TiDB源码学习笔记：Parser模块

... definitions ...
%%
... rules ...
%%
... subroutines ... 

... definitions ...
%%
/* 变量 */
[a-z]    {
            yylval = *yytext - 'a';
            return VARIABLE;
         }
/* 整数 */
[0-9]+   {
            yylval = atoi(yytext);
            return INTEGER;
         }
/* 操作符 */
[-+()=/*\n] { return *yytext; }
/* 跳过空格 */
[ \t]    ;
/* 其他格式报错 */
.        yyerror("invalid character");
%%
... subroutines ... 

%token INTEGER VARIABLE
%left '+' '-'
%left '*' '/'
......
%%
program:
        program statement '\n'
        |
        ;


statement:
        expr                    { printf("%d\n", $1); }
        | VARIABLE '=' expr     { sym[$1] = $3; }
        ;


expr:
        INTEGER
        | VARIABLE              { $$ = sym[$1]; }
        | expr '+' expr         { $$ = $1 + $3; }
        | expr '-' expr         { $$ = $1 - $3; }
        | expr '*' expr         { $$ = $1 * $3; }
        | expr '/' expr         { $$ = $1  $3; }
        | '(' expr ')'          { $$ = $2; }
        ;


%%
...... 

// 我们先来定义下产生式   双引号引着的我们就代表是终结符.反之则是非终结符
// 第一个产生式是SelectStmt,也就是一个查询表达式
SelectStmt:
          // 可以变成下面这个表达式, 从什么表中拿什么字段
      SelectFiled FromTable


SelectFiled:
          // 可以是一个字段列表
          "Select" FieldList
          // 可以是所有字段 *
         | "Select" "*"


FromTable:
          // 从那个表中
          "From" TableList


FieldList:
          // 可以是一个字段
          "Field"
          // 可以是多个字段， 这个地方可以使用递归思想，也就是可以扩展无数个字段
         | FieldList "," "Field"


TableList:
          // 可以是一个表名
          "Table"
          // 可以是多个表名，同字段
         | "TableList" "," "Table"


// 好了，下面开始解析我们上面那句SQL,记住从左往右依次来，"."代表我们读到的位子
   Select . * From student
   // Select 匹配到，是终结符，没有相关表达式转换，不变
=》Select * . From student
   // 读到"*"发现 "Select" "*" 可以变成转换式 SelectFiled 于是转换
=》SelectFiled . From student
   // 继续读发现到from 没有可以转换的产生式，不变
=》SelectFiled From . student
   // 继续右边移，发现到student 可以匹配成TableList，转换
=》SelectFiled From TableList .
   // 继续往右发现没了，于是重读，发现 From TableList 可以转换
=》SelectFiled FromTable .
   // 最后这两个可以继续匹配成SelectStmt
=》SelectStmt


通过一系列的转换，最后我们获得了一个SelectStmt的表达式
这个过程可以构造成一颗树，我们根据树的结构就可以处理这句SQL了
这个例子只是一个很简单的列子，真实的结构会相当复杂

// Parse parses a query string to raw ast.StmtNode.
func (s *session) Parse(ctx context.Context, sql string) ([]ast.StmtNode, error) {
   charsetInfo, collation := s.sessionVars.GetCharsetInfo()
   parseStartTime := time.Now()
   stmts, warns, err := s.ParseSQL(ctx, sql, charsetInfo, collation)


   ......


   return stmts, nil
}

func (s *session) ParseSQL(ctx context.Context, sql, charset, collation string) ([]ast.StmtNode, []error, error) {
   if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
      span1 := span.Tracer().StartSpan("session.ParseSQL", opentracing.ChildOf(span.Context()))
      defer span1.Finish()
   }
   defer trace.StartRegion(ctx, "ParseSQL").End()
   s.parser.SetSQLMode(s.sessionVars.SQLMode)
   s.parser.EnableWindowFunc(s.sessionVars.EnableWindowFunction)
   return s.parser.Parse(sql, charset, collation)
} 

