如何使用 Go 和 ANTLR 解析 SQL 查询中的 WHERE 子句

如何使用 Go 和 ANTLR 解析 SQL 查询中的 WHERE 子句

在本教程中，我们将学习如何使用 Go 语言结合 ANTLR 来解析 SQL 查询中的 WHERE 子句。我们将通过构建一个简单的 SQL 解析器来提取条件表达式，并对复杂的 SQL 查询进行递归解析。我们特别关注 Kubernetes 资源的 JSON 嵌套结构，因 Kubernetes 资源的字段路径是嵌套的，所以需要在解析时将 SQL 中的字段路径改写为适应 JSON 查询的格式。

---

背景信息

我正在开发一个开源项目 kom，目标是实现通过 SQL 查询 Kubernetes 资源。因为 Kubernetes 资源是 JSON 格式的嵌套结构，而不是传统的 db.table 结构，所以在处理 SQL 查询中的 WHERE 语句时，必须先将像 x.y.z.m 这样的属性改写为一个整体的字段，以便能够正确查询 Kubernetes 中的资源。

---

步骤 1：定义 SQL 语法

首先，我们需要使用 ANTLR 来定义一个 SQL 语法（SQL.g4），特别是针对 WHERE 子句中的常见表达式。ANTLR 会根据这个语法文件生成相应的代码，用于解析 SQL 查询。

SQL 语法定义（SQL.g4）

grammar SQL;

parse   : selectStatement;
selectStatement : 'SELECT' '*' 'FROM' table 'WHERE' condition;

table  : IDENTIFIER;

condition
    : condition AND condition           # AndCondition
    | condition OR condition            # OrCondition
    | '(' condition ')'                 # ParenthesizedCondition
    | comparisonExpr                    # Comparison
    | rangeExpr                         # RangeCondition
    ;

comparisonExpr
    : field comparisonOperator value   # ComparisonExpr
    ;

rangeExpr
    : field 'BETWEEN' value 'AND' value # RangeExpr
    ;

comparisonOperator
    : '='  | '!=' | '<' | '>' | '<=' | '>='
    ;

field  : IDENTIFIER;

value  : STRING  | NUMBER | BOOLEAN | DATE;

BOOLEAN : 'TRUE' | 'FALSE';
NUMBER  : [0-9]+;
STRING  : '\'' [a-zA-Z0-9_]+ '\'';
DATE    : '\'' [0-9]{4}-[0-9]{2}-[0-9]{2} '\'';

IDENTIFIER : [a-zA-Z_][a-zA-Z0-9_]*;

AND     : 'AND';
OR      : 'OR';

WS      : [ \t\r\n]+ -> skip;

语法解释：

• condition 表示 SQL 查询中的条件表达式，可以包含逻辑运算符 AND 和 OR。
• comparisonExpr 处理基本的比较运算（例如 =、!=、> 等）。
• rangeExpr 处理 BETWEEN 表达式，用于区间匹配。
• field 和 value 分别代表 SQL 中的字段名和条件值。

---

步骤 2：生成 Go 代码

在定义完 SQL 语法后，使用 ANTLR 工具生成 Go 语言的解析器代码。首先，安装 ANTLR 工具，并生成对应的 Go 代码。

安装 ANTLR 工具

brew install antlr

生成 Go 代码

在终端中运行以下命令，生成 Go 代码：

antlr4 -Dlanguage=Go SQL.g4

这将生成 Go 文件，包括：

• SQLLexer.go
• SQLParser.go
• SQLListener.go

这些文件包含了用于 SQL 解析的代码，你可以在 Go 中调用这些生成的文件。

---

步骤 3：实现 SQL 解析逻辑

使用生成的 ANTLR 代码，我们编写 Go 代码来递归解析 SQL 查询，并提取 WHERE 子句中的条件。这里需要特别注意将嵌套的字段（例如 metadata.namespace.x.y）转换为 JSON 查询格式。

Go 代码示例

package main

import (
	"fmt"
	"github.com/antlr/antlr4/runtime/Go/antlr"
	"log"
	"strings"
)

// Condition 结构定义
type Condition struct {
	Depth    int
	AndOr    string
	Field    string
	Operator string
	Value    interface{}
	ValueType string // "string", "number", "bool", "date"
}

// 自定义监听器
type SQLListener struct {
	*antlr.DefaultParseTreeListener
	Conditions []Condition
	Depth      int
	AndOr      string
}

