码迷，mamicode.com
首页 > 数据库 > 详细

淘宝数据库OceanBase SQL编译器部分 源码阅读--解析SQL语法树

时间：2015-02-09 18:46:12      阅读：382      评论：0      收藏：0      [点我收藏+]

标签：

OceanBase是 阿里巴巴集团自主研发的可扩展的关系型数据库，实现了跨行跨表的事务，支持数千亿条记录、数百TB数据上的SQL操作。在阿里巴巴集团 下，OceanBase数据库支持了多个重要业务的数据存储，包括收藏夹、直通车报表、天猫评价等。截止到2013年4月份，OceanBase线上业务 的数据量已经超过一千亿条。

看起来挺厉害的,今天我们来研究下它的源代码。关于OceanBase的架构描述有很多文档，这篇笔记也不打算涉及这些东西，只讨论OceanBase的SQL编译部分的代码。

OceanBase是一个开源的数据库,托管在github上,点击下载。本文讨论的源码路径对应为：oceanbase_0.3/src/sql。最新的版本为0.4，本文讨论的代码基于0.3版本的OceanBase.目前OceanBase的能解析的SQL还比较少，包括Select,Insert,Update,Delete,Show,Explain等.

选择OceanBase 0.3 版本进行学习，基于几个原因：

  • OceanBase 的高质量，高可读性
  • OceanBase 版本低，没有历史负担
  • OceanBase SQL解析相对简单，更容易窥见全貌，利于理解设计开发中要解决的主要问题。
  • 与其他数据库的SQL解析部分进行对比，深入理解问题本质

该部分主要功能包括了，SQL语句解析，逻辑计划的生成，物理操作符运算等。

入口：ObSql类

本部分的入口函数在ob_sql.h中,调用函数ObSql::direct_execute可以直接执行SQL语句,并返回结果集ObResultSet。函数stmt_prepare用于解析要预编译的SQL语句,stmt_execute则用于执行Prepare过的SQL语句。


  1. class ObSql  
  2.    {  
  3.      public:  
  4.        ObSql(){}  
  5.        ~ObSql(){}  
  6.        int direct_execute(const common::ObString &stmt, ObResultSet &result)  
  7.        int stmt_prepare(const common::ObString &stmt, ObStmtPrepareResult &result);  
  8.        int stmt_execute(const uint64_t stmt_id, const common::ObArray<common::ObObj> params, ObResultSet &result);  
  9.        int stmt_close(const uint64_t stmt_id);  
  10.    };  


在0.4版本中，direct_execute,stmt_prepare,stmt_execute等函数都被声明为static函数,意味着调用 SQL语句执行时可以直接ObSql::direct_execute可以执行SQL语句，而不必再先定义一个ObSql对象。OceanBase还有年轻，还存在不足，我们阅读源码时应该带着批判思考的精神。
直接进入direct_execute函数，可以看到整个执行的过程,函数中有很多的if,else语句，主要是因为OceanBase有一个编码规范要求：一个函数只能有一个返回出口.按单出口的规范写代码会使得写代码的思路非常清晰，不容易出现内存泄露等问题，在大型项目中还是应该尽量保持函数单出口.当然，我觉得保持一个函数功能简洁、简单易懂也是非常重要的。

在你阅读源码的过程中，遇到的大部分函数都会是这个样.刨去其他干扰信息，结合注释，可以看到，SQL执行分为5个步骤：

  1. 初始化
    parse_init(&parse_res)
  2. 解析SQL语法树
    parse_sql(&parse_res, stmt.ptr(), static_cast<size_t>(stmt.length()));
  3. 制定逻辑计划
    resolve(&logical_plan, parse_res.result_tree_)
    ObMultiPlan* multi_plan = static_cast<ObMultiPlan*>(logical_plan.plan_tree_);
  4. 生成物理计划：
    trans.add_logical_plans(multi_plan);
    physical_plan = trans.get_physical_plan(0)
  5. 执行物理计划：
    exec_plan->open()

初始化仅仅是初始化一个缓冲区，可以略过来研究后面关键的4步。

解析SQL语法树

像PostgreSQL,MySQl等一样,OceanBase采用lex和yacc系的词法和语法解析工具生成语法树。GNU下的词法和语法工具为 Flex和Bison.Flex利用正则表达式识别SQL语句中的所有词语，Bison则根据类似BNF的语法规则识别SQL语义，从而构建语法树。不熟 悉Flex与Bison的同学推荐阅读《FLEX与BISON》(貌似我也没找到其他类似的书籍,^_^)，里面也有专门的一章讲述利用Flex与 Bison实现一个简单的SQL分析器。

OceanBase的SQL语法树与PostgreSQL更为相似，但是设计上也有很多区别。

节点设计

