[手写系列]Go手写db — — 完整教程

已于 2025-05-10 09:08:57 修改
阅读量980 收藏 27
点赞数 21
分类专栏： 教程 手写系列 go 文章标签： golang 数据库 手写数据库 教程 实战 底层原理
于 2025-05-10 09:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/147839627
版权

[手写系列]Go手写db

ZiyiDB是一个简单的内存数据库实现，支持基本的SQL操作，包含create、insert、delete、select、update、drop。目前一期暂支持int类型以及字符类型数据，后续会支持更多数据结构以及能力。本项目基于https://github.com/eatonphil/gosql灵感进行开发。

  • 项目Github地址：https://github.com/ziyifast/ZiyiDB
  • 请大家多多支持，也欢迎大家star⭐️和共同维护这个项目~

项目结构

// 项目创建
mkdir ZiyiDB
cd ZiyiDB/
go mod init ziyi.db.com

ZiyiDB/
├── cmd/
│   └── main.go           # 主程序入口
├── internal/
│   ├── ast/
│   │   └── ast.go        # 抽象语法树定义
│   ├── lexer/
│   │   ├── lexer.go      # 词法分析器实现
│   │   └── token.go      # 词法单元定义
│   ├── parser/
│   │   └── parser.go     # 语法分析器实现
│   └── storage/
│       └── memory.go     # 内存存储引擎实现
├── go.mod                # Go模块定义
└── go.sum                # 依赖版本锁定

原理介绍

流程图：
在这里插入图片描述

主要包含几大模块：

  1. cmd/main.go：
  • 程序入口点
  • 实现交互式命令行界面
  • 处理用户输入
  • 显示执行结果
  1. internal/ast/ast.go：
  • 定义抽象语法树节点
  • 定义 SQL 语句结构
  • 定义表达式结构
  1. internal/lexer/token.go：
  • 定义词法单元类型
  • 定义 SQL 关键字
  • 定义运算符和分隔符
  1. internal/lexer/lexer.go：
  • 实现词法分析器
  • 将输入文本转换为标记序列
  • 处理标识符和字面量
  1. internal/parser/parser.go：
  • 实现语法分析器
  • 将标记序列转换为抽象语法树
  • 处理各种 SQL 语句
  1. internal/storage/memory.go：
  • 实现内存存储引擎
  • 处理数据存储和检索
  • 实现索引和约束

具体实现

模块一： 词法分析器 (Lexer)

词法分析器 (Lexer)：SQL转token序列

①定义标记类型token.go
思路

新建ziyi-db/internal/lexer/token.go文件,完成词法分析器（Lexer）中的标记（Token）定义部分，用于将 SQL 语句分解成基本的语法单元。

定义词法单元以及关键字：

  • 包含常见的SQL关键字，如：select、update等
  • 包含符号关键字：=、>、<
  • 包含字段类型：INT、字符型（TEXT）
  • 包含标识符：INDENT，解析出来的SQL列名、表名
type TokenType string

const (
    SELECT  TokenType = "SELECT"
    FROM    TokenType = "FROM"
    IDENT   TokenType = "IDENT"  // 标识符（如列名、表名）
    INT_LIT TokenType = "INT"    // 整数字面量
    STRING  TokenType = "STRING" // 字符串字面量
    EQ TokenType = "=" // 等于
    GT TokenType = ">" // 大于
    LT TokenType = "<" // 小于
    ....
)

// Token 词法单元
// Type：标记的类型（如 SELECT、IDENT 等）
// Literal：标记的实际值（如具体的列名、数字等）
type Token struct {
    Type    TokenType // 标记类型
    Literal string    // 标记的实际值
}

示例：

SELECT id, name FROM users WHERE age > 18;

该SQL 语句会被下面的词法分析器lexer.go分解成以下标记序列：
{Type: SELECT, Literal: "SELECT"}
{Type: IDENT, Literal: "id"}
{Type: COMMA, Literal: ","}
{Type: IDENT, Literal: "name"}
{Type: FROM, Literal: "FROM"}
{Type: IDENT, Literal: "users"}
{Type: WHERE, Literal: "WHERE"}
{Type: IDENT, Literal: "age"}
{Type: GT, Literal: ">"}
{Type: INT_LIT, Literal: "18"}
{Type: SEMI, Literal: ";"}
解析后的标记随后会被传递给语法分析器（Parser）进行进一步处理，构建抽象语法树（AST）。
全部代码
// internal/lexer/token.go
package lexer

// TokenType 表示词法单元类型
type TokenType string

const (
    // 特殊标记
    EOF   TokenType = "EOF"   // 文件结束标记
    ERROR TokenType = "ERROR" // 错误标记

    // 关键字
    SELECT  TokenType = "SELECT"
    FROM    TokenType = "FROM"
    WHERE   TokenType = "WHERE"
    CREATE  TokenType = "CREATE"
    TABLE   TokenType = "TABLE"
    INSERT  TokenType = "INSERT"
    INTO    TokenType = "INTO"
    VALUES  TokenType = "VALUES"
    UPDATE  TokenType = "UPDATE"
    SET     TokenType = "SET"
    DELETE  TokenType = "DELETE"
    DROP    TokenType = "DROP"
    PRIMARY TokenType = "PRIMARY"
    KEY     TokenType = "KEY"
    INT     TokenType = "INT"
    TEXT    TokenType = "TEXT"
    LIKE    TokenType = "LIKE"

    // 标识符和字面量
    IDENT   TokenType = "IDENT"  // 标识符（如列名、表名）
    INT_LIT TokenType = "INT"    // 整数字面量
    STRING  TokenType = "STRING" // 字符串字面量

    // 运算符
    EQ TokenType = "="
    GT TokenType = ">"
    LT TokenType = "<"

    // 标识符
    COMMA    TokenType = ","
    SEMI     TokenType = ";"
    LPAREN   TokenType = "("
    RPAREN   TokenType = ")"
    ASTERISK TokenType = "*"
)

// Token 词法单元
// Type：标记的类型（如 SELECT、IDENT 等）
// Literal：标记的实际值（如具体的列名、数字等）
type Token struct {
    Type    TokenType // 标记类型
    Literal string    // 标记的实际值
}
② 实现词法分析器lexer.go
思路

新建ziyi-db/internal/lexer/lexer.go文件，这是词法分析器（Lexer）的核心实现，负责将输入的 SQL 语句分解成标记（Token）序列。

词法分析器lexer.go：读取SQL到内存中并进行解析，将字符转换为对应关键字

示例：

SELECT id, name FROM users WHERE age > 18;

处理过程：
跳过空白字符
读取 "SELECT" 并识别为关键字
读取 "id" 并识别为标识符
读取 "," 并识别为分隔符
读取 "name" 并识别为标识符
读取 "FROM" 并识别为关键字
读取 "users" 并识别为标识符
读取 "WHERE" 并识别为关键字
读取 "age" 并识别为标识符
读取 ">" 并识别为运算符
读取 "18" 并识别为数字
读取 ";" 并识别为分隔符
这个词法分析器是 SQL 解析器的第一步，它将输入的 SQL 语句分解成标记序列，为后续的语法分析提供基础



该SQL 语句会被词法分析器分解成以下标记序列：
{Type: SELECT, Literal: "SELECT"}
{Type: IDENT, Literal: "id"}
{Type: COMMA, Literal: ","}
{Type: IDENT, Literal: "name"}
{Type: FROM, Literal: "FROM"}
{Type: IDENT, Literal: "users"}
{Type: WHERE, Literal: "WHERE"}
{Type: IDENT, Literal: "age"}
{Type: GT, Literal: ">"}
{Type: INT_LIT, Literal: "18"}
{Type: SEMI, Literal: ";"}
解析后的标记随后会被传递给语法分析器（Parser）进行进一步处理，构建抽象语法树（AST）。
全部代码
// internal/lexer/lexer.go
package lexer

