使用flex和bison实现的sql引擎解析

由于老师要求,最近在做oceanbase存储过程的实现,在oceanbase 0.4以前是不支持存储过程的。实现的主要步骤主要包括

1、语法解析

2、词法解析

3、具体执行语法树的步骤

现在先来说说语法解析吧,在这一块主要是使用的flex( 词法分析器生成工具) 和bison(语法分析器生成器) 这两个是对用户输入的存储过程语句进行解析的

来具体说说该怎么实现对sql语句的分析吧

1、首先建立一个lex的文件

%option noyywrap nodefault yylineno case-insensitive

%{

#include "prosql.tab.hpp"
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
//YYSTYPE yylval;
int oldstate;
extern "C" int yylex();
//extern "C" int yyparse();
extern "C" void yyerror(const char *s, ...);
extern char globalInputText[10000];
extern int readInputForLexer( char *buffer, int *numBytesRead, int maxBytesToRead );
#undef YY_INPUT
#define YY_INPUT(b,r,s) readInputForLexer(b,&r,s)
%}

%x COMMENT

%%

CREATE		{ return CREATE; }
PROCEDURE	{ return PROCEDURE; }
SQL		{ return SQL; }

DECLARE		{ return DECLARE; }
SET		{ return SET; }
BEGIN		{ return BEGINT; }
END		{ return END; }

INT		{ return INT; }
VARCHAR		{ return VARCHAR; }
DATE		{ return DATE; }
TIME		{ return TIME; }
DOUBLE		{ return DOUBLE; }

IF		{ return IF; }
THEN		{ return THEN; }
ELSE		{ return ELSE; }
ENDIF		{ return ENDIF; }
FOR		{ return FOR; }
WHEN		{ return WHEN; }
WHILE		{ return WHILE; }

[0-9]+	{ yylval.strval = strdup(yytext);/*printf("number=%s\n",yylval.strval);*/ return INTNUM; }/*number*/

[0-9]+"."[0-9]* |
"."[0-9]+	|
[0-9]+E[-+]?[0-9]+	|
[0-9]+"."[0-9]*E[-+]?[0-9]+ |
"."[0-9]*E[-+]?[0-9]+	{ yylval.strval = strdup(yytext);/*printf("float=%s\n",yylval.strval);*/ return APPROXNUM; }/*double*/

TRUE	{ yylval.strval = "1";/*printf("bool=%s\n",yylval.strval);*/ return BOOL; }/*bool*/

FALSE	{ yylval.strval = "0";/*printf("bool=%s\n",yylval.strval);*/ return BOOL; }/*bool*/

'(\\.|''|[^'\n])*'	|
\"(\\.|\"\"|[^"\n])*\"  {
				char *temp = strdup(yytext);
				yylval.strval = strdup(yytext);

				//GetCorrectString(yylval.strval, temp);

				/*printf("string=%s\n",yylval.strval);*/
				return STRING;
			}/*string*/
'(\\.|[^'\n])*$		{ yyerror("Unterminated string %s", yytext); }
\"(\\.|[^"\n])*$		{ yyerror("Unterminated string %s", yytext); }

X'[0-9A-F]+' |
0X[0-9A-F]+  	{ yylval.strval = strdup(yytext); return STRING; }

0B[01]+      |
B'[01]+'     { yylval.strval = strdup(yytext); return STRING; }

[-+&~|^/%*(),.;!]   { return yytext[0]; }

"&&"	{ return ANDOP; }
"||"	{ return OR; }

"<"	{ yylval.subtok = 1; return COMPARISON; }
">"	{ yylval.subtok = 2; return COMPARISON; }
"!="	|
"<>"	{ yylval.subtok = 3; return COMPARISON; }
"="	{ yylval.subtok = 4; return COMPARISON; }
"<="	{ yylval.subtok = 5; return COMPARISON; }
">="	{ yylval.subtok = 6; return COMPARISON; }
"<=>"	{ yylval.subtok = 12; return COMPARISON; }

"<<"	{ yylval.subtok = 1; return SHIFT; }
">>"	{ yylval.subtok = 2; return SHIFT; }

[A-Za-z][A-Za-z0-9_]*	{ yylval.strval = strdup(yytext);
			  /*printf("name 1=%s\n",yylval.strval);*/
                          return NAME; }
