当前位置：首页 > news >正文

Go语言从零构建SQL数据库(7)：实现ALTER TABLE语句的解析

news 来源：原创 2025/5/3 16:18:37

SQL解析器系列：实现ALTER TABLE语句

在SQL解析器系列的最后一篇文章中，我们将聚焦于ALTER TABLE语句的实现。ALTER TABLE是数据定义语言(DDL)中的重要组成部分，允许在不丢失数据的情况下修改表结构。实现这个功能将为我们的SQL解析器画上圆满的句号，也为下一阶段的查询执行引擎开发奠定基础。

ALTER TABLE语法与复杂性

ALTER TABLE语句的语法相对复杂，支持多种操作类型：

ALTER TABLE users 
    ADD COLUMN email VARCHAR(100) NOT NULL,
    MODIFY COLUMN name VARCHAR(50) DEFAULT 'unknown',
    DROP COLUMN age,
    ADD CONSTRAINT uk_email UNIQUE (email);

ALTER TABLE语句的基本语法结构如下图所示：

与其他SQL语句相比，ALTER TABLE的实现面临以下挑战：

多操作支持：一条ALTER语句可以包含多个子操作，每个操作有不同的语法结构
复杂的类型定义：列类型可能包含参数，如 DECIMAL(10,2)
多种约束类型：需要支持PRIMARY KEY、UNIQUE、FOREIGN KEY等不同约束
默认值表达式：默认值可以是简单字面量或复杂表达式

各种ALTER操作类型的语法结构如下：

数据结构设计

为了表示ALTER TABLE语句，我们设计了一个层次化的AST结构：

这种设计允许我们在一个语句中表示多种ALTER操作，每种操作都有其特定的结构和属性。ALTER操作类型通过枚举定义：

// AlterActionType 表示ALTER TABLE操作的类型
type AlterActionType int

const (
    AddColumn AlterActionType = iota
    ModifyColumn
    ChangeColumn
    DropColumn
    AddConstraint
    DropConstraint
)

解析实现

主解析函数的流程

ALTER TABLE语句的解析过程可以表示为以下流程图：

解析的核心代码如下：

func (p *Parser) parseAlterTableStatement() (*ast.AlterTableStatement, error) {
    stmt := &ast.AlterTableStatement{}

    // 跳过ALTER TABLE
    p.nextToken() // 跳过ALTER
    p.nextToken() // 跳过TABLE

    // 解析表名
    if !p.currTokenIs(lexer.IDENTIFIER) {
        return nil, fmt.Errorf("期望表名，但得到%s", p.currToken.Literal)
    }
    stmt.TableName = p.currToken.Literal
    p.nextToken()

    // 解析第一个ALTER操作
    action, err := p.parseAlterAction()
    if err != nil {
        return nil, err
    }
    stmt.Actions = append(stmt.Actions, action)

    // 如果有更多的操作（以逗号分隔），继续解析
    for p.currTokenIs(lexer.COMMA) {
        p.nextToken() // 跳过逗号
        action, err := p.parseAlterAction()
        if err != nil {
            return nil, err
        }
        stmt.Actions = append(stmt.Actions, action)
    }

    // 可选的分号
    if p.currTokenIs(lexer.SEMICOLON) {
        p.nextToken() // 跳过分号
    }

    return stmt, nil
}

操作类型解析详解

每种ALTER操作类型的解析逻辑都不同，以下是各种操作类型的解析流程：

特别值得注意的是ADD COLUMN操作的解析过程：

处理复杂类型参数

处理类型参数（如VARCHAR(100)）时，我们需要特别注意嵌套括号的情况。我们使用一个计数器跟踪括号嵌套级别：

具体实现代码：

// 处理类型后可能的括号参数，如VARCHAR(100)
if p.currTokenIs(lexer.LPAREN) {
    bracketLevel := 1
    p.nextToken() // 跳过左括号
  
    // 跳过括号内的所有token直到匹配的右括号
    for bracketLevel > 0 && !p.currTokenIs(lexer.EOF) {
        if p.currTokenIs(lexer.LPAREN) {
            bracketLevel++
        } else if p.currTokenIs(lexer.RPAREN) {
            bracketLevel--
        }
      
        if bracketLevel > 0 {
            p.nextToken()
        }
    }
  
    if p.currTokenIs(lexer.RPAREN) {
        p.nextToken() // 跳过右括号
    }
}

这种方法确保我们能正确处理嵌套括号，如 DECIMAL(12,2)或更复杂的类型定义。

表达式解析与默认值处理

默认值可以是各种表达式，例如数字、字符串甚至函数调用。我们利用之前实现的Pratt解析算法来处理这些表达式：

