lex和yacc解析SQL语句语法解析(1)

最新推荐文章于 2021-01-25 16:09:03 发布
最新推荐文章于 2021-01-25 16:09:03 发布
阅读量6.4k 收藏 14
点赞数 1
文章标签： yacc sql list whitespace struct 工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haizhenglang/article/details/5880838
版权

  最近因项目需要解析sql，并sql语句的Group By字段加入附加信息。系统的开发环境和语言。

  项目运行环境 : linux Ret Hat Enterprise 5

       开发语言 :  c,shell. perl

          基础库 : glib-2.24

 

 

  我们先从总体上来对lex和yacc的功能进行认识。lex的功能主要是完成词法的分析，yacc主要功能是完成语法的分析；这样词法分析工具和语法工具已经具备，这样我们就可以整合这两个工具来完成sql语句的分析或者是自定义语句的分析工作。

   在开始代码工作之前，我们首先要明确我们的目标。

  

   目标： 通过词法分析构建语法分析的要素；然后通过语法分析，构建语法树；最后对我们对语法树进行处理，得到我们想要的结果。

 

    1、通过lex分析定义的词；(词是构建语法的最基本单元，语法是建立在词的基础之上)

    2、通过yacc分析语法，构建语法树。

    3、通过对语法树的分析，生成或计算出我们想要的结果。

 

  我们明确了目标之后，接下来准备开始词法分析的代码编写和分析。在开始词法代码编写之前，我们根据自己的需要先语法树节点结构体的定义。根据分析我们定义的结构体如下

 

// sqlAnalysis.y

typedef struct sqlNodeType{
        int type;
        double dVal;
        char text[48];
        struct nodeType *lpNext; // 指向同一层的节点
        struct nodeType *lpSub;  // 指向子节点
}STSqlNode,*LPSTSqlNode;

 

 

%union {
        int nVal;
        LPSTSqlNode lpStNode;
};

   

定义完之后，然后定义词的规则

// sqlAnalysis.l

 

