src/sql/dmlyacc.yxx

   1 %{
   2 #include <CSql.h>
   3 #include <stdlib.h>
   4 #include "Parser.h"
   5
   6 class Predicate;
   7
   8 ParsedData *parsedData;
   9 extern char yytext[];
  10 int yylex( void );
  11 void yyerror(const char* Msg);
  12 %}
  13
  14
  15 %union
  16 {
  17    char *stringval;
  18    void *predicate;
  19 }
  20
  21 %token <stringval> STRING FIELD NUMBER_STRING BINARY_STRING DOUBLE OPERATOR PARAMETER
  22 %token <stringval> SELECT FROM WHERE BETWEEN AND OR NOT
  23 %token <stringval> STAR
  24 %token <stringval> INSERT INTO VALUES
  25 %token <stringval> DELETE UPDATE SET NULL_VALUE
  26 %token <stringval> CREATE TABLE PRIMARY KEY DEFAULT INDEX ON HASH TREE UNIQUE DROP
  27 %token <stringval> INT_TYPE LONG_TYPE SHORT_TYPE DOUBLE_TYPE TIMESTAMP_TYPE DATE_TYPE CHAR_TYPE TIME_TYPE BIGINT_TYPE
  28 %token ';' ',' '(' ')'
  29 %type <stringval> ident field value not_opt
  30 %type <predicate> conditions condition
  31
  32 %%
  33 command:  select_statement { YYACCEPT; }
  34         | insert_statement { YYACCEPT; }
  35         | delete_statement { YYACCEPT; }
  36         | update_statement { YYACCEPT; }
  37         | ddl_statement { YYACCEPT; }
  38         ;
  39
  40 select_statement: SELECT field_list FROM ident where_clause_opt semicolon_opt
  41         {
  42             parsedData->setStmtType(SelectStatement);
  43             parsedData->setTableName($4);
  44             free($4);
  45         }
  46         ;
  47
  48 field_list: field_list field_list_L
  49         | field
  50         ;
  51 field_list_L: ',' field
  52         ;
  53
  54 insert_statement: INSERT INTO ident field_list_opt VALUES '(' value_list ')' semicolon_opt
  55         {
  56             parsedData->setStmtType(InsertStatement);
  57             parsedData->setTableName($3);
  58             free($3);
  59         }
  60         ;
  61
  62 field_list_opt:
  63         | '(' field_list ')'
  64         ;
  65
  66 value_list: value_list value_list_L
  67         | value
  68         {
  69             parsedData->insertValue((char*)$1);
  70             free($1);
  71         }
  72         ;
  73 value_list_L: ',' value
  74         {
  75             parsedData->insertValue((char*)$2);
  76             free($2);
  77         }
  78         ;
  79
  80 delete_statement: DELETE FROM ident where_clause_opt semicolon_opt
  81         {
  82             parsedData->setStmtType(DeleteStatement);
  83             parsedData->setTableName($3);
  84             free($3);
  85         }
  86         ;
  87
  88 update_statement: UPDATE ident SET assign_list where_clause_opt semicolon_opt
  89         {
  90             parsedData->setStmtType(UpdateStatement);
  91             parsedData->setTableName($2);
  92             free( $2 );
  93         }
  94         ;
  95
  96 semicolon_opt: ';'
  97         |
  98         ;
  99
 100 assign_list: assign_list assign_list_L
 101         | assign_stmt
 102         ;
 103
 104 assign_list_L: ',' assign_stmt
 105         ;
 106 assign_stmt: ident OPERATOR value
 107         {
 108             parsedData->insertUpdateValue( (char*) $1, (char*) $3);
 109             free( $1 ); free( $3 );
 110         }
 111         ;
 112
 113 where_clause_opt:  WHERE conditions
 114         |
 115         ;
 116
 117 conditions: conditions AND conditions
 118         {
 119             Predicate *pred;
 120             pred = parsedData->insertPredicate((Predicate*) $1, OpAnd, (Predicate*) $3);
 121             parsedData->setCondition((Predicate*)pred);
 122             $$= pred;
 123
 124         }
 125         | conditions OR conditions
 126         {
 127             Predicate *pred;
 128             pred = parsedData->insertPredicate((Predicate*) $1, OpOr, (Predicate*) $3);
 129             parsedData->setCondition((Predicate*)pred);
 130             $$= pred;
 131         }
 132         | NOT conditions
 133         {
 134             Predicate *pred;
 135             pred = parsedData->insertPredicate((Predicate*) $2, OpNot, NULL);
 136             parsedData->setCondition((Predicate*)pred);
 137             $$= pred;
 138         }
 139         | '(' conditions ')' { }
 140         | condition
 141         {
 142             parsedData->setCondition((Predicate*)$1);
 143             //((Predicate*)$1)->print();
 144             $$=$1;
 145         }
 146         ;
 147 condition: ident OPERATOR value
 148         {
 149             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
 150             Predicate *pred;
 151             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$3);
 152             pred = parsedData->insertPredicate((char*) $1, op, ptr);
 153             free( $1 ); free( $3 );
 154             $$=pred;
 155         }
 156         | ident OPERATOR ident
 157         {
 158             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
 159             Predicate *pred;
 160             pred = parsedData->insertPredicate((char*) $1, op, (char*) $3);
 161             free( $1 ); free( $3 );
 162             $$=pred;
 163         }
 164
 165         | ident not_opt BETWEEN value AND value
 166         {
 167             void **ptr1 = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$4);
 168             void **ptr2 = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$6);
 169             Predicate *pred1, *pred2, *pred3, *finalPred;
 170             pred1 = parsedData->insertPredicate((char*) $1, OpGreaterThanEquals, ptr1);
 171             pred2 = parsedData->insertPredicate((char*) $1, OpLessThanEquals, ptr2);
 172             finalPred = parsedData->insertPredicate(pred1, OpAnd, pred2);
 173             if( $2 == (char*) 1 )
 174                 finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);
 175             free( $1 );  free( $4 );  free( $6 );
 176             $$= finalPred;
 177         }
 178         ;
 179 not_opt: NOT
 180         { $$=(char*) 1;
 181         }
 182         |
 183         { $$=(char*) 0; }
 184         ;
 185 field:   ident
 186         {
 187             parsedData->insertField((char*)$1);
 188             free( $1 );
 189         }
 190         | STAR
 191         {
 192             parsedData->insertField((char*)$1);
 193             free( $1 );
 194         }
 195         ;
 196 ident:    FIELD { $$ = $1; }
 197         ;
 198 value:    STRING { $$ = $1; }
 199         | NUMBER_STRING { $$ = $1; }
 200         | BINARY_STRING { $$ = $1; }
 201         | DOUBLE { $$ = $1; }
 202         | PARAMETER { $$ = $1; }
 203         | NULL_VALUE { $$ = (char*) 0; }
 204         ;
 205
 206 ddl_statement: CREATE TABLE ident '(' create_defn_list ')' semicolon_opt
 207         {
 208             parsedData->setStmtType(CreateTableStatement);
 209             parsedData->setTableName($3);
 210             free($3);
 211         }
 212         | CREATE INDEX ident ON ident '(' field_list ')' opt_constr_type opt_ind_type  semicolon_opt
 213         {
 214             parsedData->setStmtType(CreateIndexStatement);
 215             parsedData->setIndexName($3);
 216             parsedData->setTableName($5);
 217             free($3);
 218             free($5);
 219         }
 220         | DROP TABLE ident
 221         {
 222             parsedData->setStmtType(DropTableStatement);
 223             parsedData->setTableName($3);
 224             free($3);
 225         }
 226         | DROP INDEX ident
 227         {
 228             parsedData->setStmtType(DropIndexStatement);
 229             parsedData->setIndexName($3);
 230             free($3);
 231         }
 232         ;
 233 opt_ind_type:
 234         | HASH  opt_constr_type
 235         {
 236             parsedData->setIndexType(hashIndex);
 237         }
 238         | TREE  opt_constr_type
 239         {
 240             parsedData->setIndexType(treeIndex);
 241         }
 242         |
 243         {
 244             parsedData->setIndexType(hashIndex);
 245         }
 246         ;
 247 opt_constr_type:
 248         | UNIQUE
 249         {
 250             parsedData->setUnique(true);
 251         }
 252         | PRIMARY
 253         {
 254             parsedData->setUnique(true);
 255             parsedData->setPrimary(true);
 256         }
 257         |
 258         {
 259             parsedData->setUnique(false);
 260             parsedData->setPrimary(false);
 261         }
 262         ;
 263 create_defn_list: create_defn_list create_defn_list_L
 264         | create_defn
 265         ;
 266
 267 create_defn_list_L: ',' create_defn
 268         ;
 269
 270 create_defn: field_defn
 271         {
 272             parsedData->insertFldDef();
 273         }
 274         | constraint_defn
 275         ;
 276
 277 field_defn: field_name field_type size_opt null_expr_opt default_expr_opt
 278         ;
 279
 280 field_name: ident
 281         {
 282             parsedData->setFldName($1);
 283             free($1);
 284         }
 285 size_opt:
 286         | '(' NUMBER_STRING ')'
 287         {
 288             parsedData->setFldLength(atoi($2));
 289             free($2);
 290         }
 291         ;
 292
 293 default_expr_opt:
 294         | DEFAULT value
 295         ;
 296
 297 null_expr_opt:
 298         | NOT NULL_VALUE
 299         {
 300             parsedData->setFldNotNull(true);
 301         }
 302         ;
 303 constraint_defn: primary_key_constraint
 304         ;
 305
 306 primary_key_constraint: PRIMARY KEY '(' field_list ')'
 307         ;
 308
 309 field_type: INT_TYPE
 310         {
 311             parsedData->setFldType(typeInt);
 312         }
 313         | LONG_TYPE
 314         {
 315             parsedData->setFldType(typeLong);
 316         }
 317         | SHORT_TYPE
 318         {
 319             parsedData->setFldType(typeShort);
 320         }
 321         | BIGINT_TYPE
 322         {
 323             parsedData->setFldType(typeLongLong);
 324         }
 325         | FLOAT_TYPE
 326         {
 327             parsedData->setFldType(typeFloat);
 328         }
 329         | DOUBLE_TYPE
 330         {
 331             parsedData->setFldType(typeDouble);
 332         }
 333         ;
 334         | DATE_TYPE
 335         {
 336             parsedData->setFldType(typeDate);
 337         }
 338         ;
 339         | TIME_TYPE
 340         {
 341             parsedData->setFldType(typeTime);
 342         }
 343         ;
 344         | TIMESTAMP_TYPE
 345         {
 346             parsedData->setFldType(typeTimeStamp);
 347         }
 348         ;
 349         | CHAR_TYPE
 350         {
 351             parsedData->setFldType(typeString);
 352         }
 353         ;
 354 %%
 355
 356 extern int lexEof;
 357 void yyerror(const char* Msg) {
 358     if( lexEof == 0 )
 359         fprintf(stderr, "[Parser: %s] %s\n", Msg, yytext);
 360
 361     return;
 362 }