import (
    "bufio"
    "bytes"
    "io"
    "strings"
    "unicode"
)

// Lexer 词法分析器
// reader：使用 bufio.Reader 进行高效的字符读取
// ch：存储当前正在处理的字符
type Lexer struct {
    reader *bufio.Reader // 用于读取输入
    ch     rune          // 当前字符
}

// NewLexer 创建一个新的 词法分析器
// 初始化 reader 并读取第一个字符
func NewLexer(r io.Reader) *Lexer {
    l := &Lexer{
       reader: bufio.NewReader(r),
    }
    l.readChar()
    return l
}

// 读取字符
func (l *Lexer) readChar() {
    ch, _, err := l.reader.ReadRune()
    if err != nil {
       l.ch = 0 // 遇到错误或EOF时设置为0
    } else {
       l.ch = ch
    }
}

// NextToken 获取下一个词法单元
// 识别并返回下一个标记
// 处理各种类型的标记：运算符、分隔符、标识符、数字、字符串等
func (l *Lexer) NextToken() Token {
    var tok Token
    // 跳过空白字符
    l.skipWhitespace()

    switch l.ch {
    case '=':
       tok = Token{Type: EQ, Literal: "="}
    case '>':
       tok = Token{Type: GT, Literal: ">"}
    case '<':
       tok = Token{Type: LT, Literal: "<"}
    case ',':
       tok = Token{Type: COMMA, Literal: ","}
    case ';':
       tok = Token{Type: SEMI, Literal: ";"}
    case '(':
       tok = Token{Type: LPAREN, Literal: "("}
    case ')':
       tok = Token{Type: RPAREN, Literal: ")"}
    case '*':
       tok = Token{Type: ASTERISK, Literal: "*"}
    case '\'':
       tok.Type = STRING
       // 读取字符串字面量
       tok.Literal = l.readString()
       return tok
    case 0:
       tok = Token{Type: EOF, Literal: ""}
    default:
       if isLetter(l.ch) {
          // 读取标识符（表名、列名等）
          tok.Literal = l.readIdentifier()
          // 将读取到的标识符转换为对应的标记类型(转换为对应tokenType)
          tok.Type = l.lookupIdentifier(tok.Literal)
          return tok
       } else if isDigit(l.ch) {
          tok.Type = INT_LIT
          // 读取数字
          tok.Literal = l.readNumber()
          return tok
       } else {
          tok = Token{Type: ERROR, Literal: string(l.ch)}
       }
    }

    l.readChar()
    return tok
}

func (l *Lexer) skipWhitespace() {
    for unicode.IsSpace(l.ch) {
       l.readChar()
    }
}

// 读取标识符，如：列名、表名
func (l *Lexer) readIdentifier() string {
    var ident bytes.Buffer
    for isLetter(l.ch) || isDigit(l.ch) {
       ident.WriteRune(l.ch)
       l.readChar()
    }
    return ident.String()
}

func (l *Lexer) readNumber() string {
    var num bytes.Buffer
    for isDigit(l.ch) {
       num.WriteRune(l.ch)
       l.readChar()
    }
    return num.String()
}

// 读取字符串字面量
func (l *Lexer) readString() string {
    var str bytes.Buffer
    l.readChar() // 跳过开始的引号
    for l.ch != '\'' && l.ch != 0 {
       str.WriteRune(l.ch)
       l.readChar()
    }
    l.readChar() // 跳过结束的引号
    return str.String()
}

func (l *Lexer) peekChar() rune {
    ch, _, err := l.reader.ReadRune()
    if err != nil {
       return 0
    }
    l.reader.UnreadRune()
    return ch
}

// lookupIdentifier 查找标识符类型
// 将标识符转换为对应的标记类型
// 识别 SQL 关键字
func (l *Lexer) lookupIdentifier(ident string) TokenType {
    switch strings.ToUpper(ident) {
    case "SELECT":
       return SELECT
    case "FROM":
       return FROM
    case "WHERE":
       return WHERE
    case "CREATE":
       return CREATE
    case "TABLE":
       return TABLE
    case "INSERT":
       return INSERT
    case "INTO":
       return INTO
    case "VALUES":
       return VALUES
    case "UPDATE":
       return UPDATE
    case "SET":
       return SET
    case "DELETE":
       return DELETE
    case "DROP":
       return DROP
    case "PRIMARY":
       return PRIMARY
    case "KEY":
       return KEY
    case "INT":
       return INT
    case "TEXT":
       return TEXT
    case "LIKE":
       return LIKE
    default:
       return IDENT
    }
}

// 判断字符是否为字母或下划线
func isLetter(ch rune) bool {
    return unicode.IsLetter(ch) || ch == '_'
}

// 判断字符是否为数字
func isDigit(ch rune) bool {
    return unicode.IsDigit(ch)
}

模块二：抽象语法树 (AST)

思路

抽象语法树用于表示 SQL 语句的语法结构。我们需要为每种 SQL 语句定义相应的节点类型。

我们新建internal/ast/ast.go。

ast.go构建不同SQL语句的结构，以及查询结果等。
这个 AST 定义文件是 SQL 解析器的核心部分，它：

  1. 定义了所有 SQL 语句的语法结构
  2. 提供了类型安全的方式来表示 SQL 语句
  3. 支持复杂的表达式和条件
  4. 便于后续的语义分析和执行
    通过这个 AST，我们可以：
  • 验证 SQL 语句的语法正确性
  • 进行语义分析
  • 生成执行计划
  • 执行 SQL 语句

示例：

SELECT id, name FROM users WHERE age > 18;

交给语法分析器parser解析后的AST结构为：

SelectStatement
├── Fields
│   ├── Identifier{Value: "id"}
│   └── Identifier{Value: "name"}
├── TableName: "users"
└── Where
    └── BinaryExpression
        ├── Left: Identifier{Value: "age"}
        ├── Operator: ">"
        └── Right: IntegerLiteral{Value: "18"}
全部代码
package ast

import (
    "cursor-db/internal/lexer"
    "fmt"
)

// Node 表示AST中的节点
type Node interface {
    TokenLiteral() string
}

// Statement 表示SQL语句
type Statement interface {
    Node
    statementNode()
}

// Expression 表示表达式
type Expression interface {
    Node
    expressionNode()
}

// Program 表示整个SQL程序
type Program struct {
    Statements []Statement
}

// SelectStatement 表示SELECT语句
type SelectStatement struct {
    Token     lexer.Token
    Fields    []Expression
    TableName string
    Where     Expression
}

func (ss *SelectStatement) statementNode()       {}
func (ss *SelectStatement) TokenLiteral() string { return ss.Token.Literal }

// CreateTableStatement 表示CREATE TABLE语句
type CreateTableStatement struct {
    Token     lexer.Token
    TableName string
    Columns   []ColumnDefinition
}

func (cts *CreateTableStatement) statementNode()       {}
func (cts *CreateTableStatement) TokenLiteral() string { return cts.Token.Literal }

// InsertStatement 表示INSERT语句
type InsertStatement struct {
    Token     lexer.Token
    TableName string
    Values    []Expression
}

func (is *InsertStatement) statementNode()       {}
func (is *InsertStatement) TokenLiteral() string { return is.Token.Literal }

// ColumnDefinition 表示列定义
type ColumnDefinition struct {
    Name     string
    Type     string
    Primary  bool
    Nullable bool
}

