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 IN 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         | ident not_opt IN '(' value_list ')'
 179         {
 180             ListIterator valIter = parsedData->getFieldValueList().getIterator();
 181             FieldValue *value1, *value2;
 182             Predicate *pred1, *pred2, *finalPred;
 183             void **ptr1, **ptr2;
 184             if (valIter.hasElement()) {
 185                value1 = (FieldValue*) valIter.nextElement();
 186                ptr1 = parsedData->insertCondValueAndGetPtr((char*)$1, value1->parsedString);
 187                pred1 = parsedData->insertPredicate((char*) $1, OpEquals, ptr1);
 188                finalPred=pred1;
 189             }
 190             while (valIter.hasElement()) {
 191                value2 = (FieldValue*) valIter.nextElement();
 192                ptr2 = parsedData->insertCondValueAndGetPtr((char*)$1, value2->parsedString);
 193                pred2 = parsedData->insertPredicate((char*) $1, OpEquals, ptr2);
 194                finalPred = parsedData->insertPredicate(pred1, OpOr, pred2);
 195                pred1= finalPred;
 196             }
 197             if( $2 == (char*)1)
 198                 finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);
 199
 200             free( $1 );
 201             $$= finalPred;
 202         }
 203         ;
 204 not_opt: NOT
 205         { $$=(char*) 1;
 206         }
 207         |
 208         { $$=(char*) 0; }
 209         ;
 210 field:   ident
 211         {
 212             parsedData->insertField((char*)$1);
 213             free( $1 );
 214         }
 215         | STAR
 216         {
 217             parsedData->insertField((char*)$1);
 218             free( $1 );
 219         }
 220         ;
 221 ident:    FIELD { $$ = $1; }
 222         ;
 223 value:    STRING { $$ = $1; }
 224         | NUMBER_STRING { $$ = $1; }
 225         | BINARY_STRING { $$ = $1; }
 226         | DOUBLE { $$ = $1; }
 227         | PARAMETER { $$ = $1; }
 228         | NULL_VALUE { $$ = (char*) 0; }
 229         ;
 230
 231 ddl_statement: CREATE TABLE ident '(' create_defn_list ')' semicolon_opt
 232         {
 233             parsedData->setStmtType(CreateTableStatement);
 234             parsedData->setTableName($3);
 235             free($3);
 236         }
 237         | CREATE INDEX ident ON ident '(' field_list ')' opt_constr_type opt_ind_type  semicolon_opt
 238         {
 239             parsedData->setStmtType(CreateIndexStatement);
 240             parsedData->setIndexName($3);
 241             parsedData->setTableName($5);
 242             free($3);
 243             free($5);
 244         }
 245         | DROP TABLE ident
 246         {
 247             parsedData->setStmtType(DropTableStatement);
 248             parsedData->setTableName($3);
 249             free($3);
 250         }
 251         | DROP INDEX ident
 252         {
 253             parsedData->setStmtType(DropIndexStatement);
 254             parsedData->setIndexName($3);
 255             free($3);
 256         }
 257         ;
 258 opt_ind_type:
 259         | HASH  opt_constr_type
 260         {
 261             parsedData->setIndexType(hashIndex);
 262         }
 263         | TREE  opt_constr_type
 264         {
 265             parsedData->setIndexType(treeIndex);
 266         }
 267         |
 268         {
 269             parsedData->setIndexType(hashIndex);
 270         }
 271         ;
 272 opt_constr_type:
 273         | UNIQUE
 274         {
 275             parsedData->setUnique(true);
 276         }
 277         | PRIMARY
 278         {
 279             parsedData->setUnique(true);
 280             parsedData->setPrimary(true);
 281         }
 282         |
 283         {
 284             parsedData->setUnique(false);
 285             parsedData->setPrimary(false);
 286         }
 287         ;
 288 create_defn_list: create_defn_list create_defn_list_L
 289         | create_defn
 290         ;
 291
 292 create_defn_list_L: ',' create_defn
 293         ;
 294
 295 create_defn: field_defn
 296         {
 297             parsedData->insertFldDef();
 298         }
 299         | constraint_defn
 300         ;
 301
 302 field_defn: field_name field_type size_opt null_expr_opt default_expr_opt
 303         ;
 304
 305 field_name: ident
 306         {
 307             parsedData->setFldName($1);
 308             free($1);
 309         }
 310 size_opt:
 311         | '(' NUMBER_STRING ')'
 312         {
 313             parsedData->setFldLength(atoi($2)+1);
 314             free($2);
 315         }
 316         ;
 317
 318 default_expr_opt:
 319         | DEFAULT value
 320         {
 321             parsedData->setDefaultValue($2);
 322             free($2);
 323         }
 324         ;
 325
 326 null_expr_opt:
 327         | NOT NULL_VALUE
 328         {
 329             parsedData->setFldNotNull(true);
 330         }
 331         ;
 332 constraint_defn: primary_key_constraint
 333         ;
 334
 335 primary_key_constraint: PRIMARY KEY '(' field_list ')'
 336         {
 337             parsedData->setPrimary(true);
 338         }
 339         ;
 340
 341 field_type: INT_TYPE
 342         {
 343             parsedData->setFldType(typeInt);
 344         }
 345         | LONG_TYPE
 346         {
 347             parsedData->setFldType(typeLong);
 348         }
 349         | SHORT_TYPE
 350         {
 351             parsedData->setFldType(typeShort);
 352         }
 353         | BIGINT_TYPE
 354         {
 355             parsedData->setFldType(typeLongLong);
 356         }
 357         | FLOAT_TYPE
 358         {
 359             parsedData->setFldType(typeFloat);
 360         }
 361         | DOUBLE_TYPE
 362         {
 363             parsedData->setFldType(typeDouble);
 364         }
 365         ;
 366         | DATE_TYPE
 367         {
 368             parsedData->setFldType(typeDate);
 369         }
 370         ;
 371         | TIME_TYPE
 372         {
 373             parsedData->setFldType(typeTime);
 374         }
 375         ;
 376         | TIMESTAMP_TYPE
 377         {
 378             parsedData->setFldType(typeTimeStamp);
 379         }
 380         ;
 381         | CHAR_TYPE
 382         {
 383             parsedData->setFldType(typeString);
 384             parsedData->setFldLength(2);
 385         }
 386         ;
 387 %%
 388
 389 extern int lexEof;
 390 void yyerror(const char* Msg) {
 391     if( lexEof == 0 )
 392         fprintf(stderr, "[Parser: %s] %s\n", Msg, yytext);
 393
 394     return;
 395 }