语法树由一系列的节点串连而成。我选取较为简单的Update语句作为示例，下面是一个例句：
Update student set sex="M" where name="小明";
其SQL语法树可以表示为：

|--Update Stmt
|--Table:student
|--TargeList:
|--sex = "M"
|--Qualifications:
|--name="小明"

语法解析的作用就是如何用数据结构来表示上面这棵语法树。不同的数据库有不同的方案。为加强对比，我选取了PostgreSQL,RedBase与OceanBase作为参照。

PostgreSQL语法树的节点设计

PostgreSQL中每一种语法都会有一个对应的结构体，比如更新语句Update对应的结构体为UpdateStmt:


  1. typedef struct UpdateStmt  
  2.   
  3.   NodeTag        type;           /* 枚举类型 */  
  4.   RangeVar   *relation;        /* 要更新的关系 */  
  5.   List       *targetList;        /* 要更新的项 */  
  6.   Node       *whereClause;    /* 更新条件 */  
  7.   List       *fromClause;        /* optional from clause for more tables */  
  8.   List       *returningList;    /* 返回的表达式列表 */  
  9.   WithClause *withClause;        /* WITH clause */  
  10. UpdateStmt;  


其中type是个枚举值,表示结构体的类型,在UpdateStmt中为T_UpdateStmt。其他字段分别对应UPdate语句的各个部分，该结构体可以支持更复杂的Update语句。
PostgreSQL中还有一个基础的结构体：


  1. typedef struct Node  
  2. {  
  3.     NodeTag        type;  
  4. } Node;  


用于语法解析的结构体都可以强制转换成Node * 类型。PostgreSQL中传递语法结构体是都会转化成Node *类型，只有在需要明确类型的时候根据type枚举值转换成需要的类型。Node *的作用有的类似于void * ,但是更利于调试。我们也可以简单的认为：诸如UpdateStmt的语法解析结构体们都继承自Node。

由于每个语法对应一个结构体，因此在PostgreSQL中存在很多类似的结构体，包括SelectStmt,InsertStmt,DeleteStmt等。最终这些结构体还会被统一转换成Query结构体。即Query是统一的语法树结构体。
在PostgreSQL中，示例中的SQL语法树可表示为：

|--UpdateStmt
|--type: T_UpdateStmt
|--relation: student
|--targetList:
|--targest[0]:
|--name: sex
|--val: "M"
|--whereClause：
|--expr: =
|--left: name
|--right: "小明"

RedBase的语法树的节点设计 

RedBase是斯坦福的数据库系统实现这门课程(cs346)的一个项目。RedBase比起PostgreSQL,OceanBase这样的复杂数据库而言，十分的简单。但是其语法树的节点设计与其他数据库不同，因此提出来做对比。
 
 



 
  
 
  
  


 
  
 
  
  
     
   
  1.  typedef struct node{   
    2.  
   
  2.     NODEKIND kind;/*枚举类型*/   
    3.  
   
  3.     
    4.  
   
  4.     union{   
    5.  
   
  5.        /* SM component nodes */   
    6.  
   
  6.        /* create table node */   
    7.  
   
  7.        struct{   
    8.  
   
  8.           char *relname;   
    9.  
   
  9.           struct node *attrlist;   
    10.  
   
  10.        } CREATETABLE;   
    11.  
   
  11.     
    12.  
   
  12.       /*此处省略n多个结构体...*/   
    13.  
   
  13.     
    14.  
   
  14.        /* QL component nodes */   
    15.  
   
  15.        /* query node */   
    16.  
   
  16.        ...   
    17.  
   
  17.     
    18.  
   
  18.        /* update node */   
    19.  
   
  19.        struct{   
    20.  
   
  20.           char *relname;                 /* 关系名 */   
    21.  
   
  21.           struct node *relattr;          /* 属性 */   
    22.  
   
  22.           struct node *relorvalue;       /* 修改后值 */   
    23.  
   
  23.           struct node *conditionlist;    /* 条件列表 */   
    24.  
   
  24.        } UPDATE;   
    25.  
   
  25.     
    26.  
   
  26.       /*此处省略n多个结构体...*/   
    27.  
   
  27.     } u;   
    28.  
   
  28.  } NODE;   
    29.

RedBase数据库的语法树结构体只有一个，就是NODE,但是这个NODE结构体的声明有150多行(^-^).NODE包括一个枚举类型,作用于 PostgreSQL中的type一样。所有的语法结构如UPDATE,SELECT,CREATETABLE等构成巨大的联合体。针对Update语句 的结构体包括了关系名,属性,修改后的值,条件列表等字段，显然这种设计只能支持简单的Update语句。
RedBase采用“巨型”联合体取代PostgreSQL中的多个结构体，免去了类型转换（语法结构体到Node*的转换）。如果把PostgreSQL语法树节点看成是“继承”结构，那么RedBase的语法树节点可以看成是“组合”结构。
在RedBase中，示例中的SQL语法树可表示为：