// Cell 表示数据单元格
type Cell struct {
    Type      CellType
    IntValue  int32
    TextValue string
}

// CellType 表示单元格类型
type CellType int

const (
    CellTypeInt CellType = iota
    CellTypeText
)

// AsText 返回单元格的文本值
func (c *Cell) AsText() string {
    switch c.Type {
    case CellTypeInt:
       s := fmt.Sprintf("%d", c.IntValue)
       return s
    case CellTypeText:
       return c.TextValue
    default:
       return "NULL"
    }
}

// AsInt 返回单元格的整数值
func (c *Cell) AsInt() int32 {
    if c.Type == CellTypeInt {
       return c.IntValue
    }
    return 0
}

// String 返回单元格的字符串表示
func (c Cell) String() string {
    switch c.Type {
    case CellTypeInt:
       return fmt.Sprintf("%d", c.IntValue)
    case CellTypeText:
       return c.TextValue
    default:
       return "NULL"
    }
}

// Results 表示查询结果
type Results struct {
    Columns []ResultColumn
    Rows    [][]Cell
}

// ResultColumn 表示结果列
type ResultColumn struct {
    Name string
    Type string
}

// StarExpression 表示星号表达式,如：select * from users;
type StarExpression struct{}

func (se *StarExpression) expressionNode()      {}
func (se *StarExpression) TokenLiteral() string { return "*" }

// LikeExpression 表示LIKE表达式, 如 LIKE '%b'
type LikeExpression struct {
    Token   lexer.Token
    Left    Expression
    Pattern string
}

func (le *LikeExpression) expressionNode()      {}
func (le *LikeExpression) TokenLiteral() string { return le.Token.Literal }

// BinaryExpression 表示二元表达式,如比较运算,大于小于比较等
type BinaryExpression struct {
    Token    lexer.Token
    Left     Expression
    Operator string
    Right    Expression
}

func (be *BinaryExpression) expressionNode()      {}
func (be *BinaryExpression) TokenLiteral() string { return be.Token.Literal }

// IntegerLiteral 表示整数字面量
type IntegerLiteral struct {
    Token lexer.Token
    Value string
}

func (il *IntegerLiteral) expressionNode()      {}
func (il *IntegerLiteral) TokenLiteral() string { return il.Token.Literal }

// StringLiteral 表示字符串字面量
type StringLiteral struct {
    Token lexer.Token
    Value string
}

func (sl *StringLiteral) expressionNode()      {}
func (sl *StringLiteral) TokenLiteral() string { return sl.Token.Literal }

// Identifier 表示标识符（如列名）
type Identifier struct {
    Token lexer.Token
    Value string
}

func (i *Identifier) expressionNode()      {}
func (i *Identifier) TokenLiteral() string { return i.Token.Literal }

// UpdateStatement 表示UPDATE语句
type UpdateStatement struct {
    Token     lexer.Token
    TableName string
    Set       []SetClause
    Where     Expression
}

func (us *UpdateStatement) statementNode()       {}
func (us *UpdateStatement) TokenLiteral() string { return us.Token.Literal }

// SetClause 表示SET子句
type SetClause struct {
    Column string
    Value  Expression
}

// DeleteStatement 表示DELETE语句
type DeleteStatement struct {
    Token     lexer.Token
    TableName string
    Where     Expression
}

func (ds *DeleteStatement) statementNode()       {}
func (ds *DeleteStatement) TokenLiteral() string { return ds.Token.Literal }

// DropTableStatement 表示DROP TABLE语句
type DropTableStatement struct {
    Token     lexer.Token
    TableName string
}

func (ds *DropTableStatement) statementNode()       {}
func (ds *DropTableStatement) TokenLiteral() string { return ds.Token.Literal }

模块三：语法分析器 (Parser)

思路

语法分析器负责将词法分析器生成的标记序列转换为抽象语法树。将token序列构建成ast。

SQL 解析器（Parser）的实现，负责将词法分析器（Lexer）产生的标记（Token）序列转换为抽象语法树（AST）。
语法分析器SQL 数据库系统的关键组件，负责：

  • 验证 SQL 语句的语法正确性
  • 构建抽象语法树
  • 为后续的语义分析和执行提供基础

我们新建internal/parser/parser.go。

示例：

CREATE TABLE users (
    id INT PRIMARY KEY,
    name TEXT
);


解析过程：
1. 识别 CREATE 关键字
2. 解析 TABLE 关键字
3. 解析表名 "users"
4. 解析列定义：
    列名 "id"，类型 INT，主键
    列名 "name"，类型 TEXT
5. 生成 CREATE TABLE 语句的 AST
全部代码
package parser

import (
    "fmt"
    "ziyi.db.com/internal/ast"
    "ziyi.db.com/internal/lexer"
)

// Parser 表示语法分析器
// 维护当前和下一个标记，实现向前查看（lookahead）
// 记录解析过程中的错误
type Parser struct {
    l         *lexer.Lexer // 词法分析器
    curToken  lexer.Token  // 当前标记
    peekToken lexer.Token  // 下一个标记
    errors    []string     // 错误信息
}

// NewParser 创建新的语法分析器
// 初始化解析器
// 预读两个标记
func NewParser(l *lexer.Lexer) *Parser {
    p := &Parser{
       l:      l,
       errors: []string{},
    }

    // 读取两个token，设置curToken和peekToken
    p.nextToken()
    p.nextToken()

    return p
}

// nextToken 移动到下一个词法单元
func (p *Parser) nextToken() {
    p.curToken = p.peekToken
    p.peekToken = p.l.NextToken()
}

// ParseProgram 解析整个程序
// 解析整个 SQL 程序
// 循环解析每个语句直到结束
func (p *Parser) ParseProgram() (*ast.Program, error) {
    program := &ast.Program{
       Statements: []ast.Statement{},
    }

    for p.curToken.Type != lexer.EOF {
       stmt, err := p.parseStatement()
       if err != nil {
          return nil, err
       }
       if stmt != nil {
          program.Statements = append(program.Statements, stmt)
       }
       p.nextToken()
    }

    return program, nil
}

// parseStatement 解析语句
// 根据当前标记类型选择相应的解析方法
func (p *Parser) parseStatement() (ast.Statement, error) {
    switch p.curToken.Type {
    case lexer.CREATE:
       return p.parseCreateTableStatement()
    case lexer.INSERT:
       return p.parseInsertStatement()
    case lexer.SELECT:
       return p.parseSelectStatement()
    case lexer.UPDATE:
       return p.parseUpdateStatement()
    case lexer.DELETE:
       return p.parseDeleteStatement()
    case lexer.DROP:
       return p.parseDropTableStatement()
    case lexer.SEMI:
       return nil, nil
    default:
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Type)
    }
}

// parseCreateTableStatement 解析CREATE TABLE语句
// 解析表名
// 解析列定义
// 处理主键约束
func (p *Parser) parseCreateTableStatement() (*ast.CreateTableStatement, error) {
    stmt := &ast.CreateTableStatement{Token: p.curToken}

    if !p.expectPeek(lexer.TABLE) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    if !p.expectPeek(lexer.LPAREN) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    // 解析列定义
    for !p.peekTokenIs(lexer.RPAREN) {
       p.nextToken()

       if !p.curTokenIs(lexer.IDENT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }

       col := ast.ColumnDefinition{
          Name: p.curToken.Literal,
       }

       if !p.expectPeek(lexer.INT) && !p.expectPeek(lexer.TEXT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
       }

       col.Type = string(p.curToken.Type)

       if p.peekTokenIs(lexer.PRIMARY) {
          p.nextToken()
          if !p.expectPeek(lexer.KEY) {
             return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
          }
          col.Primary = true
       }

       stmt.Columns = append(stmt.Columns, col)

       if p.peekTokenIs(lexer.COMMA) {
          p.nextToken()
       }
    }

    if !p.expectPeek(lexer.RPAREN) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    return stmt, nil
}