// Parse parses a query string to raw ast.StmtNode.
// If charset or collation is "", default charset and collation will be used.
func (parser *Parser) Parse(sql, charset, collation string) (stmt []ast.StmtNode, warns []error, err error) {
   ......


   var l yyLexer
   parser.lexer.reset(sql)
   l = &parser.lexer
   yyParse(l, parser)


   ......


   return parser.result, warns, nil
}

%{
  最先会看到这个大括号
  里面主要是些声明
  引入的包等等
  这个括号中的内容会原封不动的出现在生成文件里面 （就是parser.go这个文件里）
%}




// 下面就是一个联合体，这个联合体会翻译成一个结构体，在parser.go中会找到相对应的结构体yySymType，主要用来从保存在解析过程中被压入堆栈的项的属性和类型，可以是终结符或者非终结符
/*
   type yySymType struct {
   yys       int
   offset    int  offset
   item      interface{}
   ident     string
   expr      ast.ExprNode
   statement ast.StmtNode
}
*/
%union {
  offset int // offset
  item interface{}
  ident string
  expr ast.ExprNode
  statement ast.StmtNode
}




// 这些就是定义Toke（终结符）和表达式（非终结符），还有符号的优先级，结合类型
%token  <ident>




%token  <item>
%token not2
%type   <expr>
%type   <statement>
.......
%precedence sqlCache sqlNoCache
%precedence lowerThanIntervalKeyword
%precedence interval
%precedence lowerThanStringLitToken
%precedence stringLit
......
%right   assignmentEq
%left   pipes or pipesAsOr
%left   xor
%left   andand and
%left   between
......




// 上面是第一部分，由%%分割后进入第二部分，也就是定义规则，上面我们举了个简单的列子，这里的明显要更加复杂点
// 除了匹配Token并不段向上结合外，我们还会发现它在匹配到相对应的句型后有一个大括号，里面action 则是匹配成功后，进行的一些操作，比如说构建树节点
// 这个地方在我刚开始发的官方讲解文档中有一个小例子，如果还是有疑惑，可以在看看
%%


// 产生式和Alter Table的语法是对应的
AlterTableStmt:
   "ALTER" IgnoreOptional "TABLE" TableName AlterTableSpecListOpt AlterTablePartitionOpt
    // 当匹配到上面的句型时，就会进行括号中的操作
   {
      // $5 表示句型中的第五个 也就是 AlterTableSpecListOpt 这个部分
      // 相同道理$1 就是 ALTER $2 就是 IgnoreOptional .....
      // $$ 就代表这整个语句
      specs := $5.([]*ast.AlterTableSpec)
      if $6 != nil {
         specs = append(specs, $6.(*ast.AlterTableSpec))
      }
      $$ = &ast.AlterTableStmt{
         Table: $4.(*ast.TableName),
         Specs: specs,
      }
   }
|  "ALTER" IgnoreOptional "TABLE" TableName "ANALYZE" "PARTITION" PartitionNameList AnalyzeOptionListOpt
   {
      $$ = &ast.AnalyzeTableStmt{TableNames: []*ast.TableName{$4.(*ast.TableName)}, PartitionNames: $7.([]model.CIStr), AnalyzeOpts: $8.([]ast.AnalyzeOpt)}
   }
|  "ALTER" IgnoreOptional "TABLE" TableName "ANALYZE" "PARTITION" PartitionNameList "INDEX" IndexNameList AnalyzeOptionListOpt
   {
      $$ = &ast.AnalyzeTableStmt{
         TableNames:     []*ast.TableName{$4.(*ast.TableName)},
         PartitionNames: $7.([]model.CIStr),
         IndexNames:     $9.([]model.CIStr),
         IndexFlag:      true,
         AnalyzeOpts:    $10.([]ast.AnalyzeOpt),
      }
   }




// 最后上面这个产生式 AlterTableStmt 构建出来的结构对应的就是下面这个结构体， 在 ast/ddl.go 中
// AlterTableStmt is a statement to change the structure of a table.
type AlterTableStmt struct {
   ddlNode


   Table *TableName
   Specs []*AlterTableSpec
}




......

goyacc -o parser.go parser.y