Go手寫數(shù)據(jù)庫ZiyiDB的實現(xiàn)

更新時間：2025年05月25日 10:31:24 作者：NPE~

本文主要介紹了Go手寫數(shù)據(jù)庫ZiyiDB的實現(xiàn),文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

ZiyiDB是一個簡單的內(nèi)存數(shù)據(jù)庫實現(xiàn)，支持基本的SQL操作，包含create、insert、delete、select、update、drop。目前一期暫支持int類型以及字符類型數(shù)據(jù)，后續(xù)會支持更多數(shù)據(jù)結(jié)構(gòu)以及能力。本項目基于https://github.com/eatonphil/gosql靈感進行開發(fā)。

項目Github地址：https://github.com/ziyifast/ZiyiDB

項目結(jié)構(gòu)

// 項目創(chuàng)建
mkdir ZiyiDB
cd ZiyiDB/
go mod init ziyi.db.com

ZiyiDB/
├── cmd/
│   └── main.go           # 主程序入口
├── internal/
│   ├── ast/
│   │   └── ast.go        # 抽象語法樹定義
│   ├── lexer/
│   │   ├── lexer.go      # 詞法分析器實現(xiàn)
│   │   └── token.go      # 詞法單元定義
│   ├── parser/
│   │   └── parser.go     # 語法分析器實現(xiàn)
│   └── storage/
│       └── memory.go     # 內(nèi)存存儲引擎實現(xiàn)
├── go.mod                # Go模塊定義
└── go.sum                # 依賴版本鎖定

原理介紹

流程圖：

在這里插入圖片描述

主要包含幾大模塊：

cmd/main.go：

程序入口點
實現(xiàn)交互式命令行界面
處理用戶輸入
顯示執(zhí)行結(jié)果

internal/ast/ast.go：

定義抽象語法樹節(jié)點
定義 SQL 語句結(jié)構(gòu)
定義表達(dá)式結(jié)構(gòu)

internal/lexer/token.go：

定義詞法單元類型
定義 SQL 關(guān)鍵字
定義運算符和分隔符

internal/lexer/lexer.go：

實現(xiàn)詞法分析器
將輸入文本轉(zhuǎn)換為標(biāo)記序列
處理標(biāo)識符和字面量

internal/parser/parser.go：

實現(xiàn)語法分析器
將標(biāo)記序列轉(zhuǎn)換為抽象語法樹
處理各種 SQL 語句

internal/storage/memory.go：

實現(xiàn)內(nèi)存存儲引擎
處理數(shù)據(jù)存儲和檢索
實現(xiàn)索引和約束

具體實現(xiàn)

模塊一：詞法分析器 (Lexer)

詞法分析器 (Lexer)：SQL轉(zhuǎn)token序列

①定義標(biāo)記類型token.go

思路

新建ziyi-db/internal/lexer/token.go文件,完成詞法分析器（Lexer）中的標(biāo)記（Token）定義部分，用于將 SQL 語句分解成基本的語法單元。

定義詞法單元以及關(guān)鍵字：

包含常見的SQL關(guān)鍵字，如：select、update等
包含符號關(guān)鍵字：=、>、<
包含字段類型：INT、字符型（TEXT）
包含標(biāo)識符：INDENT，解析出來的SQL列名、表名

type TokenType string

const (
    SELECT  TokenType = "SELECT"
    FROM    TokenType = "FROM"
    IDENT   TokenType = "IDENT"  // 標(biāo)識符（如列名、表名）
    INT_LIT TokenType = "INT"    // 整數(shù)字面量
    STRING  TokenType = "STRING" // 字符串字面量
    EQ TokenType = "=" // 等于
    GT TokenType = ">" // 大于
    LT TokenType = "<" // 小于
    ....
)

// Token 詞法單元
// Type：標(biāo)記的類型（如 SELECT、IDENT 等）
// Literal：標(biāo)記的實際值（如具體的列名、數(shù)字等）
type Token struct {
    Type    TokenType // 標(biāo)記類型
    Literal string    // 標(biāo)記的實際值
}