|--NODE:
|--kind: N_UPDATE
|--u:UPDATE
|--relname: student
|--relattr:
|--kind: N_RELATTR
|--u:RELATTR
|--relname: (null)
|--attrname: sex
|--relorvalue:
|--kind: N_RELATTR_OR_VALUE
|--u:RELATTR_OR_VALUE
|--relattr: (null)
|--value:
|--kind:N_VALUE
|--u:VALUE
|--sval = "M"
|--conditionlist:
|--kind:N_LIST
|--u: LIST
|--next: (null)
|--curr:
|--kind: N_CONDITION
|--u: CONDITION
|--lhsRelattr:
|--kind: N_RELATTR
|--u:RELATTR
|--relname: (null)
|--attrname: name
|--op:
|--kind: N_EQ
|--rhsRelattr:(null)
|--rhsValue:
|--kind:N_VALUE
|--u:VALUE
|--sval = "M"

OceanBase的语法树的节点设计

OceanBase 的语法树节点结构体也只有一个,该结构体包括一个枚举类型变量type_,和PostgreSQL与RedBase一样，代表该结构体对应的类型。还有两 组属性，对应终止符节点,只能使用vakue_和str_value_两个字段，分别对应64位整形值和字符串值；非终止符节点使用最后两个字 段,num_child_表示子节点的个数,children_指向子节点数组的首地址。


  1. typedef struct _ParseNode  
  2. {  
  3.   ObItemType   type_;  
  4.   
  5.   /* 终止符节点的真实的值 */  
  6.   int64_t      value_;  
  7.   const char*  str_value_;  
  8.   
  9.   /* 非终止符节点的孩子节点*/  
  10.   int32_t      num_child_; /*孩子节点的个数*/  
  11.   struct _ParseNode** children_;   
  12.   
  13.   // BuildPlanFunc m_fnBuildPlan;  
  14. } ParseNode;  


对应一个节点而言，要么是终止符节点要么是非终止符节点，它只会使用两组属性中的一组。int,long,float,double,string等都是 终止符类型，可以看出int,long都是用64位整形int64表示。float,double,string则用char *字符串表示。终止符的num_child_为0,children_为null.

PostgreSQL的子节点都是有名字的子节点，可以使用名字进行访问，如在PostgreSQL中，Update语句的where条件可以通过updatestmt.whereClause来访问 。 但在OceanBase中不行 ， 所有的子节点都是匿名的 ， 只能通过下标来访问。

打个比方，在PostgreSQL和RedBase中，孩子是有名字的，可以叫小明、小红等，根据名字你大概可以知道这个孩子是男是女；但是在OceanBase家，他们分别叫老大，老二，老三，听名字完全听不出是男是女的。OceanBase家有点不讲究^-^。

可以在运行时查看语法树的结构，也可以在代码中可以推各个子节点代表的类型，但是不如PostgreSQL和RedBase方便。在sql_parser.y文件中，定义了SQL的语法规则，同时也规定了各种类型的子节点的结构。


  1. update_stmt:   
  2.     UPDATE relation_factor SET update_asgn_list opt_where  
  3.     {  
  4.       ParseNode* assign_list = merge_tree(result->malloc_pool_, T_ASSIGN_LIST, $4);  
  5.       $$ = new_non_terminal_node(result->malloc_pool_, T_UPDATE, 3, $2, assign_list, $5);  
  6.     }  
  7.   ;  


从上述代码可以看出，Update语法结构体中有3个子节点，第一个表示表名，第二个表示要更新列表项，第三个表示更新的条件语句。
示例中的Update语句在OceanBase中可以表示为如下形式：

|--ParseNode
|--type: T_UPDATE
|--num_child: 3
|--children[0]:
|--type: T_IDENT
|--str_value: student
|--children[1]:
|--type: T_ASSIGN_LIST
|--num_child:1
|--children[0]:
|--type: T_ASSIGN_ITEM
|--children[0]:
|--type: T_IDENT
|--str_value: sex
|children[1]:
|--type: T_EXPR
|--children[0]:
|--type: T_STRING
|--str_value: "M"
|--children[2]:
|--type: T_OP_EQ
|--num_child: 2
|--children[0]:
|--type: T_IDENT
|--str_value: name
|--children[1]:
|--type: T_IDENT
|--str_value: "小明"

OceanBase中采用的这种方式缺点很明显，就是使用这些结构体时必须要仔细辨别各个子节点代表的意义，否则容易出错。优点同样也很明显，可以非常灵活的构建出语法树。

语法树的节点的设计，主要是为了解决如何表达语法结构。不同的数据库有不同的具体实现。OceanBase采用终止符和非终止符分类，使用OceanBase的设计极具灵活性，但使用时需要仔细验证，避免出错。