// parseInsertStatement 解析INSERT语句
// 解析表名
// 解析 VALUES 子句
// 解析插入的值
func (p *Parser) parseInsertStatement() (*ast.InsertStatement, error) {
    stmt := &ast.InsertStatement{Token: p.curToken}

    if !p.expectPeek(lexer.INTO) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    if !p.expectPeek(lexer.VALUES) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.LPAREN) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    // 解析值列表
    for !p.peekTokenIs(lexer.RPAREN) {
       p.nextToken()

       expr, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Values = append(stmt.Values, expr)

       if p.peekTokenIs(lexer.COMMA) {
          p.nextToken()
       }
    }

    if !p.expectPeek(lexer.RPAREN) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    return stmt, nil
}

// parseSelectStatement 解析SELECT语句
// 解析选择列表
// 解析 FROM 子句
// 解析 WHERE 子句
func (p *Parser) parseSelectStatement() (*ast.SelectStatement, error) {
    stmt := &ast.SelectStatement{Token: p.curToken}

    // 解析选择列表
    for !p.peekTokenIs(lexer.FROM) {
       p.nextToken()

       if p.curToken.Type == lexer.ASTERISK {
          stmt.Fields = append(stmt.Fields, &ast.StarExpression{})
          break
       }

       expr, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Fields = append(stmt.Fields, expr)

       if p.peekTokenIs(lexer.COMMA) {
          p.nextToken()
       }
    }

    if !p.expectPeek(lexer.FROM) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    // 解析WHERE子句
    if p.peekTokenIs(lexer.WHERE) {
       p.nextToken()
       p.nextToken()

       // 解析左操作数（列名）
       if !p.curTokenIs(lexer.IDENT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }
       left := &ast.Identifier{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }

       // 解析操作符
       p.nextToken()
       operator := p.curToken

       // 处理LIKE操作符
       if p.curTokenIs(lexer.LIKE) {
          p.nextToken()
          if !p.curTokenIs(lexer.STRING) {
             return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
          }
          // 移除字符串字面量的引号
          pattern := p.curToken.Literal
          if len(pattern) >= 2 && (pattern[0] == '\'' || pattern[0] == '"') {
             pattern = pattern[1 : len(pattern)-1]
          }
          stmt.Where = &ast.LikeExpression{
             Token:   operator,
             Left:    left,
             Pattern: pattern,
          }
          return stmt, nil
       }

       // 处理其他操作符
       if !p.curTokenIs(lexer.EQ) && !p.curTokenIs(lexer.GT) && !p.curTokenIs(lexer.LT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", operator.Type)
       }

       // 解析右操作数
       p.nextToken()
       right, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Where = &ast.BinaryExpression{
          Token:    operator,
          Left:     left,
          Operator: operator.Literal,
          Right:    right,
       }
    }

    return stmt, nil
}

// parseUpdateStatement 解析UPDATE语句
// 解析表名
// 解析 SET 子句
// 解析 WHERE 子句
func (p *Parser) parseUpdateStatement() (*ast.UpdateStatement, error) {
    stmt := &ast.UpdateStatement{Token: p.curToken}

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    if !p.expectPeek(lexer.SET) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    // 解析SET子句
    for {
       p.nextToken()
       if !p.curTokenIs(lexer.IDENT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }
       column := p.curToken.Literal

       if !p.expectPeek(lexer.EQ) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
       }

       p.nextToken()
       value, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Set = append(stmt.Set, ast.SetClause{
          Column: column,
          Value:  value,
       })

       if !p.peekTokenIs(lexer.COMMA) {
          break
       }
       p.nextToken()
    }

    // 解析WHERE子句
    if p.peekTokenIs(lexer.WHERE) {
       p.nextToken()
       p.nextToken()

       // 解析左操作数（列名）
       if !p.curTokenIs(lexer.IDENT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }
       left := &ast.Identifier{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }

       // 解析操作符
       p.nextToken()
       operator := p.curToken
       if !p.curTokenIs(lexer.EQ) && !p.curTokenIs(lexer.GT) && !p.curTokenIs(lexer.LT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", operator.Type)
       }

       // 解析右操作数
       p.nextToken()
       right, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Where = &ast.BinaryExpression{
          Token:    operator,
          Left:     left,
          Operator: operator.Literal,
          Right:    right,
       }
    }

    return stmt, nil
}

// parseDeleteStatement 解析DELETE语句
// 解析表名
// 解析 WHERE 子句
func (p *Parser) parseDeleteStatement() (*ast.DeleteStatement, error) {
    stmt := &ast.DeleteStatement{Token: p.curToken}

    if !p.expectPeek(lexer.FROM) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    // 解析WHERE子句
    if p.peekTokenIs(lexer.WHERE) {
       p.nextToken()
       p.nextToken()

       // 解析左操作数（列名）
       if !p.curTokenIs(lexer.IDENT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }
       left := &ast.Identifier{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }

       // 解析操作符
       p.nextToken()
       operator := p.curToken
       if !p.curTokenIs(lexer.EQ) && !p.curTokenIs(lexer.GT) && !p.curTokenIs(lexer.LT) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", operator.Type)
       }

       // 解析右操作数
       p.nextToken()
       right, err := p.parseExpression()
       if err != nil {
          return nil, err
       }

       stmt.Where = &ast.BinaryExpression{
          Token:    operator,
          Left:     left,
          Operator: operator.Literal,
          Right:    right,
       }
    }

    return stmt, nil
}

// parseDropTableStatement 解析DROP TABLE语句
func (p *Parser) parseDropTableStatement() (*ast.DropTableStatement, error) {
    stmt := &ast.DropTableStatement{Token: p.curToken}

    if !p.expectPeek(lexer.TABLE) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }

    if !p.expectPeek(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.peekToken.Literal)
    }
    stmt.TableName = p.curToken.Literal

    return stmt, nil
}

// parseExpression 解析表达式(字面量int、string类型，标识符列名、表名等)
// 解析各种类型的表达式
// 支持字面量、标识符等
func (p *Parser) parseExpression() (ast.Expression, error) {
    switch p.curToken.Type {
    case lexer.INT_LIT:
       return &ast.IntegerLiteral{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }, nil
    case lexer.STRING:
       return &ast.StringLiteral{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }, nil
    case lexer.IDENT:
       return &ast.Identifier{
          Token: p.curToken,
          Value: p.curToken.Literal,
       }, nil
    default:
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Type)
    }
}

// curTokenIs 检查当前token是否为指定类型
func (p *Parser) curTokenIs(t lexer.TokenType) bool {
    return p.curToken.Type == t
}

// peekTokenIs 检查下一个token是否为指定类型
func (p *Parser) peekTokenIs(t lexer.TokenType) bool {
    return p.peekToken.Type == t
}

// expectPeek 检查下一个词法单元是否为预期类型
func (p *Parser) expectPeek(t lexer.TokenType) bool {
    if p.peekTokenIs(t) {
       p.nextToken()
       return true
    }
    return false
}