if p.currTokenIs(lexer.DEFAULT) {
    p.nextToken() // 跳过DEFAULT
  
    // 解析默认值表达式
    expr, err := p.parseExpression(LOWEST)
    if err != nil {
        return nil, err
    }
    colDef.Default = &ast.ColumnDefault{Value: expr}
}

表达式解析的优先级流程如下：

约束解析深入讲解

约束解析是ALTER TABLE中的另一个复杂部分，不同类型的约束有不同的语法结构：

约束解析的一个关键部分是解析标识符列表，例如 (id, name, email)：

// parseIdentifierList 解析标识符列表
func (p *Parser) parseIdentifierList() ([]string, error) {
    identifiers := []string{}

    // 跳过左括号
    p.nextToken()

    // 第一个标识符
    if !p.currTokenIs(lexer.IDENTIFIER) {
        return nil, fmt.Errorf("期望标识符，但得到%s", p.currToken.Literal)
    }

    identifiers = append(identifiers, p.currToken.Literal)

    // 解析剩余标识符
    for p.peekTokenIs(lexer.COMMA) {
        p.nextToken() // 跳过当前标识符或逗号
        p.nextToken() // 移动到下一个标识符

        if !p.currTokenIs(lexer.IDENTIFIER) {
            return nil, fmt.Errorf("期望标识符，但得到%s", p.currToken.Literal)
        }

        identifiers = append(identifiers, p.currToken.Literal)
    }

    // 期望下一个Token是右括号
    if !p.expectPeek(lexer.RPAREN) {
        return nil, fmt.Errorf("期望)，但得到%s", p.peekToken.Literal)
    }

    return identifiers, nil
}

测试实现详解

测试是确保解析器正确性的关键。我们为ALTER TABLE设计了全面的测试套件：

测试用例覆盖了各种ALTER TABLE操作：

{
    name:           "Add Column",
    input:          "ALTER TABLE users ADD COLUMN email VARCHAR(100) NOT NULL;",
    checkTableName: "users",
    actionCount:    1,
    expectError:    false,
},
{
    name:           "Add Column with Default",
    input:          "ALTER TABLE users ADD COLUMN score INT DEFAULT 100;",
    checkTableName: "users",
    actionCount:    1,
    expectError:    false,
},
{
    name:           "Multiple Actions",
    input:          "ALTER TABLE orders ADD COLUMN created_at TIMESTAMP, ADD CONSTRAINT pk_order PRIMARY KEY (id);",
    checkTableName: "orders",
    actionCount:    2,
    expectError:    false,
},
{
    name:           "Drop Column",
    input:          "ALTER TABLE products DROP COLUMN description;",
    checkTableName: "products",
    actionCount:    1,
    expectError:    false,
},

对于每个测试用例，我们验证：

是否正确解析表名
操作数量是否正确
每个操作的类型是否正确
操作参数（列定义、约束等）是否正确

错误处理机制

强大的错误处理对于解析器至关重要。我们采用详细的错误消息，帮助用户快速定位问题：

错误处理示例：

if !p.currTokenIs(lexer.IDENTIFIER) {
    return nil, fmt.Errorf("期望表名，但得到%s", p.currToken.Literal)
}

if !p.currTokenIs(lexer.LPAREN) {
    return nil, fmt.Errorf("期望(，但得到%s", p.currToken.Literal)
}

这种详细的错误提示使得用户能够快速识别和修复SQL语法错误。

编译器设计模式应用

我们的SQL解析器实现展示了多种编译器设计模式：

特别值得一提的是Pratt解析算法的应用，它使我们能够轻松处理复杂表达式的优先级：

技术难点与解决方案详解

1. 多操作处理

解析多个操作需要仔细处理Token序列，特别是在操作之间的逗号和语句结尾的分号：

我们的实现确保正确处理操作序列，即使它们跨越多行：

// 如果有更多的操作（以逗号分隔），继续解析
for p.currTokenIs(lexer.COMMA) {
    p.nextToken() // 跳过逗号
    action, err := p.parseAlterAction()
    if err != nil {
        return nil, err
    }
    stmt.Actions = append(stmt.Actions, action)
}

2. 嵌套括号处理

处理类型参数中的嵌套括号是一个挑战，我们通过维护括号嵌套级别解决这个问题：

代码实现通过跟踪嵌套级别，确保只有在所有括号闭合后才结束解析：

bracketLevel := 1
p.nextToken() // 跳过左括号

for bracketLevel > 0 && !p.currTokenIs(lexer.EOF) {
    if p.currTokenIs(lexer.LPAREN) {
        bracketLevel++
    } else if p.currTokenIs(lexer.RPAREN) {
        bracketLevel--
    }
  
    if bracketLevel > 0 {
        p.nextToken()
    }
}