`[^`/\\.\n]+`           { yylval.strval = strdup(yytext+1);
			  /*printf("name 2=%s\n",yylval.strval);*/
                          yylval.strval[yyleng-2] = 0;
                          return NAME; }

`[^`\n]*$               { yyerror("unterminated quoted name %s", yytext); }

@[0-9a-z_.$]+ |
@\"[^"\n]+\" |
@`[^`\n]+` |
@'[^'\n]+' { yylval.strval = strdup(yytext+1);  return USERVAR; }

@\"[^"\n]*$ { yyerror("unterminated quoted user variable %s", yytext); }
@`[^`\n]*$ { yyerror("unterminated quoted user variable %s", yytext); }
@'[^'\n]*$ { yyerror("unterminated quoted user variable %s", yytext); }

":="     { return ASSIGN; }

#.*		;
"--"[ \t].*	;

"/*"            { oldstate = YY_START; BEGIN COMMENT; }
<COMMENT>"*/"   { BEGIN oldstate; }
<COMMENT>.|\n   ;
<COMMENT><<EOF>> { yyerror("unclosed comment"); }

[ \t\n]         /* white space */
.               { yyerror("mystery character '%c'", *yytext); }

%%

这一部分呢就是对 每个我们自定义的满足正则的识别

接下来是对词的语法识别

%{
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>
char * parsetreeroot=NULL;
extern "C" int yylex();
extern "C" int yyparse();
extern "C" void yyerror(const char *s, ...);
char globalInputText[10000];
int globalReadOffset;
int readInputForLexer( char *buffer, int *numBytesRead, int maxBytesToRead );
char * mystrcat(char *s1,char *s2)
{
	char *p1=(char *)malloc(strlen(s1)+strlen(s2)+1);
	strcpy(p1,s1);
	strcat(p1,s2);
	return p1;
}
%}
%locations
%union {
	int intval;
	double floatval;
	char *strval;
	int subtok;
}
%token <strval> NAME
%token <strval> STRING
%token <strval> INTNUM
%token <strval> BOOL
%token <strval> APPROXNUM
%token <strval> USERVAR

%type <strval> stmt_root  create_stmt para_list definition  data_type pro_block pro_parameters declare_list set_list
%type <strval> assign_var  pro_body pro_stmt_list sql_stmt expr

%right ASSIGN
%left OR
%left XOR
%left ANDOP

%left NOT '!'
%left BETWEEN
%left <subtok> COMPARISON /* = <> < > <= >= <=> */
%left '|'
%left '&'
%left <subtok> SHIFT /* << >> */
%left '+' '-'
%left '*' '/' '%' MOD
%left '^'

%token CREATE
%token PROCEDURE
%token PRONAME
%token DECLARE
%token SET
%token BEGINT
%token END
%token SQL

%token INT
%token VARCHAR
%token DATE
%token TIME
%token DOUBLE

%token IF
%token NOT
%token EXISTS
%token THEN
%token ELSE
%token ENDIF
%token FOR
%token WHEN
%token WHILE
%start stmt_root
%%

stmt_root: create_stmt pro_block { $$=mystrcat($1,$2); parsetreeroot=$$;}
;
create_stmt: CREATE PROCEDURE  NAME '(' para_list ')'
		{
			char *temp=mystrcat("create procedure ",$3);
			temp=mystrcat(temp,"(");
			temp=mystrcat(temp,$5);
			$$=mystrcat(temp,")(create)\n");
		}
;
/*
opt_if_not_exists:	      { $$ = 0; }
   | IF NOT EXISTS            { $$ = 1; }
   ;
*/
para_list: definition { $$=$1; }
|definition ',' para_list
		{	

			char *temp=mystrcat($1,",");
			$$=mystrcat(temp,$3);
		}
;
definition: USERVAR data_type
		{	

			char *temp=mystrcat($1," ");
			$$=mystrcat(temp,$2);

		}
;

data_type:
   DATE 					{$$="date"; }
   | TIME					{$$="time"; }
   | VARCHAR '(' INTNUM ')' 			{$$="varchar"; }
   | INT 					{$$="int"; }
   | DOUBLE 					{$$="double"; }
   ;