// parseWhereClause 解析WHERE子句
func (p *Parser) parseWhereClause() (ast.Expression, error) {
    p.nextToken()

    // 解析左操作数（列名）
    if !p.curTokenIs(lexer.IDENT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
    }
    left := &ast.Identifier{
       Token: p.curToken,
       Value: p.curToken.Literal,
    }

    // 解析操作符
    p.nextToken()
    operator := p.curToken

    // 处理LIKE操作符
    if p.curTokenIs(lexer.LIKE) {
       p.nextToken()
       if !p.curTokenIs(lexer.STRING) {
          return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", p.curToken.Literal)
       }
       // 移除字符串字面量的引号
       pattern := p.curToken.Literal
       if len(pattern) >= 2 && (pattern[0] == '\'' || pattern[0] == '"') {
          pattern = pattern[1 : len(pattern)-1]
       }
       return &ast.LikeExpression{
          Token:   operator,
          Left:    left,
          Pattern: pattern,
       }, nil
    }

    // 处理其他操作符
    if !p.curTokenIs(lexer.EQ) && !p.curTokenIs(lexer.GT) && !p.curTokenIs(lexer.LT) {
       return nil, fmt.Errorf("You have an error in your SQL syntax; check the manual that corresponds to your db server version for the right syntax to use near '%s'", operator.Type)
    }

    // 解析右操作数
    p.nextToken()
    right, err := p.parseExpression()
    if err != nil {
       return nil, err
    }

    return &ast.BinaryExpression{
       Token:    operator,
       Left:     left,
       Operator: operator.Literal,
       Right:    right,
    }, nil
}

模块四：存储引擎 (Storage)

思路

存储引擎负责实际的数据存储和检索操作,执行引擎中的数据操作CURD。

我们需要新建internal/storage/memory.go文件。

这是内存存储引擎的实现，负责处理 SQL 语句的实际执行和数据存储。

本期存储引擎实现了：

  1. 完整的数据操作（CRUD）
  2. 主键约束
  3. 索引支持
  4. 类型检查
  5. 条件评估
  6. 模式匹配

它是 SQL 数据库系统的核心组件，负责：

  • 数据存储和管理
  • 查询执行
  • 数据完整性维护
  • 性能优化（通过索引）

原理解析：

-- 创建表
CREATE TABLE users (
    id INT PRIMARY KEY,
    name TEXT
);

-- 插入数据
INSERT INTO users VALUES (1, 'Alice');

-- 查询数据
SELECT * FROM users WHERE name LIKE 'A%';

-- 更新数据
UPDATE users SET name = 'Bob' WHERE id = 1;

-- 删除数据
DELETE FROM users WHERE id = 1;


存储引擎会根据解析后的语法分析器，创建出对应的数据结构（如：在内存中），以及对外暴露对该数据的操作（CRUD）
全部代码
// internal/storage/memory.go
package storage

import (
    "fmt"
    "regexp"
    "strconv"
    "strings"
    "ziyi.db.com/internal/ast"
)

// MemoryBackend 内存存储引擎，管理所有表
type MemoryBackend struct {
    tables map[string]*Table
}

// Table 数据表，包含列定义、数据行和索引
type Table struct {
    Name    string
    Columns []ast.ColumnDefinition
    Rows    [][]ast.Cell
    Indexes map[string]*Index // 值到行索引的映射
}

// Index 索引，用于加速查询
type Index struct {
    Column string
    Values map[string][]int // 值到行索引的映射
}

// NewMemoryBackend 创建新的内存存储引擎
func NewMemoryBackend() *MemoryBackend {
    return &MemoryBackend{
       tables: make(map[string]*Table),
    }
}

// CreateTable 创建表
// 验证表名唯一性
// 创建表结构
// 为主键列创建索引
func (b *MemoryBackend) CreateTable(stmt *ast.CreateTableStatement) error {
    if _, exists := b.tables[stmt.TableName]; exists {
       return fmt.Errorf("Table '%s' already exists", stmt.TableName)
    }

    table := &Table{
       Name:    stmt.TableName,
       Columns: stmt.Columns,
       Rows:    make([][]ast.Cell, 0),
       Indexes: make(map[string]*Index),
    }

    // 为主键创建索引
    for _, col := range stmt.Columns {
       if col.Primary {
          table.Indexes[col.Name] = &Index{
             Column: col.Name,
             Values: make(map[string][]int),
          }
       }
    }

    b.tables[stmt.TableName] = table
    return nil
}

// Insert 插入数据
// 验证表存在性
// 检查数据完整性
// 处理主键约束
// 维护索引
func (b *MemoryBackend) Insert(stmt *ast.InsertStatement) error {
    table, exists := b.tables[stmt.TableName]
    if !exists {
       return fmt.Errorf("Table '%s' doesn't exist", stmt.TableName)
    }

    if len(stmt.Values) != len(table.Columns) {
       return fmt.Errorf("Column count doesn't match value count at row 1")
    }

    // 转换值
    row := make([]ast.Cell, len(stmt.Values))
    for i, expr := range stmt.Values {
       value, err := evaluateExpression(expr)
       if err != nil {
          return err
       }

       switch v := value.(type) {
       case string:
          if table.Columns[i].Type == "INT" {
             // 尝试将字符串转换为整数
             intVal, err := strconv.ParseInt(v, 10, 32)
             if err != nil {
                return fmt.Errorf("Incorrect integer value: '%s' for column '%s'", v, table.Columns[i].Name)
             }
             row[i] = ast.Cell{Type: ast.CellTypeInt, IntValue: int32(intVal)}
          } else {
             row[i] = ast.Cell{Type: ast.CellTypeText, TextValue: v}
          }
       case int32:
          row[i] = ast.Cell{Type: ast.CellTypeInt, IntValue: v}
       default:
          return fmt.Errorf("Unsupported value type: %T for column '%s'", value, table.Columns[i].Name)
       }
    }

    // 检查主键约束
    for i, col := range table.Columns {
       if col.Primary {
          key := row[i].String()
          if _, exists := table.Indexes[col.Name].Values[key]; exists {
             return fmt.Errorf("Duplicate entry '%s' for key '%s'", key, col.Name)
          }
       }
    }

    // 插入数据
    rowIndex := len(table.Rows)
    table.Rows = append(table.Rows, row)

    // 更新索引
    for i, col := range table.Columns {
       if col.Primary {
          key := row[i].String()
          table.Indexes[col.Name].Values[key] = append(table.Indexes[col.Name].Values[key], rowIndex)
       }
    }

    return nil
}

// Select 查询数据
// 支持 SELECT * 和指定列
// 处理 WHERE 条件
// 返回查询结果
func (b *MemoryBackend) Select(stmt *ast.SelectStatement) (*ast.Results, error) {
    table, exists := b.tables[stmt.TableName]
    if !exists {
       return nil, fmt.Errorf("Table '%s' doesn't exist", stmt.TableName)
    }

    results := &ast.Results{
       Columns: make([]ast.ResultColumn, 0),
       Rows:    make([][]ast.Cell, 0),
    }

    // 处理选择列表
    if len(stmt.Fields) == 1 && stmt.Fields[0].(*ast.StarExpression) != nil {
       // SELECT *
       for _, col := range table.Columns {
          results.Columns = append(results.Columns, ast.ResultColumn{
             Name: col.Name,
             Type: col.Type,
          })
       }
    } else {
       // 处理指定的列
       for _, expr := range stmt.Fields {
          switch e := expr.(type) {
          case *ast.Identifier:
             // 查找列
             found := false
             for _, col := range table.Columns {
                if col.Name == e.Value {
                   results.Columns = append(results.Columns, ast.ResultColumn{
                      Name: col.Name,
                      Type: col.Type,
                   })
                   found = true
                   break
                }
             }
             if !found {
                return nil, fmt.Errorf("Unknown column '%s' in 'field list'", e.Value)
             }
          default:
             return nil, fmt.Errorf("Unsupported select expression type")
          }
       }
    }

    // 处理WHERE子句
    for _, row := range table.Rows {
       if stmt.Where != nil {
          match, err := evaluateWhereCondition(stmt.Where, row, table.Columns)
          if err != nil {
             return nil, err
          }
          if !match {
             continue
          }
       }

       // 构建结果行
       resultRow := make([]ast.Cell, len(results.Columns))
       for j, col := range results.Columns {
          // 查找列在原始行中的位置
          for k, tableCol := range table.Columns {
             if tableCol.Name == col.Name {
                resultRow[j] = row[k]
                break
             }
          }
       }
       results.Rows = append(results.Rows, resultRow)
    }

    return results, nil
}