构建语法树

SQL的语法规则很多 ， SELECT , INSERT , UPDATE , DELETE , CREATE TABLE 等 dml , ddl 等语句都有对应的语法树。在上一节节中我们已经看到了UPDATE语句在内存中的语法树形状。本节需要些Flex和Bison的基础知识，如果之前没有接 触过Flex与Bison的话，可以阅读《Flex与Bison中文版》或者GNU Bison 2.1 中文手册。
SQL全称为结构化查询语言，有独立于各数据库厂家的SQL标准，各数据库基本上都会大体上遵循该标准。像PostgreSQL数据库兼容某些版本的 SQL标准，同时也有些自己独有的语句。每个数据库都有自己的擅长之处，这些细微的区别有时候就体现在查询语言的细微区别上。OceanBase在0.3 版本仅支持有限的几条SQL语句，按照其官方的介绍，其目标之一是兼容MySQL的语法，让我们拭目以待。

词法分析

利用Flex进行词法分析是构建语法树的第一个。Flex源文件包含3部分:选项定义、词法规则、代码部分。选项定义部分定义了该词法分析器使用的特性和 一些自定义的函数。词法规则部分为匹配语法+匹配动作。匹配语法为正则表达式，flex从上往下按顺序对每个规则进行匹配，一旦匹配成功则执行该项后面大 括号内对应的动作代码;代码部分则是C语言代码。

OceanBase的词法文件为sql_parser.l。其中定义了一些函数，选取部分来看。

下面这两个函数可以使得OceanBase支持转义字符，包括：\b,\f,\n,\r,\t.


  1. inline unsigned char escaped_char(unsigned char c);  
  2.   
  3. /* quote_type: 0 - single quotes; 1 - double quotation marks */  
  4. int64_t parse_string(const char* src, char* dest, int64_t len, int quote_type);  


OceanBase中的字符串用双引号括起来的表示，而且需要进行转义处理。


  1. \"(\\.|\"\"|[^"\\\n])*\" {  
  2.   ParseNode* node = NULL;  
  3.   malloc_new_node(node, ((ParseResult*)yyextra)->malloc_pool_, T_IDENT, 0);  
  4.   yylval->node = node;  
  5.   char* src = yytext+1;  
  6.   int len = strlen(src) - 1; //remove last quote charactor  
  7.   char* dest = (char*) parse_malloc(len + 1, ((ParseResult*)yyextra)->malloc_pool_);  
  8.   check_value(dest);  
  9.   node->str_value_ = dest;  
  10.   node->value_ = parse_string(src, dest, len, 1);/*字符串转义处理*/  
  11.   return NAME;  
  12. }  


当匹配到NULL时，返回的值类型不能为NULL，因为NULL是c语言的保留字，所以需要换成其他名字，此处将NULL的类型定义为NULLX。


  1. NULL   {  
  2.   /* yylval->node = new_node(((ParseResult*)yyextra)->malloc_pool_, T_NULL, 0); */  
  3.   malloc_new_node(yylval->node, ((ParseResult*)yyextra)->malloc_pool_, T_NULL, 0);  
  4.   return NULLX;  
  5. }  


再来看关系符号的规则代码，每个符号分别返回一个值。


  1. "||" {return CNNOP;}  
  2. "=" {return COMP_EQ;}  
  3. ">=" {return COMP_GE;}  
  4. ">" {return COMP_GT;}  
  5. "<=" {return COMP_LE;}  
  6. "<" {return COMP_LT;}  
  7. "!="|"<>" {return COMP_NE;}  


在《Flex与Bison》一书中，作者让所有关系符号返回同一个值，通过yylval的成员值来标记不同符号。代码类型如下这段。


  1. "=" { yylval.subtok = EXPR_EQ; return COMPARISON; }  
  2. "<=>"   { yylval.subtok = EXPR_COMP; return COMPARISON; }  
  3. ">="    { yylval.subtok = EXPR_GE; return COMPARISON; }  
  4. ">" { yylval.subtok = EXPR_GT; return COMPARISON; }  
  5. "<="    { yylval.subtok = EXPR_LE; return COMPARISON; }  
  6. "<" { yylval.subtok = EXPR_LT; return COMPARISON; }  
  7. "!="    |  
  8. "<>"    { yylval.subtok = EXPR_NE; return COMPARISON; }  


虽然都能完成相同的功能，但是从个人喜好来讲，我更喜欢OceanBase这种做法，因为够直接。

整数的值保留在node->value_中返回，为long long 类型 （ 64位 ） 。 而浮点数的值字面值则保存在node->str_value_ 中。