pro_block: BEGINT pro_parameters pro_body END
		{
			char *temp=mystrcat("begin\n",$2);
			temp=mystrcat(temp,"");
			temp=mystrcat(temp,$3);
			$$=mystrcat(temp,"end");
			//printf("pro_body %s\n",$3);
		}
;

pro_parameters: declare_list ';' { $$=mystrcat($1,";(declare)\n");}
|pro_parameters  declare_list ';'
		{
			char *temp=mystrcat($1,$2);
			$$=mystrcat(temp,";(declare)\n");
		}
|pro_parameters  set_list ';'
		{
	 		char *temp=mystrcat($1,$2);
			$$=mystrcat(temp,";(set)\n");
		}
;

declare_list:
|DECLARE definition
		{
			$$=mystrcat("declare ",$2);
		}
|declare_list ',' definition
		{
			char *temp=mystrcat($1,",");
			$$=mystrcat(temp,$3);
		}
;

set_list:
|SET assign_var
		{
			$$=mystrcat("set ",$2);
		}
| set_list ',' assign_var
		{
			char *temp=mystrcat($1,",");
			$$=mystrcat(temp,$3);
		}
;

assign_var : USERVAR COMPARISON expr
		{
			char *temp=mystrcat($1,"=");
			$$=mystrcat(temp,$3);
		}
;

expr: NAME         { $$=$1;}
   | STRING        { $$=$1;}
   | INTNUM        { $$=$1;}
   | APPROXNUM 	   { $$=$1;}
   | BOOL          { $$=$1;}
   ;

pro_body :  pro_stmt_list { $$=$1; }
;
pro_stmt_list: sql_stmt {$$=$1; }
|pro_stmt_list  sql_stmt
		{
			$$=mystrcat($1,$2);
		}
;
sql_stmt:
|SQL NAME ';' { $$=mystrcat($2,";(sql)\n");}
;
%%
/*
int main(int argc, char* argv[])
{
	yyparse();
}*/
int readInputForLexer( char *buffer, int *numBytesRead, int maxBytesToRead ) {
	int numBytesToRead = maxBytesToRead;
	int bytesRemaining = strlen(globalInputText)-globalReadOffset;
	int i;
	if ( numBytesToRead > bytesRemaining ) { numBytesToRead = bytesRemaining; }
	for ( i = 0; i < numBytesToRead; i++ ) {
		buffer[i] = globalInputText[globalReadOffset+i];
	}
	*numBytesRead = numBytesToRead;
	globalReadOffset += numBytesToRead;
	return 0;
}
void yyerror(const char *s, ...)
{
    fprintf(stderr, "error: %s\n", s);
}
void zzerror(const char *s, ...)
{
	extern int  yylineno;

	va_list ap;
	va_start(ap, s);

	fprintf(stderr, "%d: error: ", yylineno);
	vfprintf(stderr, s, ap);
	fprintf(stderr, "\n");
}

int yywrap(void)
{
    return 1;
}
char* getsql()
{
	return parsetreeroot;
}

这部分就是对上一个识别出来的词 进行顺序上的确定,构成一个完整的语法

这些需要在linux环境下进行调试

bison -d 文件名

flex 文件名

使用flex和bison实现的sql引擎解析

时间: 2024-10-29 19:07:39

使用flex和bison实现的sql引擎解析的相关文章

flex与bison

flex与bison 中文版 目录: 第一章:flex和bison简介 第二章:使用flex 第三章:使用bison 第四章:分析sql 第五章:flex规范参考 第六章:bison规范参考 第七章:二义性和冲突 第八章:错误报告和恢复 第九章:flex和bison进阶

在UNIX系统下联合编译flex 和bison 程序