// Update 执行UPDATE操作
// 验证表和列存在性
// 处理 WHERE 条件
// 更新符合条件的行
func (mb *MemoryBackend) Update(stmt *ast.UpdateStatement) error {
    table, ok := mb.tables[stmt.TableName]
    if !ok {
       return fmt.Errorf("Table '%s' doesn't exist", stmt.TableName)
    }

    // 获取列索引
    columnIndices := make(map[string]int)
    for i, col := range table.Columns {
       columnIndices[col.Name] = i
    }

    // 验证所有要更新的列是否存在
    for _, set := range stmt.Set {
       if _, ok := columnIndices[set.Column]; !ok {
          return fmt.Errorf("Unknown column '%s' in 'field list'", set.Column)
       }
    }

    // 更新符合条件的行
    for i := range table.Rows {
       if stmt.Where != nil {
          // 评估WHERE条件
          result, err := evaluateWhereCondition(stmt.Where, table.Rows[i], table.Columns)
          if err != nil {
             return err
          }
          if !result {
             continue
          }
       }

       // 更新行
       for _, set := range stmt.Set {
          colIndex := columnIndices[set.Column]
          value, err := evaluateExpression(set.Value)
          if err != nil {
             return err
          }

          switch v := value.(type) {
          case int32:
             table.Rows[i][colIndex] = ast.Cell{Type: ast.CellTypeInt, IntValue: v}
          case string:
             table.Rows[i][colIndex] = ast.Cell{Type: ast.CellTypeText, TextValue: v}
          default:
             return fmt.Errorf("Unsupported value type: %T for column '%s'", value, set.Column)
          }
       }
    }

    return nil
}

// Delete 执行DELETE操作
// 验证表存在性
// 处理 WHERE 条件
// 删除符合条件的行
func (mb *MemoryBackend) Delete(stmt *ast.DeleteStatement) error {
    table, ok := mb.tables[stmt.TableName]
    if !ok {
       return fmt.Errorf("Table '%s' doesn't exist", stmt.TableName)
    }

    // 找出要删除的行
    rowsToDelete := make([]int, 0)
    for i := range table.Rows {
       if stmt.Where != nil {
          // 评估WHERE条件
          result, err := evaluateWhereCondition(stmt.Where, table.Rows[i], table.Columns)
          if err != nil {
             return err
          }
          if !result {
             continue
          }
       }
       rowsToDelete = append(rowsToDelete, i)
    }

    // 从后向前删除行，以避免索引变化
    for i := len(rowsToDelete) - 1; i >= 0; i-- {
       rowIndex := rowsToDelete[i]
       table.Rows = append(table.Rows[:rowIndex], table.Rows[rowIndex+1:]...)
    }

    return nil
}

// DropTable 删除表
// 验证表是否存在
// 从存储引擎中删除表
func (mb *MemoryBackend) DropTable(stmt *ast.DropTableStatement) error {
    if _, exists := mb.tables[stmt.TableName]; !exists {
       return fmt.Errorf("Unknown table '%s'", stmt.TableName)
    }

    delete(mb.tables, stmt.TableName)
    return nil
}

// evaluateExpression 评估表达式的值
// 计算表达式的值
// 处理不同类型的数据
func evaluateExpression(expr ast.Expression) (interface{}, error) {
    switch e := expr.(type) {
    case *ast.IntegerLiteral:
       val, err := strconv.ParseInt(e.Value, 10, 32)
       if err != nil {
          return nil, fmt.Errorf("Incorrect integer value: '%s'", e.Value)
       }
       return int32(val), nil
    case *ast.StringLiteral:
       return e.Value, nil
    case *ast.Identifier:
       return nil, fmt.Errorf("Cannot evaluate identifier: '%s'", e.Value)
    default:
       return nil, fmt.Errorf("Unknown expression type: %T", expr)
    }
}

// matchLikePattern 检查字符串是否匹配LIKE模式
func matchLikePattern(str, pattern string) bool {
    // 将SQL LIKE模式转换为正则表达式
    regexPattern := "^"
    for i := 0; i < len(pattern); i++ {
       switch pattern[i] {
       case '%':
          regexPattern += ".*"
       case '_':
          regexPattern += "."
       case '\\':
          if i+1 < len(pattern) {
             regexPattern += "\\" + string(pattern[i+1])
             i++
          }
       default:
          // 转义正则表达式特殊字符
          if strings.ContainsAny(string(pattern[i]), ".+*?^$()[]{}|") {
             regexPattern += "\\" + string(pattern[i])
          } else {
             regexPattern += string(pattern[i])
          }
       }
    }
    regexPattern += "$"

    // 编译正则表达式
    re, err := regexp.Compile(regexPattern)
    if err != nil {
       return false
    }

    // 执行匹配
    return re.MatchString(str)
}

// evaluateWhereCondition 评估WHERE条件
// 评估 WHERE 条件
// 支持比较运算符和 LIKE 操作符
func evaluateWhereCondition(expr ast.Expression, row []ast.Cell, columns []ast.ColumnDefinition) (bool, error) {
    switch e := expr.(type) {
    case *ast.BinaryExpression:
       // 获取左操作数的值
       leftValue, err := getColumnValue(e.Left, row, columns)
       if err != nil {
          return false, err
       }

       // 获取右操作数的值
       rightValue, err := getColumnValue(e.Right, row, columns)
       if err != nil {
          return false, err
       }

       // 根据操作符比较值
       switch e.Operator {
       case "=":
          return compareValues(leftValue, rightValue, "=")
       case ">":
          return compareValues(leftValue, rightValue, ">")
       case "<":
          return compareValues(leftValue, rightValue, "<")
       default:
          return false, fmt.Errorf("Unknown operator: '%s'", e.Operator)
       }
    case *ast.LikeExpression:
       // 获取左操作数的值
       leftValue, err := getColumnValue(e.Left, row, columns)
       if err != nil {
          return false, err
       }

       // 确保左操作数是字符串类型
       strValue, ok := leftValue.(string)
       if !ok {
          return false, fmt.Errorf("LIKE operator requires string operand")
       }

       // 执行LIKE匹配
       return matchLikePattern(strValue, e.Pattern), nil
    default:
       return false, fmt.Errorf("Unknown expression type: %T", expr)
    }
}

// compareValues 比较两个值
func compareValues(left, right interface{}, operator string) (bool, error) {
    switch l := left.(type) {
    case int32:
       if r, ok := right.(int32); ok {
          switch operator {
          case "=":
             return l == r, nil
          case ">":
             return l > r, nil
          case "<":
             return l < r, nil
          }
       }
    case string:
       if r, ok := right.(string); ok {
          switch operator {
          case "=":
             return l == r, nil
          case ">":
             return l > r, nil
          case "<":
             return l < r, nil
          }
       }
    }
    return false, fmt.Errorf("Cannot compare values of different types: %T and %T", left, right)
}