示例：

SELECT id, name FROM users WHERE age > 18;

該SQL 語句會被下面的詞法分析器lexer.go分解成以下標(biāo)記序列：
{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: ";"}
解析后的標(biāo)記隨后會被傳遞給語法分析器（Parser）進行進一步處理，構(gòu)建抽象語法樹（AST）。

全部代碼

// internal/lexer/token.go
package lexer

// TokenType 表示詞法單元類型
type TokenType string

const (
    // 特殊標(biāo)記
    EOF   TokenType = "EOF"   // 文件結(jié)束標(biāo)記
    ERROR TokenType = "ERROR" // 錯誤標(biāo)記

    // 關(guān)鍵字
    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"

    // 標(biāo)識符和字面量
    IDENT   TokenType = "IDENT"  // 標(biāo)識符（如列名、表名）
    INT_LIT TokenType = "INT"    // 整數(shù)字面量
    STRING  TokenType = "STRING" // 字符串字面量

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

    // 標(biāo)識符
    COMMA    TokenType = ","
    SEMI     TokenType = ";"
    LPAREN   TokenType = "("
    RPAREN   TokenType = ")"
    ASTERISK TokenType = "*"
)

// Token 詞法單元
// Type：標(biāo)記的類型（如 SELECT、IDENT 等）
// Literal：標(biāo)記的實際值（如具體的列名、數(shù)字等）
type Token struct {
    Type    TokenType // 標(biāo)記類型
    Literal string    // 標(biāo)記的實際值
}

② 實現(xiàn)詞法分析器lexer.go

思路

新建ziyi-db/internal/lexer/lexer.go文件，這是詞法分析器（Lexer）的核心實現(xiàn)，負(fù)責(zé)將輸入的 SQL 語句分解成標(biāo)記（Token）序列。

詞法分析器lexer.go：讀取SQL到內(nèi)存中并進行解析，將字符轉(zhuǎn)換為對應(yīng)關(guān)鍵字

示例：

SELECT id, name FROM users WHERE age > 18;

處理過程：
跳過空白字符
讀取 "SELECT" 并識別為關(guān)鍵字
讀取 "id" 并識別為標(biāo)識符
讀取 "," 并識別為分隔符
讀取 "name" 并識別為標(biāo)識符
讀取 "FROM" 并識別為關(guān)鍵字
讀取 "users" 并識別為標(biāo)識符
讀取 "WHERE" 并識別為關(guān)鍵字
讀取 "age" 并識別為標(biāo)識符
讀取 ">" 并識別為運算符
讀取 "18" 并識別為數(shù)字
讀取 ";" 并識別為分隔符
這個詞法分析器是 SQL 解析器的第一步，它將輸入的 SQL 語句分解成標(biāo)記序列，為后續(xù)的語法分析提供基礎(chǔ)



該SQL 語句會被詞法分析器分解成以下標(biāo)記序列：
{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: ";"}
解析后的標(biāo)記隨后會被傳遞給語法分析器（Parser）進行進一步處理，構(gòu)建抽象語法樹（AST）。

全部代碼

// internal/lexer/lexer.go
package lexer

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

// Lexer 詞法分析器
// reader：使用 bufio.Reader 進行高效的字符讀取
// ch：存儲當(dāng)前正在處理的字符
type Lexer struct {
    reader *bufio.Reader // 用于讀取輸入
    ch     rune          // 當(dāng)前字符
}

// NewLexer 創(chuàng)建一個新的 詞法分析器
// 初始化 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時設(shè)置為0
    } else {
       l.ch = ch
    }
}

