dsl.y

一个SQL解析器

/*
Distributed Database Facilitator Parcer
Version 1.0
By Leroy G. Cain
1985 Columbia Union College
*/
%union
{
        int     stype;
        char    *nsbuf;
}
%token ADD
%token ALL
%token ALLOWED
%token AFTER
%token ALTER
%token AND
%token ANY
%token AS
%token ASC
%token AT
%token AUDIT
%token BEFORE
%token BBEGIN
%token BETWEEN
%token BY
%token CHECK
%token CLOSE
%token COMMENT
%token COMMIT
%token COMPOSITE
%token CONSTRAINT
%token CREATE
%token DATABASE
%token DEFAULT
%token DELETE
%token DESC
%token DISTINCT
%token DIVIDEBY
%token DOMAIN
%token DROP
%token DUMP
%token END
%token ELSE
%token EXISTS
%token FOR
%token FOREIGN
%token FRAGMENT
%token FROM
%token GRANT
%token GROUP
%token HAVING
%token IDENTIFIES
%token IF
%token IN
%token INDEX
%token INFO
%token INSERT
%token INTO
%token INTERSECT
%token IS
%token LIKE
%token LOCK
%token MINUS
%token MODE
%token MODIFY
%token NOT
%token NULLN
%token NULLS
%token OF
%token ON
%token OPEN 
%token OPTION 
%token OR
%token ORDER 
%token OUTER 
%token PRIMARY 
%token PROGRAM 
%token RANGE
%token REPAIR
%token RESTORE
%token REVOKE 
%token ROLLBACK 
%token ROLLFORWARD 
%token SELECT
%token SET
%token SHOW
%token SNAPSHOT
%token START
%token STORE
%token SYNC
%token SYNONYM
%token TABLE
%token THEN
%token TO
%token TYPE
%token VALUES
%token VIEW
%token UNION
%token UNIQUE
%token UPDATE
%token WHERE
%token WORK
%token WITH
/*
*/
%token ALLFIELDS
%token <nsbuf> IDENTIFIER
%token INTEGER
%token ILLEGAL
%token REAL 
%token STRING
%token PARM 
%left ';'
%left WHERE
%left OR
%left AND
%left ','
%right ASSIGN
%right TCOL
%left '?'
%left E_OR
%left E_AND
%left '|'
%left '^'
%left '&'
%left NLT NGT LT GT EQ GE LE NE
%left RIGHTSHIFT LEFTSHIFT
%left '+' '-'
%left '*' '/' '%' PWR
%right UMINUS  '~' PNOT
%left PORDER
%left '`'
%left '.'


%{
static long     flag;
static short    sqy_flag;

static char     path_name[1024];
static char     scratch[1024];

#include "gtok.h"
#define BEXPR { sqy_flag = 0; }
%}
%%
dsl:
          statement ';' 
          {puttok(T_ROOT);puttok(0);puttok(0);puttok(T_ENDCOMMAND);}
        | STORE PROGRAM prog_name '(' parm_list ')'stats ';' END STORE ';'
        ;

stats:
        statement
        | stats ';' statement
        ;

        /*
trigger_list:
        trigger
        | trigger_list ',' trigger
        |error
        | trigger_list error trigger
        | trigger_list ',' error 
        ;
        */
statement:
          { puttok(0300);} alter        
        | { puttok(0301);} audit
        | { puttok(0302);} begin
        | { puttok(0303);} check
        | { puttok(0304);} close
        | { puttok(0305);} comment
        | { puttok(0306);} commit
        | { puttok(0307);} create
        | { puttok(0310);} delete
        | { puttok(0311);} drop
        | { puttok(0312);} dump
        | { puttok(0313);} grant
        | { puttok(0314);} info
        | { puttok(0315);} insert
        | { puttok(0316);} lock
        | { puttok(0317);} open
        | { puttok(0320);} rollback
        | { puttok(0321);} rollforward
        | { puttok(0322);} repair
        | { puttok(0323);} restore
        | { puttok(0324);} revoke
        | { puttok(0325);} select
        | { puttok(0326);} set
        | { puttok(0327);} start
        | { puttok(0330);} sync
        | { puttok(0331);} update
        ;

start:
          prog_name '(' expr_list ')'
          /*
        | START INTEGER '(' parm_list ')'
          */
        ;

parm_list:
          parm
        | parm ',' parm_list
        ;

parm:
          parm_name
        | parm_name EQ expr %prec ASSIGN
        ;

/*
Data Manipulation
*/

delete:
          DELETE FROM rec_alias where_clause /* Set where flag */
        ;

insert:
            INSERT INTO rec_alias '(' field_list ')' icond
          | INSERT INTO rec_alias icond
          ;

update:
          UPDATE rec_alias set_show where_clause /* Set where flag */
        ;

rec_alias:
          path
        | path alias
        ;

icond:  
          FROM filename
        | select_statement
        | VALUES '(' const_list ')'
        ;

set_show:
          SHOW setelements
        | SET setelements
        ;

setelements:
          setelement
        | setelements ',' setelement
        ;

setelement: 
          field EQ expr %prec ASSIGN
        | field EQ select_statement %prec ASSIGN
        | '[' field_list ']' EQ '[' expr_list ']' %prec ASSIGN
        | '[' field_list ']' EQ select_statement %prec ASSIGN
        ;