number          [-]?[0-9]+(/.[0-9]+)?
name            [_a-zA-Z][_0-9a-zA-Z()/./*]*
variable        ($/{[_a-zA-Z][_0-9a-zA-Z()/.]*/}|[_a-zA-Z][_0-9a-zA-Z()/./*]*|[-]?[0-9]+(/.[0-9]+)?)
whitespace      [ /n/t]
st              (select|SELECT|Select)
fm              (from|FROM|From)
wh              (where|WHERE|Where)
gy              (group[ ]+by|GROUP[ ]+BY|Group[ ]+By)
oy              (order[ ]+by|ORDER[ ]+BY|Order[ ]+By)
terminator      [;]
nsplit          [,]
whsplit         (and|AND|or|OR|Or|And)
define          (AS|as|As|aS)
operator        [<>=|(<=)|(>=)]
lborder         ([ ]+/([ ]+)
rborder         ([ ]+/)[ ]+)
indId           (/[[a-zA-Z0-9_]{1,24}/])

 

以上是一个SELECT sql语句简单的词规则，为了简便我们就定义简单一些。

定义完词规则之后，然后根据这些规则进行相应的处理，我们简单的处理：

 

{indId} {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=INDID;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                return INDID;
        }

 

 

  
{st}  {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=ST;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"SELECT");
                return ST;
        }

 

{fm}    {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=FM;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"FROM");
                return FM;
        }

{wh}    {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=WH;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"WHERE");
                return WH;
        }

{gy}    {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=GY;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"GROUP BY");
                return GY;
        }

{oy}    {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=OY;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"ORDER BY");
                return OY;
        }

{define}  {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=DEFINE;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"AS");
                return DEFINE;
           }

{whsplit} {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=WHSPLIT;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                return WHSPLIT;
          }

{operator} {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type= OPERATOR;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                return OPERATOR;
           }

{nsplit}        {
                        yylval.lpStNode = mallocSqlNode();
                        yylval.lpStNode->type= NSPLIT;
                        snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                        return NSPLIT;
                }
{lborder}       {
                        yylval.lpStNode = mallocSqlNode();
                        yylval.lpStNode->type= LBORDER;
                        snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                        return LBORDER;
                }

{rborder}       {
                        yylval.lpStNode = mallocSqlNode();
                        yylval.lpStNode->type= RBORDER;
                        snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                        return RBORDER;
                }

{variable} {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=VARIABLE;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                return VARIABLE;
           }

{name}  {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=NAME;
                snprintf(yylval.lpStNode->text,sizeof(yylval.lpStNode->text),"%s",yytext);
                return NAME;
        }

{number} {
                yylval.lpStNode = mallocSqlNode();
                yylval.lpStNode->type=NUMBER;
                yylval.lpStNode->dVal = strtod(yytext,NULL);
                return NUMBER;
         }

{terminator}    {
                        return TERMINATOR;
                }

{whitespace}    ;
%%

 

这里一般不是太复杂，因为词法分析的结果只是为语法分析而作的准备。是为了语法树的构建而准备。

这样词法分析就这样做好了，是很简单吧。词法分析写好了，接着我们开始编写语法分析代码。

 

语法分析代码编写，首先定义处理规则，

 

program:
        program stmt INDID TERMINATOR {
                    

        }
        |
        ;

stmt:
         st_list fm_list                                {$$=oper(OPT_BROTHER,2,$1,$2);}
        |st_list fm_list oy_list                        {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        |st_list fm_list gy_list                        {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        |st_list fm_list wh_list                        {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        |st_list fm_list wh_list gy_list                {$$=oper(OPT_BROTHER,4,$1,$2,$3,$4);}
        |st_list fm_list gy_list oy_list                {$$=oper(OPT_BROTHER,4,$1,$2,$3,$4);}
        |st_list fm_list wh_list oy_list                {$$=oper(OPT_BROTHER,4,$1,$2,$3,$4);}
        |st_list fm_list wh_list gy_list oy_list        {$$=oper(OPT_BROTHER,5,$1,$2,$3,$4,$5);}
        ;

st_list:
        ST name_list                    {$$=oper(OPT_SON,2,$1,$2);}
        ;
fm_list:
        FM NAME                         {$$=oper(OPT_SON,2,$1,$2);}
        |FM LBORDER stmt RBORDER        {$$=oper(OPT_SON,4,$1,$2,$3,$4);}
        |fm_list NSPLIT NAME            {$$=oper(OPT_SON,3,$1,$2,$3);}
        |fm_list NSPLIT LBORDER stmt RBORDER {$$=oper(OPT_SON,5,$1,$2,$3,$4,$5);}
        |fm_list DEFINE NAME            {$$=oper(OPT_SON,3,$1,$2,$3);}
        ;

oy_list:
        OY name_list                    {$$=oper(OPT_SON,2,$1,$2);}
        ;
gy_list:
        GY name_list                    {$$=oper(OPT_SON,2,$1,$2);}
        ;
wh_list:
        WH whname_list                  {$$=oper(OPT_SON,2,$1,$2);}
        ;

name_list:
         NAME                           {$$=oper(OPT_BROTHER,1,$1);}
        |name_list DEFINE NAME          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        |name_list NSPLIT NAME          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        ;

whname_list:
        whname                          {$$=oper(OPT_BROTHER,1,$1);}
        |whname_list WHSPLIT whname     {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        ;

whname:
        NAME OPERATOR VARIABLE          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
oy_list:
        OY name_list                    {$$=oper(OPT_SON,2,$1,$2);}
        ;
gy_list:
        GY name_list                    {$$=oper(OPT_SON,2,$1,$2);}
        ;
wh_list:
        WH whname_list                  {$$=oper(OPT_SON,2,$1,$2);}
        ;

name_list:
         NAME                           {$$=oper(OPT_BROTHER,1,$1);}
        |name_list DEFINE NAME          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        |name_list NSPLIT NAME          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        ;

whname_list:
        whname                          {$$=oper(OPT_BROTHER,1,$1);}
        |whname_list WHSPLIT whname     {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        ;

whname:
        NAME OPERATOR VARIABLE          {$$=oper(OPT_BROTHER,3,$1,$2,$3);}
        ;

%%

 

 

 

以上就是SQL SELECT语句语法分析的大体规则，这规则能完成select语句大部分的功能的分析，例如这样形式的语句，

    select id，name from table;

    select count(id),sun(bal) form (select id,name,bal from table) where name='sss' groub by classs;

     等类似语句的分析。

 

   在规则中的oper函数可以自己定义，然后根据你的情况和需求来处理，通过这些规则我们将根据自己需要构建语法树或者图，

    最后我们将在这里得到这个树的根节点，

      program stmt INDID TERMINATOR {

                displayTree($2);

       }

然后在这里可以对这个树进行处理，

 

 

 

水浴清风
关注
mysql yacc 解析_yacc介绍
weixin_35275189的博客
02-07 1412
在mysql源码中，解析sql在sql_yacc.yy中实现，这个文件是一个硕大的文件，用bison来转换为c文件。在《编译原理及实践》中有yacc介绍，编译原理是很深奥的科目，学好了对编程技术好很大的帮助，可惜当初没好好学，需要回炉一下。这里是从《编译原理及实践》的摘录。一个简单的算术表达式的计算器。calc.y，BNF文法如下：%{#include #include %}%token NUMB...
Pisa-Proxy SQL 解析之 Lex & Yacc
SphereEX的博客
07-07 827
在上篇文章《Pisa-Proxy 之 SQL 解析实践》中介绍了 Pisa-Proxy 的核心模块之一 SQL 解析器的相关内容。在 MySQL 和 PostgreSQL 中 SQL 解析是通过 Yacc 实现的，同样 Pisa- Proxy 的 SQL 解析器是由类似 Yacc 这样的工具实现的，所以本篇文章会围绕 SQL 解析器为大家介绍一些编译原理和 Lex & Yacc 的使用，同时也会为读者展示如何通过 Lex & Yacc 实现一个简单的 SQL 解析器。从而帮助大家更好地理解 Pisa-Pro
sqltoy(lex yacc c sql)
02-19
开发环境：windows, vc2008, mingw, flex, bison 使用的库: STL 程序名称：EasySql(sql玩具) 程序支持的命令：区分大小写 HELP; CREATE TABLE DROP TABLE INSERT INTO DELETE FROM SELECT FROM UPDATE SET 命令具体格式，可以输入HELP;命令来查看，命令关键字全部大写，以";"结尾 功能：lex yacc c sql 实现的sql玩具，希望对大家有用。
Yacc 与 Lex 快速入门
燕青专栏
09-25 1998
Yacc 与 Lex 快速入门 Lex 与 Yacc 介绍 级别: 初级
yacc 语法 mysql_mysql分析(二)mysql语法分析
weixin_29205061的博客
01-25 588
一、mysqld中对于SQL语句的分析客户端和服务器之间交互的时候，客户端发送的同样是字符串形式的查询和执行命令，返回的特定格式的数据库内容(?)。这个过程就需要在服务器端进行实时指令的翻译，生成特定的查询指令。在sqlite的实现中，sqlite定义了一个专用的虚拟机环境，和通常的真正的汇编指令相同，它有自己的指令集，有特定的指令格式和操作数，有自己的寄存器和内存内容，这个虚拟环境叫做vdbe(...
lex和yacc构建的SQL分析器
09-14
lex和yacc构建的SQL分析器，lex和yacc构建的SQL分析器
利用LEX和YACC实现对SQL查询语句的语法分析.pdf
09-19
接下来，文章详细讨论了LEX和YACC的基本工作原理，并针对SQL语句的核心语句，即SELECT语句，编写了其BNF范式。使用LEX和YACC这两个工具，实现了对SQL查询语句的词法分析和语法分析，并生成了语法树。 在进行词法和...
利用LEX,YACC实现SQL编译器
03-24
在SQL编译器中，YACC负责解析由LEX生成的词法单元，构建语法树，进而理解整个SQL语句的逻辑结构。 #### 实现嵌入式SQL分析器的流程 实现嵌入式SQL分析器的过程可以分为以下几个步骤： 1. **定义词法规则**：使用...
嵌入式数据库中利用Lex,Yacc设计SQL编译器.pdf
09-19
例如，如何设置合适的正则表达式以正确地识别SQL语句中的关键字、标识符和操作符等。 最后，文章提出了对生成的SQL语法树的优化策略。由于嵌入式系统的资源限制（如内存和处理器资源），对生成的语法树进行优化可以...
使用Bison (Yacc)和Flex的现代SQL解析器
01-27
An SQL parser, generated from Bison (Yacc) and Flex (Lex). Original version - most of the work - comes from John Levine's Flex & Bison book published by O'Reilley. Example usage: $ echo "SELECT a.name...
c语言编译器，用lex和yacc工具完成词法分析与语法分析并生成语法树
最新发布
10-19
c语言编译器，用lex和yacc工具完成词法分析与语法分析并生成语法树
lex-yacc:编译器设计算法，正则表达式，语法解析等
05-15
我的lex和yacc程序的存储库。 怎么跑？ 设置如下：0。sudo apt-get更新0。sudo apt-get install flex0。sudo apt-get install bison0。sudo apt-get git-core 获取此仓库：0。git clone 编译：0. lex filename.l 0. yacc -d filename.y 0. gcc lex.yy.c y.tab.c -ll或0. ./outlex文件名 运行：0. ./a.out
lex与yacc学习笔记（词法分析，语法分析）（适合初学）
07-13
详细全面介绍了lex和yacc，给初学者一个很好的教材。不但是你全面了解lex和yacc，而且给你很多例子。
sql解析之lex和yacc工具
egraldloi的专栏
10-12 2447
lex和yacc是用来编写自己的语言和编译器的，所以我们可以用它来编写自己所定义的sql语言和编译器。 lex是lexical analyzar，yacc是yet another compiler complier lex: lex是一个生成扫描器的工具，扫描器是一种识别词汇模式的工具，这些词汇模式在特殊的结构中定义。
yacc lex 词法解析与语法解析
晨风
10-24 2756
[wln@localhost 01]$ cat calculator.l %{ #include "y.tab.h" extern int yylval; %} %% [0-9]+ {yylval=atoi(yytext);return NUMBER;} [\t] ; \n return 0; . return yytext[0]; %% [wln@local
手把手教程-lex与yacc/flex与bison入门（一）（使用windows环境）
热门推荐
weixin_44007632的博客
09-20 5万+
前言 1.文章诞生的契机 在计算机学习中，我们有时可能会想到自制一门属于自己的编程语言，此时选择lex与yacc来生成词法分析器与语法分析器是非常不错的选择。然而，这两个工具虽然用起来简单，但对于新手来说，入门还有着些许的难度。 入门的难度通常不是因为工具的复杂，而是因为教程有些难懂。在大多数教程作者眼里，想要自制一个语言的必然不会是初学者，毕竟新手们还在被C和JAVA等语言搞得晕头转向。这导致大多数lex与yacc教程都是面向进阶选手，内容“点到为止”，并心照不宣地省略了一些“常识”。导致内容在我等这般新
Lex和Yacc应用教程(四).语法树的应用
草木瓜
05-21 1万+
Lex和Yacc应用方法(四).语法树的应用草木瓜  20070515一、序    不论什么语言，语法结构总是那几种，可以想象任何程序体都可以解释成一棵语法树，语法树的本质是递归，很显然Yacc文法的核心思想也是递归。本文就通过具体实例，使用Yacc构建递归的语法树来解决实际问题。    比较遗憾的是，在总结的过程中想表达清楚并不容易，估且三分言传，七分会意吧。关键在于个人去思考。
Lex和Yacc使用教程(五).再识语法树
草木瓜
05-25 1万+
Lex和Yacc应用方法(五).再识语法树草木瓜  20070524一、序  在《Lex和Yacc应用教程(四).语法树》一文已对语法树有了初步的概念，本文主要目的是巩固语法树的概念，并做进一步的扩展分析。闲说少说，首先给出完整示例，本例在Redhat Linux 9下调试通过，可放心使用。    另外系列文章的标题，有的叫“lex和yacc应用方法”，有的叫“lex和yacc应用教程
手把手教你win10下lex与yacc的安装
wang_yr的博客
05-08 8591
步骤1：下载UnxUtils 官网下载：https://sourceforge.net/projects/unxutils/ 步骤2：解压压缩包 选择位置，解压，记住路径。 步骤3：配置环境 右击此电脑，选择属性，点击高级系统设置 点击环境变量 新建两个变量和值 变量：bison_hairy 值：你的路径\UnxUtils\usr\local\share\bison...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值