// NextToken 獲取下一個詞法單元
// 識別并返回下一個標(biāo)記
// 處理各種類型的標(biāo)記：運算符、分隔符、標(biāo)識符、數(shù)字、字符串等
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) {
          // 讀取標(biāo)識符（表名、列名等）
          tok.Literal = l.readIdentifier()
          // 將讀取到的標(biāo)識符轉(zhuǎn)換為對應(yīng)的標(biāo)記類型(轉(zhuǎn)換為對應(yīng)tokenType)
          tok.Type = l.lookupIdentifier(tok.Literal)
          return tok
       } else if isDigit(l.ch) {
          tok.Type = INT_LIT
          // 讀取數(shù)字
          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()
    }
}

// 讀取標(biāo)識符，如：列名、表名
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() // 跳過結(jié)束的引號
    return str.String()
}

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

// lookupIdentifier 查找標(biāo)識符類型
// 將標(biāo)識符轉(zhuǎn)換為對應(yīng)的標(biāo)記類型
// 識別 SQL 關(guān)鍵字
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 == '_'
}

// 判斷字符是否為數(shù)字
func isDigit(ch rune) bool {
    return unicode.IsDigit(ch)
}

模塊二：抽象語法樹 (AST)

思路

抽象語法樹用于表示 SQL 語句的語法結(jié)構(gòu)。我們需要為每種 SQL 語句定義相應(yīng)的節(jié)點類型。

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

ast.go構(gòu)建不同SQL語句的結(jié)構(gòu)，以及查詢結(jié)果等。
這個 AST 定義文件是 SQL 解析器的核心部分，它：

定義了所有 SQL 語句的語法結(jié)構(gòu)
提供了類型安全的方式來表示 SQL 語句
支持復(fù)雜的表達(dá)式和條件
便于后續(xù)的語義分析和執(zhí)行
通過這個 AST，我們可以：

驗證 SQL 語句的語法正確性
進行語義分析
生成執(zhí)行計劃
執(zhí)行 SQL 語句

示例：

SELECT id, name FROM users WHERE age > 18;

交給語法分析器parser解析后的AST結(jié)構(gòu)為：

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中的節(jié)點
type Node interface {
    TokenLiteral() string
}

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

// Expression 表示表達(dá)式
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 表示數(shù)據(jù)單元格
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 返回單元格的整數(shù)值
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 表示查詢結(jié)果
type Results struct {
    Columns []ResultColumn
    Rows    [][]Cell
}

// ResultColumn 表示結(jié)果列
type ResultColumn struct {
    Name string
    Type string
}

// StarExpression 表示星號表達(dá)式,如：select * from users;
type StarExpression struct{}

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

// LikeExpression 表示LIKE表達(dá)式, 如 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 表示二元表達(dá)式,如比較運算,大于小于比較等
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 表示整數(shù)字面量
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 表示標(biāo)識符（如列名）
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)

思路

語法分析器負(fù)責(zé)將詞法分析器生成的標(biāo)記序列轉(zhuǎn)換為抽象語法樹。將token序列構(gòu)建成ast。

SQL 解析器（Parser）的實現(xiàn)，負(fù)責(zé)將詞法分析器（Lexer）產(chǎn)生的標(biāo)記（Token）序列轉(zhuǎn)換為抽象語法樹（AST）。
語法分析器SQL 數(shù)據(jù)庫系統(tǒng)的關(guān)鍵組件，負(fù)責(zé)：

驗證 SQL 語句的語法正確性
構(gòu)建抽象語法樹
為后續(xù)的語義分析和執(zhí)行提供基礎(chǔ)

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

示例：

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


解析過程：
1. 識別 CREATE 關(guān)鍵字
2. 解析 TABLE 關(guān)鍵字
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 表示語法分析器
// 維護當(dāng)前和下一個標(biāo)記，實現(xiàn)向前查看（lookahead）
// 記錄解析過程中的錯誤
type Parser struct {
    l         *lexer.Lexer // 詞法分析器
    curToken  lexer.Token  // 當(dāng)前標(biāo)記
    peekToken lexer.Token  // 下一個標(biāo)記
    errors    []string     // 錯誤信息
}