/*
Query Langauge
*/

select:
        select_expr order_clause into_clause
        ;

select_expr:
          select_statement
        | select_expr UNION any select_statement 
        | select_expr MINUS select_statement 
        | select_expr DIVIDEBY select_statement 
        | select_expr INTERSECT select_statement 
        | '(' select_expr ')'
        ;

order_clause:
        | ORDER BY norder_list
        ;

into_clause:
        | INTO filename
        ;

select_statement:
        { puttok(T_TLEND); }
          select_clause
                FROM from_item_list
                select_options
        { puttok(T_QLEND); }
        ;

order_list:
          path orderdir %prec PORDER
        | order_list ',' path orderdir
        ;

norder_list:
/*
          INTEGER orderdir %prec PORDER
*/
          expr orderdir %prec PORDER
/*
        | path orderdir %prec PORDER
*/
        | norder_list ',' norder_list
        ;

select_clause:
          SELECT unique sellist
        | SELECT unique '*'
        ;

from_item_list:
          from_item
        | from_item_list ',' from_item_list
        ;

from_item:
          rec_alias
        | OUTER rec_alias
        | OUTER '(' from_item_list ')'
        ;

select_options:
        | WHERE predicate /* Set where flag */
        | WHERE predicate group_clause
        | group_clause
        ;

group_clause:
          GROUP BY path_list
        | GROUP BY path_list HAVING predicate /* Set having flag */
        ;

unique:
        | ALL
        | DISTINCT
        | UNIQUE
        ;

sellist:
          selelement {puttok(T_RESDOM);}
        | sellist ',' selelement {puttok(T_RESDOM);}
        ;

selelement:
          record ALLFIELDS
        | expr
        | expr STRING
        ;

predicate:
          condition
        | condition AND predicate 
        | condition OR predicate 
        | NOT predicate %prec PNOT
        | '(' predicate ')'
        | IF predicate THEN predicate else_pred
        ;

else_pred:
        |ELSE predicate
        ;

condition:
           expr
        |  expr not IN in_sel_expr /* singler flag */
        | '[' path_list ']'  not IN in_sel_expr
        |  expr IS not NULLN
        |  expr IS not DEFAULT
        |  expr not BETWEEN expr AND expr
        |  expr not LIKE const  /* Like flag */
        | EXISTS '(' select_statement ')'
        ;

not:
        |NOT
        ;

any:
        |ALL
        |ANY
        ;

in_sel_expr:
          '(' select_statement ')' 
        | const_recs
        ;

cond_sel_expr:
          expr
        | '(' select_statement ')' 
	  {if (sqy_flag) yyerror ("Illegal subquery"); else sqy_flag = 1;}
        ;

const_recs:
          '(' const_list ')'
        | '[' const_rec_list ']'
        ;

const_rec_list:
          '(' const_list ')'
        | const_rec_list ',' '(' const_list ')'
        ;

path_list:
          path
        | path_list ',' path
        ;

field_list:
          field
        | field_list ',' field
        ;
/*
path is a field or record path.
node.database.record  -- for records
node.database.record.field  -- for fields
*/
path:
        path_e_list {puttok(T_VAR);putvar(path_name);*path_name='\0';}
        | path_e_list '[' element_name ']'
        ;

path_e_list:
        path_element
        | path_element  {strcat(path_name,".");} '.' path_e_list
        ;

element_name:/* element_name flag */
         norder_list
        ;

orderdir: 
        | DESC
        | ASC
        ;

const_list:
          const
        | const_list ',' const
        ;

expr:
          expr '`' s_control    /* Semantic control */
        | '-' expr %prec UMINUS {puttok(T_NEG);}/* negate */
        | expr '+' expr {puttok(T_ADD);}/* add */
        | expr '-' expr {puttok(T_SUB);}/* subtract */
        | expr '*' expr {puttok(T_MUL);}/* multiply */
        | expr '/' expr {puttok(T_DIV);}/* divide */
        | expr '%' expr {puttok(T_MOD);}/* modulus */
        | expr PWR expr {puttok(T_ADD);}/* power */
        | expr '?' else_part
        | '~' expr      /* ones compliment */
        | expr RIGHTSHIFT expr /* bit shift right */
        | expr LEFTSHIFT expr /* bit shift left */
        | expr '^' expr /* exclusive or */
        | expr '|' expr /* or */
        | expr '&' expr /* and */
        | expr E_OR expr        /* or */
        | expr E_AND expr       /* and */
        | expr NLT cond_sel_expr {puttok(T_NLT);}
        | expr NGT cond_sel_expr {puttok(T_NGT);}
        | expr LT any cond_sel_expr {puttok(T_LT);}
        | expr GT any cond_sel_expr {puttok(T_GT);}
        | expr EQ any cond_sel_expr {puttok(T_EQ);}
        | expr GE cond_sel_expr {puttok(T_GE);}
        | expr LE cond_sel_expr {puttok(T_LE);}
        | expr NE any cond_sel_expr {puttok(T_NE);}
        | '(' expr ')'  /* parenthesis */
        | const
        | path
        | function
        ;

else_part:
        expr ':' expr %prec TCOL
        ;

const:
          INTEGER {puttok(T_INT4); putint(yytext);}
        | REAL {puttok(T_FLT8); putreal(yytext);}
        | STRING {puttok(T_CHAR); putstr(yytext);}