接下来，看日期时间的提取。


  1. Date{whitespace}?‘[0-9]{4}(-[0-9]{2}){2}‘ {  
  2.   int year, month, day;  
  3.   struct  tm time;  
  4.   int ret = 0;  
  5.   
  6.   /* ParseNode* node = new_node(((ParseResult*)yyextra)->malloc_pool_, T_DATE, 0); */  
  7.   ParseNode* node = NULL;  
  8.   malloc_new_node(node, ((ParseResult*)yyextra)->malloc_pool_, T_DATE, 0);  
  9.   char* dest = strchr(yytext, ‘\‘‘);  
  10.   dest =  parse_strdup(dest + 1, ((ParseResult*)yyextra)->malloc_pool_); // skip left quote  
  11.   check_value(dest);  
  12.   size_t len = strlen(dest);  
  13.   dest[len - 1] = ‘\0‘; //remove final ‘  
  14.   
  15.   node->str_value_ = dest;//字面值  
  16.   
  17.   ret = sscanf(dest, "%4d-%2d-%2d", &year, &month, &day);  
  18.   assert(ret == 3);  
  19.   
  20.   memset(&time, 0, sizeof(struct tm));  
  21.   time.tm_year = year - 1900;  
  22.   time.tm_mon = month - 1;  
  23.   time.tm_mday = day;  
  24.   time.tm_hour = 0;  
  25.   time.tm_min = 0;  
  26.   time.tm_sec = 0;  
  27.   time.tm_isdst = -1;  
  28.   
  29.   node->value_ = mktime(&time) * 1000000L;//转成微秒  
  30.   yylval->node = node;  
  31.   return DATE_VALUE;  
  32. }  


从表达式中可以看到，OceanBase支持直接传入日期时间，OceanBase也支持Time和Timestamp类型。具体如下表：

类型 格式(不区分大小写) 表达式
Date Date ‘YYYY-MM-DD‘ Date{whitespace}?‘[0-9]{4}(-[0-9]{2}){2}‘
Time Time ‘HH:MI:SS.FF‘或Time ‘HH:MI:SS Time{whitespace}?‘[0-9]{2}(:[0-9]{2}){2}[.][0-9]{1,6}‘，Time{whitespace}?‘[0-9]{2}(:[0-9]{2}){2}[.]?‘
Timestamp Timestamp ‘YYYY-MM-DD HH:MI:SS.FF‘或 Timestamp ‘YYYY-MM-DD HH:MI:SS‘ Timestamp{whitespace}?‘[0-9]{4}(-[0-9]{2}){2}[ ][0-9]{2}(:[0-9]{2}){2}[.][0-9]{1,6}‘，Timestamp{whitespace}?‘[0-9]{4} (-[0-9]{2}){2}[ ][0-9]{2}(:[0-9]{2}){2}[.]?‘

如下是一个使用日期的示例： 

select id,name from student where createtime <= date ‘2014-09-12‘;

语法树中存在日期类型的节点,其str_value_存储时间的字面值，value_存储该时间与基准时间（1970年1月1日0时0分0秒）之差的毫秒值。

OceanBase通过拓展标准的SQL语法支持直接在SQL语句中写入时间 ,在词法分析阶段就识别到时间类型，而 PostgreSQL 是在语法分析阶段才会识别时间 。 相比而言 ， OceanBase 这种方式更直观，方便。

在0.4版本的OceanBase中，增加了预编译的功能，需要识别占位符"?",系统变量和用户变量。对应性质如下：

名称 表达式 动作代码返回值
占位符(?) "?" QUESTIONMARK
系统变量(system_variable) (@@[A-Za-z_][A_Za-z0-9_]*) SYSTEM_VARIABLE
用户变量(temp_variable) (@[A-Za-z_][A_Za-z0-9_]*) TEMP_VARIABLE

语法分析

OceanBase的SQL语法文件为sql_parser.y。.y语法文件最终由Bison转为可编译的.c文件。其结构与Flex的.l文件类似， 分为选项部分，规则部分和代码部分。下面的代码都是去掉了关联的动作代码的规则语法，这样有助于更专注的理解语法的实现。

select语法

在SQL的语句语法中，最复杂的语法莫过于Select语句。我们先来看其在OceanBase中的语法。一个select语句可以使带括号的select语句，也可以使不带括号的select语句：


  1. select_stmt:   
  2.     select_no_parens    %prec UMINUS    /* 不到括号的select语句 */  
  3.   | select_with_parens    %prec UMINUS  /* 带括号的select语句 */  
  4.   ;  


%prec用于交换左右两个标记的优先级和结合性。即select_no_parens与UMINUS互换优先级和结核性，select_with_parens 与UMINUS互换优先级和结核性。UMINUS的定义为%right UMINUS。所有上面两句的结果是select_no_parens和select_with_parens都变成了右结合。

带括号的select语句可以是只带一个括号，也可以带多对括号：


  1. select_with_parens:  
  2.     ‘(‘ select_no_parens ‘)‘      /*只带一个括号*/  
  3.   | ‘(‘ select_with_parens ‘)‘    /*带多对括号*/  
  4.   ;  