flex 是一款词法解析开程序,而bison是一款语法解析开源程序.他们配合使用,就可以完成某些计算机脚本语言的语言的解析,如sql.这次我主要介绍flex 和bison在unix系统下的编译. 先看flex 代码: %{ #include "fb1-5.tab.h"//该文件由bison后面的bison生成.主要定义了token 的值.和yylval变量 %} %% "+" { return ADD; }//匹配上“+”,就返回token ADD,yylval 此

Kafka - SQL 引擎

Kafka - SQL 引擎分享 1.概述 大多数情况下,我们使用 Kafka 只是作为消息处理.在有些情况下,我们需要多次读取 Kafka 集群中的数据.当然,我们可以通过调用 Kafka 的 API 来完成,但是针对不同的业务需求,我们需要去编写不同的接口,在经过编译,打包,发布等一系列流程.最后才能看到我们预想的结果.那么,我们能不能有一种简便的方式去实现这一部分功能,通过编写 SQL 的方式,来可视化我们的结果.今天,笔者给大家分享一些心得,通过使用 SQL 的形式来完成这些需求. 2.

Sequoiadb该如何选择合适的SQL引擎

Sequoiadb作为一个文档型NoSQL数据既可以存储结构化数据也可以存储非结构化数据,对于非结构化数据只能使用原生的API进行查询,对结构化数据我们可以选择使用原生的API和开源SQL引擎,目前PostgresSQL,Hive,SparkSQL都可以作为Sequoiadb的SQL引擎,应用中该如何选择? 首先需要了解这些SQL引擎是怎么工作的,下图是Sequoiadb的接口图,所有的SQL查询都是通过SQL引擎把SQL解析成原生API的调用,PG依赖c++驱动,SparkSQL和HIVE依赖

6大主流开源SQL引擎总结,遥遥领先的是谁?

根据 O'Reilly 2016年数据科学薪资调查显示,SQL 是数据科学领域使用最广泛的语言.大部分项目都需要一些SQL 操作,甚至有一些只需要SQL.本文就带你来了解这些主流的开源SQL引擎!背景介绍 本文涵盖了6个开源领导者:Hive.Impala.Spark SQL.Drill.HAWQ 以及Presto,还加上Calcite.Kylin.Phoenix.Tajo 和Trafodion.以及2个商业化选择Oracle Big Data SQL 和IBM Big SQL,IBM 尚未将后者

windows下安装flex与bison

首先先下载felx/bison for windows flex:http://gnuwin32.sourceforge.net/packages/flex.htm bison:http://gnuwin32.sourceforge.net/packages/bison.htm 没有额外需要的话直接下载Binaries压缩包就行了. 注意:bison还需要以下工具支持,在bison下载页会有这些工具的下载链接. flex单独解压即可,bison则需要和将相关工具解压缩到同一目录下. flex的b

DRDS分布式SQL引擎—执行计划介绍

摘要: 本文着重介绍 DRDS 执行计划中各个操作符的含义,以便用户通过查询计划了解 SQL 执行流程,从而有针对性的调优 SQL. DRDS分布式SQL引擎 - 执行计划介绍 前言 数据库系统中,执行计划是对 SQL 如何执行的形式化表示,往往由若干关系操作符构成,用户可以通过对应的 EXPLAIN 命令查看,并通过执行计划大致了解 SQL 的执行过程和执行方式,如全表扫描还是索引扫描,归并连接还是哈希连接等.执行计划可以为用户进行 SQL 调优提供重要依据. DRDS 执行计划 与多数数据库

六大主流开源SQL引擎

本文涵盖了6个开源领导者:Hive.Impala.Spark SQL.Drill.HAWQ 以及Presto,还加上Calcite.Kylin.Phoenix.Tajo 和Trafodion.以及2个商业化选择Oracle Big Data SQL 和IBM Big SQL,IBM 尚未将后者更名为"Watson SQL". 背景介绍 使用SQL 引擎一词是有点随意的.例如Hive 不是一个引擎,它的框架使用MapReduce.TeZ 或者Spark 引擎去执行查询,而且它并不运行SQ

HBase场景 | 都是HBase上的SQL引擎,Kylin和Phoenix有什么不同?

大数据时代,数据的价值越来越被重视,企业从海量大数据中挖掘所需要的信息,用来驱动业务决策以获得更大的商业价值.与此同时,出现了越来越多的大数据技术帮助企业进行大数据分析,例如 Apache Hadoop,Hive,Spark,Presto,Drill,以及今天我们即将介绍的 Apache Kylin 和 Apache Phoenix 项目等,都是使用 SQL 语言就可以分析大数据,极大地降低了大数据的使用门槛.这些大数据技术提供 SQL 查询接口,不只是因为 SQL 学习成本低,同时也和 SQL