数据库系统有一个核心部件，那就是SQL解释器。用过mySQL的同学都知道，我们需要写一系列由SQL语言组成的代码来驱动数据库的运行，由此它就必须要有一个SQL语言解释器来解读SQL代码，然后根据代码的意图来驱动数据库执行相应的操作，本节我们就完成一个简单的SQL解释器。
解释器的原理基于编译原理，我在B站上专门有视频解释编译原理算法，因此我在这里不再赘述。实现一个解释器的首要步骤就是完成一个词法解析器，我在B站编译原理视频中实现过一个小型编译器(dragon-compiler)，因此我将其对应的词法解析器直接拿过来稍作改动，让其能对SQL代码进行词法解析。首先我们把其中的lexer部分直接拷贝到我们现在的项目，打开其中的token.go文件，我们首先修改其中token的定义，将SQL语言中关键字的定义添加进去，然后去除与 SQL无关的定义，修改后代码如下：
package lexer
type Tag uint32
const (
//AND 对应SQL关键字
AND Tag = iota + 256
//BREAK
//DO
EQ
FALSE
GE
ID
//IF
//ELSE
INDEX
LE
INT
FLOAT
MINUS
PLUS
NE
NUM
//OR
REAL
//TRUE
//WHILE
LEFT_BRACE // "{"
RIGHT_BRACE // "}"
LEFT_BRACKET //"("
RIGHT_BRACKET //")"
AND_OPERATOR
OR_OPERATOR
ASSIGN_OPERATOR
NEGATE_OPERATOR
LESS_OPERATOR
GREATER_OPERATOR
BASIC //对应int , float, bool, char 等类型定义
//TEMP //对应中间代码的临时寄存器变量
//SEMICOLON
//新增SQL对应关键字
SELECT
FROM
WHERE
INSERT
INTO
VALUES
DELETE
UPDATE
SET
CREATE
TABLE
INT
VARCHAR
VIEW
AS
INDEX
ON
COMMA
STRING
//SQL关键字定义结束
EOF
ERROR
)
var token_map = make(map[Tag]string)
func init() {
//初始化SQL关键字对应字符串
token_map[AND] = "AND"
token_map[SELECT] = "SELECT"
token_map[WHERE] = "where"
token_map[INSERT] = "INSERT"
token_map[INTO] = "INTO"
token_map[VALUES] = "VALUES"
token_map[DELETE] = "DELETE"
token_map[UPDATE] = "UPDATE"
token_map[SET] = "SET"
token_map[CREATE] = "CREATE"
token_map[TABLE] = "TABLE"
token_map[INT] = "INT"
token_map[VARCHAR] = "VARCHAR"
token_map[VIEW] = "VIEW"
token_map[AS] = "AS"
token_map[INDEX] = "INDEX"
token_MAP[ON] = "ON"
token_map[COMMA] = ","
token_map[BASIC] = "BASIC"
//token_map[DO] = "do"
//token_map[ELSE] = "else"
token_map[EQ] = "EQ"
token_map[FALSE] = "FALSE"
token_map[GE] = "GE"
token_map[ID] = "ID"
//token_map[IF] = "if"
token_map[INT] = "int"
token_map[FLOAT] = "float"
token_map[LE] = "<="
token_map[MINUS] = "-"
token_map[PLUS] = "+"
token_map[NE] = "!="
token_map[NUM] = "NUM"
token_map[OR] = "OR"
token_map[REAL] = "REAL"
//token_map[TEMP] = "t"
token_map[TRUE] = "TRUE"
//token_map[WHILE] = "while"
//token_map[DO] = "do"
//token_map[BREAK] = "break"
token_map[AND_OPERATOR] = "&"
token_map[OR_OPERATOR] = "|"
token_map[ASSIGN_OPERATOR] = "="
token_map[NEGATE_OPERATOR] = "!"
token_map[LESS_OPERATOR] = "<"
token_map[GREATER_OPERATOR] = ">"
token_map[LEFT_BRACE] = "{"
token_map[RIGHT_BRACE] = "}"
token_map[LEFT_BRACKET] = "("
token_map[RIGHT_BRACKET] = ")"
token_map[EOF] = "EOF"
token_map[ERROR] = "ERROR"
//token_map[SEMICOLON] = ";"
}
type Token struct {
lexeme string
Tag Tag
}
func (t *Token) ToString() string {
if t.lexeme == "" {
return token_map[t.Tag]
}
return t.lexeme
}
func NewToken(tag Tag) Token {
return Token{
lexeme: "",
Tag: tag,
}
}
func NewTokenWithString(tag Tag, lexeme string) *Token {
return &Token{
lexeme: lexeme,
Tag: tag,
}
}
在上面代码修改中，我们把原来C语言的关键字去掉，增加了一系列SQL语言对应的关键字。打开文件word_token.go，做如下修改：
package lexer
type Word struct {
lexeme string
Tag Token
}
func NewWordToken(s string, tag Tag) Word {
return Word{
lexeme: s,
Tag: NewToken(tag),
}
}
func (w *Word) ToString() string {
return w.lexeme
}
func GetKeyWords() []Word {
key_words := []Word{
}
key_words = append(key_words, NewWordToken("||", OR))
key_words = append(key_words, NewWordToken("==", EQ))
key_words = append(key_words, NewWordToken("!=", NE))
key_words = append(key_words, NewWordToken("<=", LE))
key_words = append(key_words, NewWordToken(">=", GE))
//增加SQL语言对应关键字
key_words = append(key_words, NewWordToken("AND", AND))
key_words = append(key_words, NewWordToken("SELECT", SELECT))
key_words = append(key_words, NewWordToken("FROM", FROM))
key_words = append(key_words, NewWordToken("INSERT", INSERT))
key_words = append(key_words, NewWordToken("INTO", INTO))
key_words = append(key_words, NewWordToken("VALUES", VALUES))
key_words = append(key_words, NewWordToken("DELETE", DELETE))
key_words = append(key_words, NewWordToken("UPDATE", UPDATE))
key_words = append(key_words, NewWordToken("SET", SET))
key_words = append(key_words, NewWordToken("CREATE", CREATE))
key_words = append(key_words, NewWordToken("TABLE", TABLE))
key_words = append(key_words, NewWordToken("INT", INT))
key_words = append(key_words, NewWordToken("VARCHAR", VARCHAR))
key_words = append(key_words, NewWordToken("VIEW", VIEW))
key_words = append(key_words, NewWordToken("AS", AS))
key_words = append(key_words, NewWordToken("INDEX", INDEX))
key_words = append(key_words, NewWordToken("ON", ON))
//key_words = append(key_words, NewWordToken("minus", MINUS))
//key_words = append(key_words, NewWordToken("true", TRUE))
//key_words = append(key_words, NewWordToken("false", FALSE))
//key_words = append(key_words, NewWordToken("if", IF))
//key_words = append(key_words, NewWordToken("else", ELSE))
//增加while, do关键字
//key_words = append(key_words, NewWordToken("while", WHILE))
//key_words = append(key_words, NewWordToken("do", DO))
//key_words = append(key_words, NewWordToken("break", BREAK))
//添加类型定义
//key_words = append(key_words, NewWordToken("int", BASIC))
//key_words = append(key_words, NewWordToken("float", BASIC))
//key_words = append(key_words, NewWordToken("bool", BASIC))
//key_words = append(key_words, NewWordToken("char", BASIC))
return key_words
}
这里的修改中也是把原来对应C语言的关键字去掉，增加上SQL语言的关键字定义。除了这些修改外，lexer的基本逻辑没有什么变化，其代码如下(lexer.go):
package lexer
import (
"bufio"
"strconv"
"strings"
"unicode"
)
type Lexer struct {
Lexeme string
lexemeStack []string
tokenStack []Token
peek byte
Line uint32
reader *bufio.Reader
read_pointer int
key_words map[string]Token
}
func NewLexer(source string) Lexer {
str := strings.NewReader(source)
source_reader := bufio.NewReaderSize(str, len(source))
lexer := Lexer{
Line: uint32(1),
reader: source_reader,
key_words: make(map[string]Token),
}
lexer.reserve()
return lexer
}
func (l *Lexer) ReverseScan() {
/*
back_len := len(l.Lexeme)
只能un read 一个字节
for i := 0; i < back_len; i++ {
l.reader.UnreadByte()
}
*/
if l.read_pointer > 0 {
l.read_pointer = l.read_pointer - 1
}
}
func (l *Lexer) reserve() {
key_words := GetKeyWords()
for _, key_word := range key_words {
l.key_words[key_word.ToString()] = key_word.Tag
}
}
func (l *Lexer) Readch() error {
char, err := l.reader.ReadByte() //提前读取下一个字符
l.peek = char
return err
}
func (l *Lexer) ReadCharacter(c byte) (bool, error) {
chars, err := l.reader.Peek(1)
if err != nil {
return false, err
}
peekChar := chars[0]
if peekChar != c {
return false, nil
}
l.Readch() //越过当前peek的字符
return true, nil
}
func (l *Lexer) UnRead() error {
return l.reader.UnreadByte()
}
func (l *Lexer) Scan() (Token, error) {
if l.read_pointer < len(l.lexemeStack) {
l.Lexeme = l.lexemeStack[l.read_pointer]
token := l.tokenStack[l.read_pointer]
l.read_pointer = l.read_pointer + 1
return token, nil
} else {
l.read_pointer = l.read_pointer + 1
}
for {
err := l.Readch()
if err != nil {
return NewToken(ERROR), err
}
if l.peek == ' ' || l.peek == '\t' {
continue
} else if l.peek == '\n' {
l.Line = l.Line + 1
} else {
break
}
}
l.Lexeme = ""
switch l.peek {
case ',':
l.Lexeme = ","
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(COMMA)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '{':
l.Lexeme = "{"
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(LEFT_BRACE)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '}':
l.Lexeme = "}"
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(RIGHT_BRACE)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '+':
l.Lexeme = "+"
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(PLUS)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '-':
l.Lexeme = "-"
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(MINUS)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '(':
l.Lexeme = "("
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(LEFT_BRACKET)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case ')':
l.Lexeme = ")"
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(RIGHT_BRACKET)
l.tokenStack = append(l.tokenStack, token)
return token, nil
case '&':
l.Lexeme = "&"
if ok, err := l.ReadCharacter('&'); ok {
l.Lexeme = "&&"
word := NewWordToken("&&", AND)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(AND_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '|':
l.Lexeme = "|"
if ok, err := l.ReadCharacter('|'); ok {
l.Lexeme = "||"
word := NewWordToken("||", OR)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(OR_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '=':
l.Lexeme = "="
if ok, err := l.ReadCharacter('='); ok {
l.Lexeme = "=="
word := NewWordToken("==", EQ)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(ASSIGN_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '!':
l.Lexeme = "!"
if ok, err := l.ReadCharacter('='); ok {
l.Lexeme = "!="
word := NewWordToken("!=", NE)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(NEGATE_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '<':
l.Lexeme = "<"
if ok, err := l.ReadCharacter('='); ok {
l.Lexeme = "<="
word := NewWordToken("<=", LE)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(LESS_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '>':
l.Lexeme = ">"
if ok, err := l.ReadCharacter('='); ok {
l.Lexeme = ">="
word := NewWordToken(">=", GE)
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, word.Tag)
return word.Tag, err
} else {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(GREATER_OPERATOR)
l.tokenStack = append(l.tokenStack, token)
return token, err
}
case '"':
for {
err := l.Readch()
if l.peek == '"' {
haveSeenQuote = false
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(STRING)
l.tokenStack = append(l.tokenStack, token)
return token, nil
}
if err != nil {
panic("string no end with quota")
}
l.Lexeme += string(l.peek)
}
}
if unicode.IsNumber(rune(l.peek)) {
var v int
var err error
for {
num, err := strconv.Atoi(string(l.peek))
if err != nil {
if l.peek != 0 {
//l.peek == 0 意味着已经读完所有字符
l.UnRead() //将字符放回以便下次扫描
}
break
}
v = 10*v + num
l.Lexeme += string(l.peek)
l.Readch()
}
if l.peek != '.' {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(NUM)
token.lexeme = l.Lexeme
l.tokenStack = append(l.tokenStack, token)
return token, err
}
l.Lexeme += string(l.peek)
l.Readch() //越过 "."
x := float64(v)
d := float64(10)
for {
l.Readch()
num, err := strconv.Atoi(string(l.peek))
if err != nil {
if l.peek != 0 {
//l.peek == 0 意味着已经读完所有字符
l.UnRead() //将字符放回以便下次扫描
}
break
}
x = x + float64(num)/d
d = d * 10
l.Lexeme += string(l.peek)
}
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token := NewToken(REAL)
token.lexeme = l.Lexeme
l.tokenStack = append(l.tokenStack, token)
return token, err
}
if unicode.IsLetter(rune(l.peek)) {
var buffer []byte
for {
buffer = append(buffer, l.peek)
l.Lexeme += string(l.peek)
l.Readch()
if !unicode.IsLetter(rune(l.peek)) {
if l.peek != 0 {
//l.peek == 0 意味着已经读完所有字符
l.UnRead() //将字符放回以便下次扫描
}
break
}
}
s := string(buffer)
token, ok := l.key_words[s]
if ok {
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
l.tokenStack = append(l.tokenStack, token)
return token, nil
}
l.lexemeStack = append(l.lexemeStack, l.Lexeme)
token = NewToken(ID)
token.lexeme = l.Lexeme
l.tokenStack = append(l.tokenStack, token)
return token, nil
}
return NewToken(EOF), nil
}
为了节省篇幅，这里我没有把所有文件对应改动都贴出来，请在B站搜索"coding迪斯尼"查看详细内容，下面我们调用上面实现的代码试试效果，在main.go中添加如下测试代码：
import (
"fmt"
"lexer"
)
func main() {
sqlLexer := lexer.NewLexer("select name , sex from student where age > 20")
var tokens []*lexer.Token
tokens = append(tokens, lexer.NewTokenWithString(lexer.SELECT, "select"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.ID, "name"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.COMMA, ","))
tokens = append(tokens, lexer.NewTokenWithString(lexer.ID, "sex"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.FROM, "from"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.ID, "student"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.WHERE, "where"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.ID, "age"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.GREATER_OPERATOR, ">"))
tokens = append(tokens, lexer.NewTokenWithString(lexer.NUM, "20"))
for _, tok := range tokens {
sqlTok, err := sqlLexer.Scan()
if err != nil {
fmt.Println("lexer error")
break
}
if sqlTok.Tag != tok.Tag {
errText := fmt.Sprintf("token err, expect: %v, but got %v\n", tok, sqlTok)
fmt.Println(errText)
break
}
}
fmt.Println("lexer testing pass...")
}
通过运行可以发现，最后一句"lexer testing pass…"能正常打印出来，因此词法解析器的基本逻辑是正确的。接下来看看语法解析的实现，基于篇幅所限，这里我们只处理SQL的一小部分，有兴趣的同学可以自行补全我们这里完成的SQL解释器，首先我们先定义要解析的SQL语法部分：
FIELD -> ID
CONSTANT -> STRING | NUM
EXPRESSION -> FIELD | CONSTANT
TERM -> EXPRESSION EQ EXPRESSION
PREDICATE -> TERM (AND PREDICATE)?
QUERY -> SELECT SELECT_LIST FROM TABLE_LIST (WHERE PREDICATE)?
SELECTION_LIST -> FIELD (COMMA SELECTION_LIST)?
TABLE_LIST -> ID (COMMA TABLE_LIST)?
UPDATE_COMMAND -> INSERT_COMMAND | DELETE_COMMAND | MODIFY_COMMAND | CREATE_COMMAND
CREATE_COMMAND -> CREATE_TABLE | CREATE_VIEW | CREATE_INDEX
INSERT_COMMAND -> INSERT INTO ID LEFT_BRACE FIELD_LIST RIGHT_BRACE VALUES CONSTANT_LIST
FIELD_LIST -> FIELD (COMMA FIELD_LIST)?
CONSTANT_LIST -> CONSTANT (COMMA CONSTANT_LIST)?
DELETE_COMMAND -> DELETE FROM ID (WHERE PREDICATE)?
MODIFY_COMMAND -> UPDATE ID SET FIELD EQ EXPRESSION (WHERE PREDICATE)?
CREATE_TABLE -> CREATE TABLE FIELD_DEFS
FIELD_DEFS -> FIELD_DEF (COMMA FIELD_DEFS)?
FIELD_DEF -> ID TYPE_DEF
TYPE_DEF -> INT | VARCHAR LEFT_BRACE NUM RIGHT_BRACE
CREATE_VIEW -> CREATE VIEW ID AS QUERY
CREATE_INDEX -> CREATE INDEX ID ON ID LEFT_BRACE FIELD RIGHT_BRACE
接下来我们看看如何通过上面语法规则对SQL代码进行解析。这里我们采用自顶向下的递归式解析法，具体算法过程可以参考我在b站的编译原理视频。在工程中新建一个文件夹叫parser，然后再里面添加parser.go文件，为了简单起见，我们一次完成一小部分，然后调用完成的代码看看结果是否正确，首先我们完成TERM这条规则的解析，代码如下：
package parser
import (
"lexer"
"query"
"strconv"
"strings"
)
type SQLParser struct {
sqlLexer lexer.Lexer
}
func NewSQLParser(s string) *SQLParser {
return &SQLParser{
sqlLexer: lexer.NewLexer(s),
}
}
func (p *SQLParser) Field() (lexer.Token, string) {
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag != lexer.ID {
panic("Tag of FIELD is no ID")
}
return tok, p.sqlLexer.Lexeme
}
func (p *SQLParser) Constant() *query.Constant {
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
switch tok.Tag {
case lexer.STRING:
s := strings.Clone(p.sqlLexer.Lexeme)
return query.NewConstantWithString(&s)
break
case lexer.NUM:
//注意堆栈变量在函数执行后是否会变得无效
v, err := strconv.Atoi(p.sqlLexer.Lexeme)
if err != nil {
panic("string is not a number")
}
return query.NewConstantWithInt(&v)
break
default:
panic("token is not string or num when parsing constant")
}
return nil
}
func (p *SQLParser) Expression() *query.Expression {
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag == lexer.ID {
p.sqlLexer.ReverseScan()
_, str := p.Field()
return query.NewExpressionWithString(str)
} else {
p.sqlLexer.ReverseScan()
constant := p.Constant()
return query.NewExpressionWithConstant(constant)
}
}
func (p *SQLParser) Term() *query.Term {
lhs := p.Expression()
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag != lexer.ASSIGN_OPERATOR {
panic("should have = in middle of term")
}
rhs := p.Expression()
return query.NewTerm(lhs, rhs)
}
TERM规则解析的是类似这样的表达式"age < 20", "name = ‘jim’ "等尝出现在where 右边的表达式。我们调用上面解析代码进行测试看看，在main.go中输入如下代码：
import (
"fmt"
"parser"
)
func main() {
sqlParser := parser.NewSQLParser("age = 20")
term := sqlParser.Term()
s := fmt.Sprintf("term: %v\n", term)
fmt.Println(s)
}
请到B站查看我对上面代码进行调试演示的过程，这样更容易理解和吃透代码逻辑。接下来我们继续完成如下语法的解析：
PREDICATE -> TERM (AND PREDICATE)?
QUERY -> SELECT SELECT_LIST FROM TABLE_LIST (WHERE PREDICATE)?
SELECTION_LIST -> FIELD (COMMA SELECTION_LIST)?
TABLE_LIST -> ID (COMMA TABLE_LIST)?
这里需要注意的是PREDICATE对应的是where 后面的部分，例如where a > b and c < d，这条语句中"a>b and c < d"就是语法中的PREDICATE，对应代码如下：
func (p *SQLParser) Predicate() *query.Predicate {
//predicate 对应where 语句后面的判断部分，例如where a > b and c < b
//这里的a > b and c < b就是predicate
pred := query.NewPredicateWithTerms(p.Term())
tok, err := p.sqlLexer.Scan()
// 如果语句已经读取完则直接返回
if err != nil && fmt.Sprint(err) != "EOF" {
panic(err)
}
if tok.Tag == lexer.AND {
pred.ConjoinWith(p.Predicate())
} else {
p.sqlLexer.ReverseScan()
}
return pred
}
func (p *SQLParser) Query() *QueryData {
//query 解析select 语句
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag != lexer.SELECT {
panic("token is not select")
}
fields := p.SelectList()
tok, err = p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag != lexer.FROM {
panic("token is not from")
}
//获取select语句作用的表名
tables := p.TableList()
//判断select语句是否有where子句
tok, err = p.sqlLexer.Scan()
if err != nil {
panic(err)
}
pred := query.NewPredicate()
if tok.Tag == lexer.WHERE {
pred = p.Predicate()
} else {
p.sqlLexer.ReverseScan()
}
return NewQueryData(fields, tables, pred)
}
func (p *SQLParser) SelectList() []string {
//SELECT_LIST 对应select关键字后面的列名称
l := make([]string, 0)
_, field := p.Field()
l = append(l, field)
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag == lexer.COMMA {
//selct 多个列，每个列由逗号隔开
selectList := p.SelectList()
l = append(l, selectList...)
} else {
p.sqlLexer.ReverseScan()
}
return l
}
func (p *SQLParser) TableList() []string {
//TBALE_LSIT对应from后面的表名
l := make([]string, 0)
tok, err := p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag != lexer.ID {
panic("token is not id")
}
l = append(l, p.sqlLexer.Lexeme)
tok, err = p.sqlLexer.Scan()
if err != nil {
panic(err)
}
if tok.Tag == lexer.COMMA {
tableList := p.TableList()
l = append(l, tableList...)
} else {
p.sqlLexer.ReverseScan()
}
return l
}
新增一个go文件名为query_data.go，我们使用数据结构QueryData来存储select语句的解析结果，起内容如下：
package parser
//QueryData 用来描述select语句的操作信息
import (
"query"
)
type QueryData struct {
fields []string
tables []string
pred *query.Predicate
}
func NewQueryData(fields []string, tables []string, pred *query.Predicate) *QueryData {
return &QueryData{
fields: fields,
tables: tables,
pred: pred,
}
}
func (q *QueryData) Fields() []string {
return q.fields
}
func (q *QueryData) Tables() []string {
return q.tables
}
func (q *QueryData) Pred() *query.Predicate {
return q.pred
}
func (q *QueryData) ToString() string {
result := "select "
for _, fldName := range q.fields {
result += fldName + ", "
}
// 去掉最后一个逗号
result = result[:len(result)-1]
result += " from "
for _, tableName := range q.tables {
result += tableName + ", "
}
// 去掉最后一个逗号
result = result[:len(result)-1]
predStr := q.pred.ToString()
if predStr != "" {
result += " where " + predStr
}
return result
}
假设有SQL语句如下：
select age, name, sex from student, department where age = 20 and sex = "male"
那么我们就能调用上面代码中的Query来启动解析，其中select后面的列表名也就是"age, name, sex"由函数SelectList负责解析，from 后面的表名由函数TableList 负责解析，where后面的内容由Predicate解析，其中他会把age = 20 和 sex = "male“ 解析成expression，我们在main.go中添加如下代码，以便调用起上面代码：
import (
"fmt"
"parser"
)
func main() {
sqlParser := parser.NewSQLParser("select age, name, sex from student, department where age = 20 and sex = \"male\" ")
queryData := sqlParser.Query()
fmt.Println(queryData.ToString())
}
具体的调试演示过程请大家参看b站上的视频，通过调试演示我们才能更好的理解解析逻辑。由于本节内容较多，我们将其分割成几个小节来处理。