不带括号的select语句包括简单的select，带order by排序，带order by排序和limit限制的select语句3种：


  1. select_no_parens:  
  2.     simple_select                
  3.   | select_clause order_by  
  4.   | select_clause opt_order_by select_limit  
  5.   ;  


select子句包括简单slect和带括号的select：


  1. select_clause:  
  2.     simple_select                   
  3.   | select_with_parens             
  4.   ;  


为什么不包括不带括号的select,暂时没想通。

简单select语句包括我们常见的select 语句，但没有order by和limit选项;同时还包括UNION,INTERSECT,EXCEPT三种运算：


  1. simple_select:   
  2.     SELECT opt_distinct select_expr_list   
  3.     FROM from_list  
  4.     opt_where opt_groupby opt_having  
  5.   | select_clause UNION opt_distinct select_clause  
  6.   | select_clause INTERSECT opt_distinct select_clause  
  7.   | select_clause EXCEPT opt_distinct select_clause  
  8.   ;  


select语句的定义相对其他语句很复杂，而且上面这段代码还没有包括无表的select和for update的select。(这两项在0.4版本的OceanBase中已经实现)。

下面这段是从PostgreSQL9.2.3中截取的Select语法：


  1. SelectStmt: select_no_parens      %prec UMINUS  
  2.       | select_with_parens    %prec UMINUS  
  3.     ;  
  4.   
  5. select_with_parens:  
  6.       ‘(‘ select_no_parens ‘)‘         
  7.       | ‘(‘ select_with_parens ‘)‘     
  8.     ;  
  9. select_no_parens:  
  10.       simple_select             
  11.       | select_clause sort_clause  
  12.       | select_clause opt_sort_clause for_locking_clause opt_select_limit  
  13.       | select_clause opt_sort_clause select_limit opt_for_locking_clause  
  14.       | with_clause select_clause  
  15.       | with_clause select_clause sort_clause  
  16.       | with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit  
  17.       | with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause  
  18.     ;  
  19.   
  20. select_clause:  
  21.       simple_select               
  22.       | select_with_parens        
  23.     ;  
  24. simple_select:  
  25.       SELECT opt_distinct target_list  
  26.       into_clause from_clause where_clause  
  27.       group_clause having_clause window_clause  
  28.       | values_clause               
  29.       | TABLE relation_expr  
  30.       | select_clause UNION opt_all select_clause  
  31.       | select_clause INTERSECT opt_all select_clause  
  32.       | select_clause EXCEPT opt_all select_clause  
  33.     ;  


不知道你是不是有种似曾相识的感觉。没错，在这里，OceanBase借鉴了PostgreSQL的语法分析方式。PostgreSQL号称世界上最优秀的开源数据库，绝非浪得虚名。

update语法

为保证示例的完整性，我们在来分析下update的语法。


  1. /*0.3版本的OceanBase*/  
  2. update_stmt:   
  3.     UPDATE relation_factor SET update_asgn_list opt_where  
  4.   ;  
  5.   
  6. update_asgn_list:   
  7.     update_asgn_factor  
  8.   | update_asgn_list ‘,‘ update_asgn_factor  
  9.   ;  
  10.   
  11. update_asgn_factor:  
  12.     NAME COMP_EQ expr  
  13.   ;  


上面为0.3版本中的update的语法，支持常见的update的SQL语句，如果将它和0.4版本的update的语法相比，就会发现：0.4版本的 update在set时可以使用保留关键字作为列名，支持hint语法,支持when子句。随着OceanBase逐渐完善，其解析的语法也必然会越来越 复杂。在学习的时候，从一个简单的版本开始，由易到难，就显得很重要。

  1. /*0.4版本的OceanBase*/  
  2. update_stmt:  
  3.     UPDATE opt_hint relation_factor SET update_asgn_list opt_where opt_when  
  4.   ;  
  5. update_asgn_factor:  
  6.     column_name COMP_EQ expr  
  7.   ;  
  8. column_name:  
  9.     NAME  
  10.   | unreserved_keyword  
  11.   ;  
  12. opt_when:  
  13.     /* EMPTY */  
  14.   | WHEN expr  
  15.   ;  


除了select，比较复杂还有create table,alter table,expr等。本节最后只讨论表达式的语法问题。其他的不再讨论。

表达式语法

expression 是指表达列名或者是一个能够给出真假的布尔表达式。如
a+3 > b
a is not null
等等。表达式最常出现在where子句中，用于过滤数据行。