func (l *SQLListener) EnterComparisonExpr(ctx *SQLParserComparisonExprContext) {
	field := ctx.Field().GetText()
	operator := ctx.ComparisonOperator().GetText()
	value := ctx.Value().GetText()

	// 处理字段路径
	field = strings.ReplaceAll(field, ".", "_") // 将 x.y.z 转换为 x_y_z 形式

	// 处理字段和运算符
	condition := Condition{
		Depth:    l.Depth,
		AndOr:    l.AndOr,
		Field:    field,
		Operator: operator,
		Value:    strings.Trim(value, "'"), // 去除字符串的单引号
		ValueType: "string", // 默认值是字符串类型
	}

	l.Conditions = append(l.Conditions, condition)
}

func (l *SQLListener) EnterRangeExpr(ctx *SQLParserRangeExprContext) {
	field := ctx.Field().GetText()
	operator := "BETWEEN"
	value := ctx.Value(0).GetText() + " AND " + ctx.Value(1).GetText()

	// 处理BETWEEN表达式的字段路径
	field = strings.ReplaceAll(field, ".", "_") // 将 x.y.z 转换为 x_y_z 形式

	// 处理BETWEEN表达式
	condition := Condition{
		Depth:    l.Depth,
		AndOr:    l.AndOr,
		Field:    field,
		Operator: operator,
		Value:    value,
		ValueType: "range", // 设置范围类型
	}

	l.Conditions = append(l.Conditions, condition)
}

func (l *SQLListener) EnterAndCondition(ctx *SQLParserAndConditionContext) {
	// 递归解析AND条件
	l.AndOr = "AND"
}

func (l *SQLListener) EnterOrCondition(ctx *SQLParserOrConditionContext) {
	// 递归解析OR条件
	l.AndOr = "OR"
}

func (l *SQLListener) EnterParenthesizedCondition(ctx *SQLParserParenthesizedConditionContext) {
	// 递归解析括号中的条件
	l.Depth++
}

// 解析 SQL 查询并输出结果
func parseSQL(sql string) []Condition {
	// 1. 创建输入流并初始化 Lexer 和 Parser
	input := antlr.NewInputStream(sql)
	lexer := NewSQLLexer(input)
	tokens := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
	parser := NewSQLParser(tokens)

	// 2. 初始化监听器
	listener := &SQLListener{
		Conditions: []Condition{},
		Depth:      0,
		AndOr:      "",
	}
	antlr.ParseTreeWalkerDefault.Walk(listener, parser.Parse())

	// 3. 返回所有解析的条件
	return listener.Conditions
}

func main() {
	sql := "SELECT * FROM pod WHERE metadata.namespace = 'kube-system' AND spec.replicas BETWEEN 2 AND 5"

	// 解析 SQL
	conditions := parseSQL(sql)

	// 打印条件
	for _, cond := range conditions {
		fmt.Printf("Condition: %+v\n", cond)
	}
}

代码解释：

1. Condition 结构：表示解析出的 SQL 条件，包含条件的字段、运算符、值、值类型等信息。
2. SQLListener：是一个自定义监听器，用于处理 SQL 解析过程中遇到的各种条件表达式。我们在监听器中处理 ComparisonExpr（比较表达式）、RangeExpr（范围表达式）、AND、OR、ParenthesizedCondition（括号表达式）等。
3. 字段路径处理：在 EnterComparisonExpr 和 EnterRangeExpr 方法中，我们将 SQL 查询中的嵌套字段（如 metadata.namespace.x.y）转换为 metadata_namespace_x_y 形式，适应 Kubernetes JSON 格式。
4. parseSQL 函数：初始化解析器并使用监听器来解析 SQL 查询。
5. main 函数：执行 SQL 解析并输出解析后的条件。

输出：

对于 SQL 查询：

SELECT * FROM pod WHERE metadata.namespace = 'kube-system' AND spec.replicas BETWEEN 2 AND 5

程序输出的条件将是：

Condition: {Depth:0 AndOr: AND Field:metadata_namespace Value:kube-system ValueType:string}
Condition: {Depth:1 AndOr: AND Field:spec_replicas Value:2 AND 5 ValueType:range}

---

步骤 4：总结

通过本教程，你学到了如何：

1

. 使用 ANTLR 定义 SQL 语法并生成 Go 语言代码。
2. 在 Go 中使用 ANTLR 生成的代码来解析 SQL 查询，特别是 WHERE 子句中的条件表达式。
3. 处理 Kubernetes 资源的 JSON 嵌套结构，将 SQL 查询中的字段路径（如 metadata.namespace）转换为适合 JSON 查询的格式。

这为实现使用 SQL 查询 Kubernetes 资源奠定了基础。