// getColumnValue 获取列的值
func getColumnValue(expr ast.Expression, row []ast.Cell, columns []ast.ColumnDefinition) (interface{}, error) {
    switch e := expr.(type) {
    case *ast.Identifier:
       // 查找列索引
       for i, col := range columns {
          if col.Name == e.Value {
             switch row[i].Type {
             case ast.CellTypeInt:
                return row[i].IntValue, nil
             case ast.CellTypeText:
                return row[i].TextValue, nil
             default:
                return nil, fmt.Errorf("Unknown cell type: %v", row[i].Type)
             }
          }
       }
       return nil, fmt.Errorf("Unknown column '%s' in 'where clause'", e.Value)
    case *ast.IntegerLiteral:
       val, err := strconv.ParseInt(e.Value, 10, 32)
       if err != nil {
          return nil, fmt.Errorf("Incorrect integer value: '%s'", e.Value)
       }
       return int32(val), nil
    case *ast.StringLiteral:
       return e.Value, nil
    default:
       return nil, fmt.Errorf("Unknown expression type: %T", expr)
    }
}

//后续拓展新的存储引擎，如落地到文件...

模块五：REPL 交互界面

思路

最后，我们需要实现一个交互式的命令行界面，让用户可以输入 SQL 命令并查看结果。
这是 ZiyiDB 的主程序，实现了一个交互式的 SQL 命令行界面。

为了实现客户端可以上下翻找之前执行的命令以及cli客户端的美观，我们这里使用"github.com/c-bata/go-prompt"库

// 安装依赖
go get "github.com/c-bata/go-prompt"

我们需要新建cmd/main.go文件。

主要实现：

  1. 交互式命令行界面
  2. SQL 命令解析和执行
  3. 命令历史记录
  4. 查询结果格式化
  5. 错误处理和提示
全部代码
package main

import (
    "fmt"
    "github.com/c-bata/go-prompt"
    "os"
    "strings"
    "ziyi.db.com/internal/ast"
    "ziyi.db.com/internal/lexer"
    "ziyi.db.com/internal/parser"
    "ziyi.db.com/internal/storage"
)

var history []string               // 存储命令历史
var backend *storage.MemoryBackend // 存储引擎实例
var historyIndex int               // 当前历史记录索引

// 处理用户输入的命令
func executor(t string) {
    t = strings.TrimSpace(t)
    if t == "" {
       return
    }

    // 添加到历史记录
    history = append(history, t)
    historyIndex = len(history) // 重置历史记录索引

    // 处理退出命令
    if strings.ToLower(t) == "exit" {
       fmt.Println("Bye!")
       os.Exit(0)
    }

    // 创建词法分析器
    l := lexer.NewLexer(strings.NewReader(t))

    // 创建语法分析器
    p := parser.NewParser(l)

    // 解析SQL语句
    stmt, err := p.ParseProgram()
    if err != nil {
       fmt.Printf("Parse error: %v\n", err)
       return
    }

    // 执行SQL语句
    for _, statement := range stmt.Statements {
       switch s := statement.(type) {
       case *ast.CreateTableStatement:
          if err := backend.CreateTable(s); err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             fmt.Println("Table created successfully")
          }
       case *ast.InsertStatement:
          if err := backend.Insert(s); err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             fmt.Println("1 row inserted")
          }
       case *ast.SelectStatement:
          results, err := backend.Select(s)
          if err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             // 计算每列的最大宽度
             colWidths := make([]int, len(results.Columns))
             for i, col := range results.Columns {
                colWidths[i] = len(col.Name)
             }
             for _, row := range results.Rows {
                for i, cell := range row {
                   cellLen := len(cell.String())
                   if cellLen > colWidths[i] {
                      colWidths[i] = cellLen
                   }
                }
             }

             // 打印表头
             fmt.Print("+")
             for _, width := range colWidths {
                fmt.Print(strings.Repeat("-", width+2))
                fmt.Print("+")
             }
             fmt.Println()

             // 打印列名
             fmt.Print("|")
             for i, col := range results.Columns {
                fmt.Printf(" %-*s |", colWidths[i], col.Name)
             }
             fmt.Println()

             // 打印分隔线
             fmt.Print("+")
             for _, width := range colWidths {
                fmt.Print(strings.Repeat("-", width+2))
                fmt.Print("+")
             }
             fmt.Println()

             // 打印数据行
             for _, row := range results.Rows {
                fmt.Print("|")
                for i, cell := range row {
                   fmt.Printf(" %-*s |", colWidths[i], cell.String())
                }
                fmt.Println()
             }

             // 打印底部边框
             fmt.Print("+")
             for _, width := range colWidths {
                fmt.Print(strings.Repeat("-", width+2))
                fmt.Print("+")
             }
             fmt.Println()

             // 打印行数统计
             fmt.Printf("%d rows in set\n", len(results.Rows))
          }
       case *ast.UpdateStatement:
          if err := backend.Update(s); err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             fmt.Println("Query OK, 1 row affected")
          }
       case *ast.DeleteStatement:
          if err := backend.Delete(s); err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             fmt.Println("Query OK, 1 row affected")
          }
       case *ast.DropTableStatement:
          if err := backend.DropTable(s); err != nil {
             fmt.Printf("Error: %v\n", err)
          } else {
             fmt.Println("Table dropped successfully")
          }
       default:
          fmt.Printf("Unsupported statement type: %T\n", s)
       }
    }
}

// 提供命令补全功能
func completer(d prompt.Document) []prompt.Suggest {
    s := []prompt.Suggest{}
    return prompt.FilterHasPrefix(s, d.GetWordBeforeCursor(), true)
}

func main() {
    // 初始化存储引擎
    backend = storage.NewMemoryBackend()
    historyIndex = 0

    fmt.Println("Welcome to ZiyiDB!")
    fmt.Println("Type your SQL commands (type 'exit' to quit)")

    p := prompt.New(
       executor,
       completer,
       prompt.OptionTitle("ZiyiDB: A Simple SQL Database"),
       prompt.OptionPrefix("ziyidb> "),
       prompt.OptionHistory(history),
       prompt.OptionLivePrefix(func() (string, bool) {
          return "ziyidb> ", true
       }),
       //实现方向键上下翻阅历史命令
       // 上键绑定
       prompt.OptionAddKeyBind(prompt.KeyBind{
          Key: prompt.Up,
          Fn: func(buf *prompt.Buffer) {
             if historyIndex > 0 {
                historyIndex--
                buf.DeleteBeforeCursor(len(buf.Text()))
                buf.InsertText(history[historyIndex], false, true)
             }
          },
       }),
       // 下键绑定
       prompt.OptionAddKeyBind(prompt.KeyBind{
          Key: prompt.Down,
          Fn: func(buf *prompt.Buffer) {
             if historyIndex < len(history)-1 {
                historyIndex++
                buf.DeleteBeforeCursor(len(buf.Text()))
                buf.InsertText(history[historyIndex], false, true)
             } else if historyIndex == len(history)-1 {
                historyIndex++
                buf.DeleteBeforeCursor(len(buf.Text()))
             }
          },
       }),
    )
    p.Run()
}

整体测试

编写完第一版后，现在我们来整体测试一下。

测试脚本

test_cast.sql：

-- 1. 创建表
CREATE TABLE users (id INT PRIMARY KEY,name TEXT ,age INT);


-- 2. 插入用户数据
INSERT INTO users VALUES (1, 'Alice', 20);
INSERT INTO users VALUES (2, 'Bob', 25);
INSERT INTO users VALUES (3, 'Charlie', 30);
INSERT INTO users VALUES (4, 'David', 35);
INSERT INTO users VALUES (5, 'Eve', 40);

-- 3. 测试主键冲突
INSERT INTO users VALUES (1, 'Tomas', 21);