// NewParser 創(chuàng)建新的語法分析器
// 初始化解析器
// 預(yù)讀兩個標(biāo)記
func NewParser(l *lexer.Lexer) *Parser {
    p := &Parser{
       l:      l,
       errors: []string{},
    }

    // 讀取兩個token，設(shè)置curToken和peekToken
    p.nextToken()
    p.nextToken()

    return p
}

// nextToken 移動到下一個詞法單元
func (p *Parser) nextToken() {
    p.curToken = p.peekToken
    p.peekToken = p.l.NextToken()
}

// ParseProgram 解析整個程序
// 解析整個 SQL 程序
// 循環(huán)解析每個語句直到結(jié)束
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 解析語句
// 根據(jù)當(dāng)前標(biāo)記類型選擇相應(yīng)的解析方法
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()

       // 解析左操作數(shù)（列名）
       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)
       }

       // 解析右操作數(shù)
       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()

       // 解析左操作數(shù)（列名）
       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)
       }

       // 解析右操作數(shù)
       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()

       // 解析左操作數(shù)（列名）
       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)
       }

       // 解析右操作數(shù)
       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 解析表達(dá)式(字面量int、string類型，標(biāo)識符列名、表名等)
// 解析各種類型的表達(dá)式
// 支持字面量、標(biāo)識符等
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 檢查當(dāng)前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 檢查下一個詞法單元是否為預(yù)期類型
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()

    // 解析左操作數(shù)（列名）
    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)
    }

    // 解析右操作數(shù)
    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)

思路

存儲引擎負(fù)責(zé)實際的數(shù)據(jù)存儲和檢索操作,執(zhí)行引擎中的數(shù)據(jù)操作CURD。

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

這是內(nèi)存存儲引擎的實現(xiàn)，負(fù)責(zé)處理 SQL 語句的實際執(zhí)行和數(shù)據(jù)存儲。

本期存儲引擎實現(xiàn)了：

完整的數(shù)據(jù)操作（CRUD）
主鍵約束
索引支持
類型檢查
條件評估
模式匹配

它是 SQL 數(shù)據(jù)庫系統(tǒng)的核心組件，負(fù)責(zé)：

數(shù)據(jù)存儲和管理
查詢執(zhí)行
數(shù)據(jù)完整性維護
性能優(yōu)化（通過索引）

原理解析：

-- 創(chuàng)建表
CREATE TABLE users (
    id INT PRIMARY KEY,
    name TEXT
);

-- 插入數(shù)據(jù)
INSERT INTO users VALUES (1, 'Alice');

-- 查詢數(shù)據(jù)
SELECT * FROM users WHERE name LIKE 'A%';

-- 更新數(shù)據(jù)
UPDATE users SET name = 'Bob' WHERE id = 1;

-- 刪除數(shù)據(jù)
DELETE FROM users WHERE id = 1;


存儲引擎會根據(jù)解析后的語法分析器，創(chuàng)建出對應(yīng)的數(shù)據(jù)結(jié)構(gòu)（如：在內(nèi)存中），以及對外暴露對該數(shù)據(jù)的操作（CRUD）

全部代碼

// internal/storage/memory.go
package storage

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

// MemoryBackend 內(nèi)存存儲引擎，管理所有表
type MemoryBackend struct {
    tables map[string]*Table
}

// Table 數(shù)據(jù)表，包含列定義、數(shù)據(jù)行和索引
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 創(chuàng)建新的內(nèi)存存儲引擎
func NewMemoryBackend() *MemoryBackend {
    return &MemoryBackend{
       tables: make(map[string]*Table),
    }
}

// CreateTable 創(chuàng)建表
// 驗證表名唯一性
// 創(chuàng)建表結(jié)構(gòu)
// 為主鍵列創(chuàng)建索引
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),
    }

    // 為主鍵創(chuàng)建索引
    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 插入數(shù)據(jù)