表达式的语法之所以复杂，是因为表达式可以嵌套多个子表达式，多个子表达式出现后可能会出现语法上的歧义。BETWEEN ... AND 用于测试给的表达式是否在给定的范围内，这个操作符中的AND 与逻辑与的AND有歧义。需要使用%prec来改变其优先级和结合性，该方法能奏效，但是PostgreSQL和OceanBase都选择从语法树规则上 完全消除该歧义。

OceanBase中表达式有3种类型，分别为expr , arith_expr , simple_expr。其中

  • expr :expr为表达式的核心，是不受约束的表达式，可以直接用于where，having等子句中。
  • arith_expr :arith_expr是可以用于between ... and之间的表达式，是受约束的表达式。因此arith_expr是expr的一个真子集。
  • simple_expr :simple_expr是简单表达式，不能直接进行自我递归的表达式。是expr和aritharith_expr的共有的部分。
  1. expr_const:  
  2.     STRING   
  3.   | DATE_VALUE   
  4.   | INTNUM   
  5.   | APPROXNUM   
  6.   | BOOL   
  7.   | NULLX   
  8.   | QUESTIONMARK   
  9.   | TEMP_VARIABLE   
  10.   | SYSTEM_VARIABLE   
  11.   | SESSION_ALIAS ‘.‘ column_name   
  12.   ;  
  13.   
  14. simple_expr:  
  15.     column_ref  
  16.   | expr_const  
  17.   | ‘(‘ expr ‘)‘  
  18.   | ‘(‘ expr_list ‘,‘ expr ‘)‘  
  19.   | case_expr  
  20.   | func_expr  
  21.   | when_func  
  22.   | select_with_parens        %prec UMINUS  
  23.   | EXISTS select_with_parens  
  24.   ;  
  25.   
  26. /* used by the expression that use range value, e.g. between and */  
  27. arith_expr:  
  28.     simple_expr     
  29.   | ‘+‘ arith_expr %prec UMINUS  
  30.   | ‘-‘ arith_expr %prec UMINUS  
  31.   | arith_expr ‘+‘ arith_expr   
  32.   | arith_expr ‘-‘ arith_expr   
  33.   | arith_expr ‘*‘ arith_expr   
  34.   | arith_expr ‘/‘ arith_expr   
  35.   | arith_expr ‘%‘ arith_expr   
  36.   | arith_expr ‘^‘ arith_expr   
  37.   | arith_expr MOD arith_expr   
  38.   
  39. expr:  
  40.     simple_expr     
  41.   | ‘+‘ expr %prec UMINUS  
  42.   | ‘-‘ expr %prec UMINUS  
  43.   | expr ‘+‘ expr   
  44.   | expr ‘-‘ expr   
  45.   | expr ‘*‘ expr   
  46.   | expr ‘/‘ expr   
  47.   | expr ‘%‘ expr   
  48.   | expr ‘^‘ expr   
  49.   | expr MOD expr   
  50.   | expr COMP_LE expr   
  51.   | expr COMP_LT expr   
  52.   | expr COMP_EQ expr   
  53.   | expr COMP_GE expr   
  54.   | expr COMP_GT expr   
  55.   | expr COMP_NE expr   
  56.   | expr LIKE expr   
  57.   | expr NOT LIKE expr   
  58.   | expr AND expr %prec AND  
  59.   | expr OR expr %prec OR  
  60.   | NOT expr  
  61.   | expr IS NULLX  
  62.   | expr IS NOT NULLX  
  63.   | expr IS BOOL  
  64.   | expr IS NOT BOOL  
  65.   | expr IS UNKNOWN  
  66.   | expr IS NOT UNKNOWN  
  67.   | expr BETWEEN arith_expr AND arith_expr        %prec BETWEEN  
  68.   | expr NOT BETWEEN arith_expr AND arith_expr      %prec BETWEEN  
  69.   | expr IN in_expr  
  70.   | expr NOT IN in_expr  
  71.   | expr CNNOP expr  
  72.   ;  


simple_expr为简单表达式，并不是说它很简单，因为simple_expr也包含了select_with_parens(带括号的select语句)等语句，只能说simple_expr不能像arith_expr和expr等一样递归调用。


  1. expr:expr BETWEEN arith_expr AND arith_expr        %prec BETWEEN  
  2.   | expr NOT BETWEEN arith_expr AND arith_expr      %prec BETWEEN  
  3.   ;  


arith_expr用于between ... and 之间，只包含了算术表达式，没有is,like 以及比较关系表达式。

expr,arith_expr,simple_expr实际上等同于PostgreSQL中的a_expr,b_expr,c_expr。

总之，在语法树规则和词法分析方面，OceanBase大量的借鉴了PostgreSQL。

节点的创建