-- 4. 基本查询测试
-- 4.1 查询所有数据
SELECT * FROM users;


-- 4.2 查询特定列
SELECT id, name FROM users;

-- 5. WHERE 子句测试
SELECT * FROM users WHERE age > 25;
SELECT * FROM users WHERE age < 30;

-- 6. LIKE 操作符测试
-- 6.1 基本模式匹配
SELECT * FROM users WHERE name LIKE 'A%';  -- 以 A 开头
SELECT * FROM users WHERE name LIKE '%e';  -- 以 e 结尾

-- 6.2 转义字符测试
INSERT INTO users VALUES (6, 'Bob%Smith', 45);
SELECT * FROM users WHERE name LIKE 'Bob\%Smith';

-- 7. 更新操作测试
-- 7.1 更新单个字段
UPDATE users SET age = 21 WHERE name = 'Alice';

-- 7.2 更新多个字段
UPDATE users SET name = 'Robert', age = 8 WHERE id = 2;


-- 8. 删除操作测试
DELETE FROM users WHERE age > 30;

-- 9. 清理测试数据
DROP TABLE users;

-- 10. 验证表已删除
SELECT * FROM users;    -- 应该失败


todo::
    1. 实现!= >= <=等运算符
    2. 支持更多数据类型
    3. 支持更多函数
    4. 优化查询结果展示
    5. 支持更多索引类型
    6. 支持null值等
    7. 支持数据落地本地文件
    8. 支持事务操作等

运行效果

cd ZiyiDB
go run cmd/main.go

在这里插入图片描述

参考文章：
https://notes.eatonphil.com/database-basics.html

Spring Boot进阶(107)：这年头谁还手写逻辑删除，一个注解@TableLogic搞定！
**My Coding Family**
12-31 1611
🏆本文收录于「滚雪球学SpringBoot」专栏，手把手带你零基础入门Spring Boot，从入门到就业，助你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
【Go语言实战】(23)封装一个加密包，让敏感数据更易脱敏 【 Golang | Go语言】
面向生活编程
10-12 2040
提供 对称加密 AES、DES、3DES 以及非对称加密 RSA 的上层封装接口，让您的敏感数据更加容易脱敏并存储
前端手写系列
越思考越清晰
12-07 2201
js原生类 效果
go手写Redis(7)之Handler实现
何忆清风
05-23 689
go实现redis之handler处理器的实现
手写体识别代码_Python识别图片中的文字
weixin_39737757的博客
12-16 894
一、前言不知道大家有没有遇到过这样的问题，就是在某个软件或者某个网页里面有一篇文章，你非常喜欢，但是不能复制。或者像百度文档一样，只能复制一部分，这个时候我们就会选择截图保存。但是当我们想用到里面的文字时，还是要一个字一个字打出来。那么我们能不能直接识别图片中的文字呢？答案是肯定的。二、Tesseract文字识别是ORC的一部分内容，ORC的意思是光学字符识别，通俗讲就是文字识别。Tes...
手写数字数据集_Python神经网络编程：手写数字的数据集MNIST
weixin_40007016的博客
12-17 1267
识别人的笔迹这个问题相对复杂，也非常模糊，因此这是一种检验人工智能的理想挑战。这不像进行大量数字相乘那样明确清晰。让计算机准确区分图像中包含的内容，有时也称之为图像识别问题。科学家对这个问题进行了几十年的研究，直到最近，才取得了一些比较好的进展，如神经网络这样的方法则是构成这些飞跃的重要部分。为了让你对图像识别究竟有多难有一个感性认识，举个例子，人类有时候对图像中包含的内容有不同意见。人们很容易对...
手写简化版数据库--MYDB
qq_41911251的博客
07-22 4946
例如第一章Python机器学习入门之pandas的使用。
【Go语言学习系列35】数据库编程（二）：ORM技术
GopherTribe的博客
03-28 799
深入介绍Go语言中的ORM技术，特别是GORM库的使用，包括模型定义、CRUD操作、关联关系处理、事务支持等功能，以及ORM最佳实践与性能优化
Go日记——手写一个资源池
饥渴计科极客杰铿的博客
12-08 489
本文转自http://www.flysnow.org/2017/05/01/go-in-action-go-pool.html 《Go语言实战》读书笔记，未完待续，欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/，第一时间看后续笔记。觉得有帮助的话，顺手分享到朋友圈吧，感谢支持。这篇文章演示使用有缓冲的通道实现一个资源池，这个资源池可以管理在任意多个go
go手写Redis(9)之Aof消息落盘和消息重放
何忆清风
05-24 560
go实现redis中的aof功能
php 手写MVC
Able
08-30 361
1什么是MVC MVC模式（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。 PHP中MVC模式也称Web MVC，从上世纪70年代进化而来。MVC的目的是实现一种动态的程序设计，便于后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。除此之外，此模式通过对复杂度的简化，使程序结构更加直观。 MVC各部分的职能： 模型Model– 管理大部分的业务逻辑和所有..
手写Redis缓存系统，第三章：持久化-增加可靠性
lixiemang8887的博客
08-11 508
写放大系数主要通过减少写入数据的额外操作（如压缩、合并）来优化。读放大系数可以通过增加缓存和减少读取的文件数量来优化。空间放大系数则可以通过合理的压缩和减少冗余数据来控制。通过调优 RocksDB 的这些配置参数，可以在不同的使用场景下达到最佳的性能和平衡点。
Go语言ORM实用教程：简化Web开发流程
[Go语言ORM实用教程：简化Web开发流程](https://opengraph.githubassets.com/71841e2d1357d7ea300c28b7d33a03aff7e6f4b9a194d92183423d60d43accf0/go-gorm/gorm) # 摘要 本文对Go语言ORM框架进行了全面概述，分析了...
深入k8s监控检查源码之手写ping指令
weixin_42063529的博客
12-08 819
手写
GoWeb开发(基础)
2401_85592408的博客
05-09 793
请求处理：通过 `r.Method` 获取请求方法，`r.URL` 解析路径和参数。r.DELETE("/users/:id", deleteUser) // 删除用户。r.GET("/users", getUsers) // 获取用户列表。r.GET("/users/:id", getUser) // 获取单个用户。r.POST("/users", createUser) // 创建用户。r.PUT("/users/:id", updateUser) // 更新用户。
Go语言运算符详解
最新发布
qq_58662768的博客
05-11 732
Go语言提供了与其他语言类似的运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等。这些运算符即可满足基本的运算需求。
C++GO语言微服务基础技术①
qq_27302885的博客
05-08 867
C++GO语言微服务基础技术①
Go语言中sync.Mutex的作用
a_1940562的博客
05-08 659
因此，在RequestNotify中使用connLock.Lock()和Unlock()是必要的，以确保在修改或读取conn时不会有其他goroutine同时进行，避免竞态条件。在RequestRegister函数中使用Lock和UnLock之后，在RequestNotify函数中可以使用相同的connLock进行加锁和解锁，可以有效保护共享资源conn，避免并发访问导致的问题。在使用互斥锁时，必须确保在函数的所有退出路径中都释放锁，包括在发生错误时。避免在锁内调用其他可能获取同一锁的函数（防止递归锁）
golang常用库之-protojson 库（json.Marshal 和 protojson.Marshal 序列化对比）
西京刀客
05-10 987
跨语言与跨平台交互需要遵守 Protobuf 的规范，尤其是和 gRPC-Gateway、Google APIs, Istio, Cloud 原生等生态协作时。protojson 的行为是 Protobuf 官方定义的 JSON 行为，兼容性和正确性才有保证。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值