// 驗證表存在性
// 檢查數(shù)據(jù)完整性
// 處理主鍵約束
// 維護索引
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")
    }

    // 轉(zhuǎn)換值
    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" {
             // 嘗試將字符串轉(zhuǎn)換為整數(shù)
             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)
          }
       }
    }

    // 插入數(shù)據(jù)
    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 查詢數(shù)據(jù)
// 支持 SELECT * 和指定列
// 處理 WHERE 條件
// 返回查詢結(jié)果
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
          }
       }

       // 構(gòu)建結(jié)果行
       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 執(zhí)行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 執(zhí)行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 評估表達(dá)式的值
// 計算表達(dá)式的值
// 處理不同類型的數(shù)據(jù)
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模式轉(zhuǎn)換為正則表達(dá)式
    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:
          // 轉(zhuǎn)義正則表達(dá)式特殊字符
          if strings.ContainsAny(string(pattern[i]), ".+*?^$()[]{}|") {
             regexPattern += "\\" + string(pattern[i])
          } else {
             regexPattern += string(pattern[i])
          }
       }
    }
    regexPattern += "$"

    // 編譯正則表達(dá)式
    re, err := regexp.Compile(regexPattern)
    if err != nil {
       return false
    }

    // 執(zhí)行匹配
    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:
       // 獲取左操作數(shù)的值
       leftValue, err := getColumnValue(e.Left, row, columns)
       if err != nil {
          return false, err
       }

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

       // 根據(jù)操作符比較值
       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:
       // 獲取左操作數(shù)的值
       leftValue, err := getColumnValue(e.Left, row, columns)
       if err != nil {
          return false, err
       }

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

       // 執(zhí)行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)
    }
}

//后續(xù)拓展新的存儲引擎，如落地到文件...

模塊五：REPL 交互界面

思路

最后，我們需要實現(xiàn)一個交互式的命令行界面，讓用戶可以輸入 SQL 命令并查看結(jié)果。
這是 ZiyiDB 的主程序，實現(xiàn)了一個交互式的 SQL 命令行界面。

為了實現(xiàn)客戶端可以上下翻找之前執(zhí)行的命令以及cli客戶端的美觀，我們這里使用"github.com/c-bata/go-prompt"庫

// 安裝依賴
go get "github.com/c-bata/go-prompt"

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

主要實現(xiàn)：

交互式命令行界面
SQL 命令解析和執(zhí)行
命令歷史記錄
查詢結(jié)果格式化
錯誤處理和提示

全部代碼

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               // 當(dāng)前歷史記錄索引

// 處理用戶輸入的命令
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)
    }

    // 創(chuàng)建詞法分析器
    l := lexer.NewLexer(strings.NewReader(t))

    // 創(chuàng)建語法分析器
    p := parser.NewParser(l)

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

    // 執(zhí)行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()

             // 打印數(shù)據(jù)行
             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()

             // 打印行數(shù)統(tǒng)計
             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
       }),
       //實現(xiàn)方向鍵上下翻閱歷史命令
       // 上鍵綁定
       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()
}

整體測試

編寫完第一版后，現(xiàn)在我們來整體測試一下。

測試腳本

test_cast.sql：

-- 1. 創(chuàng)建表
CREATE TABLE users (id INT PRIMARY KEY,name TEXT ,age INT);


-- 2. 插入用戶數(shù)據(jù)
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 查詢所有數(shù)據(jù)
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 結(jié)尾

-- 6.2 轉(zhuǎn)義字符測試
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. 清理測試數(shù)據(jù)
DROP TABLE users;

-- 10. 驗證表已刪除
SELECT * FROM users;    -- 應(yīng)該失敗


todo::
    1. 實現(xiàn)!= >= <=等運算符
    2. 支持更多數(shù)據(jù)類型
    3. 支持更多函數(shù)
    4. 優(yōu)化查詢結(jié)果展示
    5. 支持更多索引類型
    6. 支持null值等
    7. 支持?jǐn)?shù)據(jù)落地本地文件
    8. 支持事務(wù)操作等