确定了节点的结构和语法树的形状，就到了实际创建语法树的过程。通常,1条SQL语句的语法树存在多个节点，数据库中要高效的执行多条语句，就会遇到大量 的节点创建问题。如果每次创建都调用new/malloc等系统函数必然会浪费大量的时，而且还会造成内存碎片。这种问题常常会出现在现实中，各个数据库 都有自己不同的解决办法，但基本原理是一次性向系统申请较大的内存，然后在需要的时候自行分配。
接下来我将对比PostgreSQL，RedBase，OceanBase 3个数据库是各自如何解决这一问题的。

PostgreSQL创建语法树节点

PostgreSQL使用两个宏完成节点的创建，即makeNode和newNode.


  1. #define makeNode(_type_)  ((_type_ *) newNode(sizeof(_type_),T_##_type_))  
  2.   
  3. /* 针对gcc版本的newNode */#define newNode(size, tag) \  
  4. ({    Node *_result; \  
  5.     AssertMacro((size) >= sizeof(Node));/* 检测申请的内存大小，>>=sizeof(Node) */ \  
  6.     _result = (Node *) palloc0fast(size); /* 申请内存 */ \  
  7.     _result->type = (tag); /*设置TypeTag */ \  
  8.     _result; /*返回值*/\  
  9. })  
  10.   
  11. #define palloc0fast(sz) \  
  12.     ( MemSetTest(0, sz) ? \  
  13.         MemoryContextAllocZeroAligned(CurrentMemoryContext, sz) : \  
  14.         MemoryContextAllocZero(CurrentMemoryContext, sz) )  


注意：要避免直接使用newNode来创建节点，因为节点的大小在不同的环境下可能是不同的。使用makeNode即可，如：
Stmt *s = makeNode(Stmt);

我们知道,PostgreSQL中继承自NODE*的结构体们各自大小不一，都大于等于NODE 的大小。newNode中使用palloc0fast申请内存，它仍然是个宏，最终调用的是PostgreSQL中的MemoryContextAllocZeroAligned或者MemoryContextAllocZero函数，这两个函数来自PostgreSQL中内存管理模块--内存上下文，该模块能够很好的应对内存碎片，向数据库进程提供缓冲区管理。

RedBase创建语法树节点

RedBase没有提供向PostgreSQL一样复杂的内存管理机制，而是采用简单的方法来解决频繁创建节点的问题。因为RedBase中语法树的节点 都是NODE类型的，所有RedBase使用一个NODE的数组来作为缓冲区，默认最大值为100,超过这个值就会创建出错，并最终退出程序。如果你的 SQL语句需要的节点超过100,需要在编译之前修改最大节点数目MAXNODE以适应需求。


  1. #define MAXNODE        100 //最大节点数目  
  2.   
  3. static NODE nodepool[MAXNODE];  
  4. static int nodeptr = 0;  
  5.   
  6. /* 
  7.  * newnode: allocates a new node of the specified kind and returns a pointer 
  8.  * to it on success.  Returns NULL on error. 
  9.  */  
  10. NODE *newnode(NODEKIND kind)  
  11. {  
  12.     NODE *n;  
  13.   
  14.     /* if we‘ve used up all of the nodes then error */  
  15.     if(nodeptr == MAXNODE){  
  16.     fprintf(stderr, "out of memory\n");  
  17.     exit(1);  
  18.     }  
  19.   
  20.     /* get the next node */  
  21.     n = nodepool + nodeptr;  
  22.     ++nodeptr;  
  23.   
  24.     /* initialize the `kind‘ field */  
  25.     n -> kind = kind;  
  26.     return n;  
  27. }  


OceanBase创建语法树节点

OceanBase创建语法树节点的方式与PostgreSQL类似，上层调用，底层有负责内存池管理的模块来负责真正的创建，不过不是内存上下文，而是一个类ObStringBuf.

OceanBase的new_node函数申请内存时调用的是parse_malloc函数，该函数专用于语法树结构体的创建,从obStringBuf中获取内存，直到obStringBuf线程退出时才会真正释放这些内存。

大型的数据库都会有专门的内存管理模块来负责语法程序运行过程中的内存申请和释放，小型的数据库则结合自身特点，量身定制轻量的内存管理机制。目的都只有一个：降低频繁创建和销毁语法树节点的开销。

总结

SQL的执行包括了解析语法树，制定逻辑查询计划，执行物理查询计划等步骤。通过对比3个不同的数据库的源代码，得出在解析语法树中遇到的一些共性问题：

  • 如何表示一个语法树的节点
  • 利用Bison定义语法树的结构时的一些难点，如select,expr等
  • 如何降低频繁创建和销毁语法树节点的开销

如果你要自己来写一个SQL解析程序的话，这些问题同样难以避免。

欢迎光临我的网站----我的博客园----我的CSDN。
如果阅读本文过程中有任何问题，请联系作者，转载请注明出处！

淘宝数据库OceanBase SQL编译器部分 源码阅读--解析SQL语法树

标签：

原文地址：http://my.oschina.net/u/1398304/blog/376816
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！