fix for trie index
[csql.git] / src / sql / dmlyacc.yxx
blob0143a8dd5078a023d0fe486008700e11bccbb1b2
1 %{
2 #include <CSql.h>
3 #include <stdlib.h>
4 #include "Parser.h"
6 class Predicate;
7 ParsedData *parsedData;
8 extern char yytext[];
9 int yylex( void );
10 void yyerror(const char* Msg);
14 %union
16    char *stringval;
17    void *predicate;
18    void *Expression;
19    void *FunctionType;
22 %left OR 
23 %left AND
24 %left '+' '-'
25 %left '*' '/' '%'
26 %nonassoc UMINUS
27 %token <stringval> STRING FIELD NUMBER_STRING BINARY_STRING DOUBLE OPERATOR PARAMETER ALLTABLE DESCRIBE PRIMARYINFO AUTO_INCREMENT GETCATALOGS GETDATATYPES GETTABLETYPES IMPORTEDKEY EXPORTEDKEY
28 %token <stringval> SELECT FROM WHERE BETWEEN IN AND OR NOT AS LIMIT OFFSET INNER OUTER CROSS JOIN LEFT IS
29 %token <stringval> INSERT INTO VALUES EXPLAIN PLAN
30 %token <stringval> DELETE UPDATE SET NULL_VALUE
31 %token <stringval> CREATE TABLE PRIMARY KEY DEFAULT INDEX ON HASH TREE TRIE UNIQUE DROP SIZE FOREIGN REFERENCES COMPACT TRUNCATE 
32 %token <stringval> CACHE CONDITION FIELDLIST PK DIRECT DSN UNCACHE NOSCHEMA
33 %token <stringval> INT_TYPE LONG_TYPE SHORT_TYPE DOUBLE_TYPE TIMESTAMP_TYPE DATE_TYPE CHAR_TYPE TIME_TYPE BIGINT_TYPE FLOAT_TYPE TINYINT_TYPE BINARY_TYPE VARCHAR_TYPE
34 %token <stringval> DATE_DIFF DATE_ADD DATE_SUB HOUR MINUTE SECOND YEAR MONTH DAY INTERVAL TIME_DIFF TIME_ADD TIME_SUB TIMESTAMP_DIFF TIMESTAMP_ADD TIMESTAMP_SUB EXTRACT NOW
35 %token <stringval> USER PASSWORD ALTER FLUSH ADD COLUMN MODIFY RENAME TO
36 %token <stringval> MIN MAX AVG SUM COUNT GROUP BY HAVING ORDER ASC DESC DISTINCT
37 %token ';' ',' '(' ')'
38 %type <stringval> ident field value not_opt doub_value num_value 
39 /*%type <stringval> foreign_key_constraint foreign_key_create foreign_key_constraint_L*/
40 %type <predicate> conditions condition hconditions hcondition 
41 %type <Expression> stmt_exp atom function_opt
42 %type <FunctionType> date_opt time_opt datetime_opt
44 command:  select_statement { YYACCEPT; }
45         | insert_statement { YYACCEPT; }
46         | delete_statement { YYACCEPT; }
47         | update_statement { YYACCEPT; }
48         | ddl_statement { YYACCEPT; }
49         | internal_statement { YYACCEPT; }
50         | cache_statement { YYACCEPT; }
51         | copy_table_statement { YYACCEPT; }
52         | user_manager_statement { YYACCEPT; }
53         | management_statement { YYACCEPT; }
54         | alter_statement { YYACCEPT; }
55         | other {YYACCEPT;}
56         ;
57 alter_statement: ALTER TABLE ident ADD '(' create_defn_list_con ')' semicolon_opt
58         {
59             parsedData->setStmtType(AlterStatement);
60             parsedData->setAlterType(ALTERADD);
61             parsedData->setTableName($3);
62             free($3); 
63         }
64         | ALTER TABLE ident DROP COLUMN ident semicolon_opt
65         {
66             parsedData->setStmtType(AlterStatement);
67             parsedData->setAlterType(ALTERDROP);
68             parsedData->setTableName($3);
69             parsedData->setIndexName($6); 
70             free($3);
71         }
72         | ALTER TABLE ident MODIFY '(' create_defn ')' semicolon_opt
73         {
74             printf(" Not Implemented\n");
75             free($3);
76             YYABORT;
77         }
78         | RENAME TABLE ident TO ident semicolon_opt
79         {
80             parsedData->setStmtType(AlterStatement);
81             parsedData->setAlterType(ALTERTABLERENAME);
82             parsedData->setTableName($3);
83             parsedData->setIndexName($5); 
84             free($3); free($5);
86         }
87         | ALTER TABLE ident RENAME COLUMN ident TO ident semicolon_opt
88         {
89             parsedData->setStmtType(AlterStatement);
90             parsedData->setAlterType(ALTERFIELDRENAME);
91             parsedData->setTableName($3);
92             parsedData->setIndexName($6);
93             parsedData->setPKTableName($8);
94             free($3); free($5); free($8);
95         }
96         | ALTER INDEX ident RENAME TO ident semicolon_opt
97         {
98             parsedData->setStmtType(AlterStatement);
99             parsedData->setAlterType(ALTERINDEXRENAME);
100             parsedData->setTableName($3);
101             parsedData->setIndexName($6); 
102             free($3); free($5);
103         }
104         ;
105 management_statement: FLUSH CACHE semicolon_opt
106         {
107            parsedData->setStmtType(MgmtStatement);
108         }
109         ;
110 user_manager_statement: CREATE USER ident PASSWORD STRING semicolon_opt
111         {
112             parsedData->setStmtType(UserStatement);
113             parsedData->createUserNode((char*)$3,(char*)$5);
114             free($3);
115             free($5);
116         }
117         |DROP USER ident semicolon_opt
118         {
119             parsedData->setStmtType(UserStatement);
120             parsedData->dropUserNode((char*)$3);
121             free($3);
122         }
123         | ALTER USER ident SET PASSWORD STRING semicolon_opt
124         {
125             parsedData->setStmtType(UserStatement);
126             parsedData->alterUserNode((char*)$3,(char*)$6);
127             free($3);
128             free($6);
129         }
130         ;
131 copy_table_statement: CREATE TABLE ident AS SELECT opt_distinct field_list FROM table_list where_clause_opt group_by_opt having_opt order_by_opt limit_opt semicolon_opt
132         {
133             parsedData->setStmtType(CopyTableStatement);
134             parsedData->setPKTableName($3);
135             parsedData->setCreateTbl();
136             free($3);
137         }
138         | INSERT  INTO ident AS SELECT opt_distinct field_list FROM table_list where_clause_opt group_by_opt having_opt order_by_opt limit_opt semicolon_opt
139         {
140             parsedData->setStmtType(CopyTableStatement);
141             parsedData->setPKTableName($3);
142             free($3);
143         }
144         ;
145 internal_statement: COMPACT TABLE ident
146         {
147             parsedData->setStmtType(CompactTableStatement);
148             parsedData->setTableName($3);
149             free($3);
150         }
151         ;
152 other: ALLTABLE
153         {
154             parsedData->setStmtType(MetaStatement);
155             parsedData->setResultSetPlan(GetTables);
156         }
157         | DESCRIBE table 
158         {
159             parsedData->setStmtType(MetaStatement);
160             parsedData->setResultSetPlan(GetColumns);
161         }
162         | DESCRIBE INDEX table
163         {
164             parsedData->setStmtType(MetaStatement);
165             parsedData->setResultSetPlan(GetIndexes);
166                    
167         }
168         | PRIMARYINFO table
169         {
170             parsedData->setStmtType(MetaStatement);
171             parsedData->setResultSetPlan(GetPriIndex);
172         }
173         | GETCATALOGS
174         {
175             parsedData->setStmtType(MetaStatement);
176             parsedData->setResultSetPlan(GetCatalogs);
177         }
178         | GETTABLETYPES
179         {
180             parsedData->setStmtType(MetaStatement);
181             parsedData->setResultSetPlan(GetTableType);
182         }
183         | GETDATATYPES 
184         {
185             parsedData->setStmtType(MetaStatement);
186             parsedData->setResultSetPlan(GetDataType);
187         }
188         | IMPORTEDKEY table
189         {
190             parsedData->setStmtType(MetaStatement);
191             parsedData->setResultSetPlan(GetImportKey);
192         }
193         | EXPORTEDKEY table
194         {
195             parsedData->setStmtType(MetaStatement);
196             parsedData->setResultSetPlan(GetExportKey);
197         }
198         ;
199 select_statement: opt_explain SELECT opt_distinct field_list FROM table_list where_clause_opt group_by_opt having_opt order_by_opt limit_opt semicolon_opt
200         {
201             parsedData->setStmtType(SelectStatement);
202             parsedData->setCacheWorthy(true);
203         }
204         ;
205 opt_explain: EXPLAIN PLAN
206         {
207            parsedData->setExplain();
208         }
209         |
210         ;
211 opt_distinct: DISTINCT 
212         { 
213             parsedData->setDistinct();
214         }
215         |
216         ;
217 field_list: field_list field_list_L
218         | field_with_as
219         ;
220 field_list_L: ',' field_with_as 
221         ;
222 field_with_as: field
223         | field AS ident
224         {
225             parsedData->insertFieldAlias((char*)$3);
226             free((char*)$3);
227         }
228         ;
229 table_list: table_list table_list_L
230         | table 
231         | table join_exp
232         ;
233 join_exp: INNER opt_join table ON conditions join_exp
234         {
235            parsedData->insertJoinType(INNER_JOIN);
236            Condition *cond = parsedData->getCondition();
237            Predicate *pred = cond->getPredicate();
238            if (pred == NULL) {
239                parsedData->setCondition((Predicate*)$5);
240            } else {
241                Predicate *newPred;
242                newPred = parsedData->insertPredicate(pred, OpAnd, (Predicate*)$5);
243                parsedData->setCondition(newPred);
244            }
246         }
247         | LEFT opt_outer opt_join table ON conditions join_exp
248         {
249            parsedData->insertJoinType(LEFT_JOIN);
250            Condition *cond = parsedData->getCondition();
251            Predicate *pred = cond->getPredicate();
252            if (pred == NULL) {
253                parsedData->setCondition((Predicate*)$6);
254            } else {
255                Predicate *newPred;
256                newPred = parsedData->insertPredicate(pred, OpAnd, (Predicate*)$6);
257                parsedData->setCondition(newPred);
258            }
259         }
260         | CROSS opt_join table join_exp
261         {
262             parsedData->insertJoinType(INNER_JOIN);
263         }
264         |
265         ;
266 opt_outer: 
267        |OUTER
268        ;
269 opt_join: 
270        |JOIN
271        ;
272 table_list_L: ',' table
273         {
274             parsedData->insertJoinType(INNER_JOIN);
275         }
276         ;
277         
278 insert_statement: INSERT INTO ident field_list_opt VALUES '(' value_list ')' semicolon_opt
279         {
280             parsedData->setStmtType(InsertStatement);
281             parsedData->setTableName($3); 
282             free($3);
283         }
284         ;
286 field_list_opt:
287         | '(' field_list ')'
288         ;
290 value_list: value_list value_list_L
291         | value
292         {
293             parsedData->insertValue((char*)$1);
294             free($1);
295         }
296         ;
297 value_list_L: ',' value 
298         {
299             parsedData->insertValue((char*)$2);
300             free($2);
301         }
302         ;
303         
304 invalue_list: invalue_list invalue_list_L
305         | value
306         {
307             parsedData->insertInValue((char*)$1);
308             free($1);
309         }
310         ;
311 invalue_list_L: ',' value 
312         {
313             parsedData->insertInValue((char*)$2);
314             free($2);
315         }
316         ;
317         
318 delete_statement: DELETE FROM ident where_clause_opt semicolon_opt
319         {
320             parsedData->setStmtType(DeleteStatement);
321             parsedData->setTableName($3); 
322             free($3);
323         }
324         ;
325         
326 update_statement: UPDATE ident SET assign_list where_clause_opt semicolon_opt
327         {
328             parsedData->setStmtType(UpdateStatement);
329             parsedData->setTableName($2); 
330             free( $2 );
331         }
332         ;
334 semicolon_opt: ';'
335         |
336         ;
338 assign_list: assign_list assign_list_L
339         | assign_stmt
340         ;
342 assign_list_L: ',' assign_stmt
343         ;
344 assign_stmt: ident  OPERATOR stmt_exp
345         {
346            parsedData->insertUpdateExpression( (char*) $1, (Expression* ) $3);
347            free( $1 ); free($2);
348         }
349         | ident OPERATOR value 
350         { 
351             parsedData->insertUpdateValue( (char*) $1, (char*) $3);
352             free( $1 ); free($2);free( $3 ); 
353         }
354         | ident OPERATOR NULL_VALUE 
355         {
356             parsedData->insertUpdateValue( (char*) $1, (char*) $3);
357             free( $1 ); free($2);free( $3 );
358         }
359         ; 
360 stmt_exp: stmt_exp '/' stmt_exp
361         {
362             Expression* exp;
363             exp=parsedData->insertExpression((Expression *)$1, division, (Expression *)$3);
364             $$=exp;
365         } 
366         | stmt_exp '%' stmt_exp
367         {
368             Expression* exp;
369             exp=parsedData->insertExpression((Expression *)$1, modulus, (Expression *)$3);
370             $$=exp;
371         }
372         | stmt_exp '*' stmt_exp
373         {
374             Expression* exp;
375             exp=parsedData->insertExpression((Expression *)$1, multiplication, (Expression *)$3);
376             $$=exp;
377         }
378         | stmt_exp '+' stmt_exp
379         {
380             Expression* exp;
381             exp=parsedData->insertExpression((Expression *)$1, addition, (Expression *)$3);
382             $$=exp;
383         }
384         | stmt_exp '-' stmt_exp
385         {
386             Expression* exp;
387             exp=parsedData->insertExpression((Expression *)$1, subtraction, (Expression *)$3);
388             $$=exp;
389         }
390         | '(' stmt_exp ')'
391         {
392             $$=$2;
393         }
394         | '-' stmt_exp %prec UMINUS
395         {
396             $$ = $2;
397         }
398         | '+' stmt_exp %prec UMINUS
399         {
400             $$ = $2;
401         }
402         | function_opt
403         | atom
404         ;
405 function_opt: DATE_DIFF '(' atom ',' atom ')'
406         {
407               Expression* exp;
408               parsedData->setFunctionType(DATEDIFF);
409               exp=parsedData->insertExpression((Expression *)$3, DATEDIFF, (Expression *)$5);
410             $$=exp;
411         }
412             | DATE_ADD '(' atom  INTERVAL atom date_opt ')'
413             {
414                  Expression* exp;
415              parsedData->setFunctionType((*(FunctionType *)$6));
416              exp=parsedData->insertExpression((Expression *)$3, (*(FunctionType *)$6), (Expression *)$5);
417              $$=exp;
418             }
419         | DATE_SUB '(' atom  INTERVAL atom date_opt ')'
420         {
421              Expression* exp;
422              //parsedData->setFunctionType((*(FunctionType *)$6));
423              parsedData->setFunctionType((FunctionType)((int)(*(FunctionType *)$6)+3));
424              exp=parsedData->insertExpression((Expression *)$3, (FunctionType)((int)(*(FunctionType *)$6)+3), (Expression *)$5);
425              $$=exp;
426         }
427         | TIME_DIFF '(' atom ',' atom ')'
428         {
429               Expression* exp;
430               parsedData->setFunctionType(TIMEDIFF);
431               exp=parsedData->insertExpression((Expression *)$3, TIMEDIFF, (Expression *)$5);
432             $$=exp;
433         }
434         | TIME_ADD '(' atom  INTERVAL atom time_opt ')'
435         {
436              Expression* exp;
437              parsedData->setFunctionType((*(FunctionType *)$6));
438              exp=parsedData->insertExpression((Expression *)$3, (*(FunctionType *)$6), (Expression *)$5);
439              $$=exp;
440         }
441         | TIME_SUB '(' atom  INTERVAL atom time_opt ')'
442         {
443              Expression* exp;
444              parsedData->setFunctionType((FunctionType)((int)(*(FunctionType *)$6)+3));
445              exp=parsedData->insertExpression((Expression *)$3, (FunctionType)((int)(*(FunctionType *)$6)+3), (Expression *)$5);
446              $$=exp;
447         }
448             | TIMESTAMP_DIFF '(' datetime_opt ','  atom ',' atom ')'
449         {
450               Expression* exp;
451               int diff=0;
452               FunctionType val = (*(FunctionType *)$3);
453               if( val == DATEADDWITHYEAR || val == DATEADDWITHMON || val == DATEADDWITHDAY ) diff = 24;
454               else diff = 21;
455               parsedData->setFunctionType((FunctionType)((int)(*(FunctionType *)$3+diff)));
456               exp=parsedData->insertExpression((Expression *)$5, (FunctionType)((int)(*(FunctionType *)$3)+diff), (Expression *)$7);
457             $$=exp;
458         }
459         | TIMESTAMP_ADD '(' atom  INTERVAL atom datetime_opt ')'
460         {
461              Expression* exp;
462              parsedData->setFunctionType((FunctionType)((int)(*(FunctionType *)$6)+12));
463              exp=parsedData->insertExpression((Expression *)$3, (FunctionType)((int)(*(FunctionType *)$6)+12), (Expression *)$5);
464              $$=exp;
465         }
466         | TIMESTAMP_SUB '(' atom  INTERVAL atom datetime_opt ')'
467         {
468              Expression* exp;
469              parsedData->setFunctionType((FunctionType)((int)(*(FunctionType *)$6)+15));
470              exp=parsedData->insertExpression((Expression *)$3, (FunctionType)((int)(*(FunctionType *)$6)+15), (Expression *)$5);
471              $$=exp;
472         }
473         | EXTRACT '(' datetime_opt FROM atom ')'
474             {
475             FunctionType val = UNKNOWN_FUNCTION;
476             //if((*(FunctionType *)$3) >=8)
477               // val = (FunctionType)((int)(*(FunctionType *)$3)+36);
478             //else
479                val = (FunctionType)((int)(*(FunctionType *)$3)+30);
480             Expression* exp;
481             parsedData->setFunctionType(val);
482             exp=parsedData->insertExpression((Expression *)$5, val,NULL);
483             $$=exp;
484             }
485                 | DATE_TYPE '(' atom  ')'
486         {
487             Expression* exp;
488             parsedData->setFunctionType(DATEFROMTIMESTAMP);
489             exp=parsedData->insertExpression((Expression *)$3, DATEFROMTIMESTAMP, NULL);
490             $$=exp;
492         }
493         | TIME_TYPE '(' atom  ')'
494         {
495             Expression* exp;
496             parsedData->setFunctionType(TIMEFROMTIMESTAMP);
497             exp=parsedData->insertExpression((Expression *)$3, TIMEFROMTIMESTAMP, NULL);
498             $$=exp;
499         }
500         ;
501 datetime_opt: time_opt
502         {
503            FunctionType val = *(FunctionType *)$1;
504            $$ = &val;
505         }
506             | date_opt
507         {
508            FunctionType val = *(FunctionType *)$1;
509            $$ = &val;
510         }
511             ;
512 time_opt: HOUR 
513             { 
514              FunctionType val = TIMEADDWITHHOUR;
515              $$ = &val;
516         }
517             | MINUTE  
518         {
519              FunctionType val = TIMEADDWITHMIN;
520              $$ = &val;
521         }
522             | SECOND  
523         {
524              FunctionType val = TIMEADDWITHSEC;
525              $$ = &val;
526         }
527             ;
528 date_opt: YEAR    
529             {
530                 FunctionType val = DATEADDWITHYEAR;
531             $$ = &val;
532             }
533             | MONTH   
534         {
535                 FunctionType val = DATEADDWITHMON;
536             $$ = &val;
537         }
538             | DAY  
539         {
540             FunctionType val = DATEADDWITHDAY;
541             $$ = &val;
542         }
543             ;
544 atom    :  ident
545         {
546             Expression* exp;
547             exp=parsedData->insertExpression((char *)$1);
548             free($1);
549             $$=exp;
550         }
551         | value
552         {
553             Expression* exp;
554             bool flag = false;
555             exp=parsedData->insertExpression((char *)$1, flag);
556             free($1);
557             $$=exp;
558         }
559         | NULL_VALUE
560         {
561             Expression* exp;
562             exp=parsedData->insertExpression("NULL");
563             free($1);
564             $$=exp;
565         }
566         ;
568 where_clause_opt:  WHERE conditions
569         {
570            Condition *cond = parsedData->getCondition();
571            Predicate *pred = cond->getPredicate();
572            if (pred == NULL) {
573                parsedData->setCondition((Predicate*)$2);
574            } else {
575                 Predicate *newPred;
576                 newPred = parsedData->insertPredicate(pred, OpAnd, (Predicate*)$2);
577                 parsedData->setCondition(newPred);
578            }
580         }
581         |
582         ;
583 group_by_opt:  GROUP BY group_field_list
584         |
585         ;
586 order_by_opt:  ORDER BY order_field_list
587         |
588         ;
589 limit_opt:  LIMIT NUMBER_STRING
590         {
591             parsedData->setLimit(atoi($2), 0);
592         }
593         | LIMIT NUMBER_STRING OFFSET NUMBER_STRING
594         {
595             parsedData->setLimit(atoi($2), atoi($4));
596         }
597         |
598         ;
599 having_opt:  HAVING hconditions
600         |
601         ;
602 group_field_list: group_field_list group_field_list_L
603         | group_field 
604         ;
605 group_field_list_L: ',' group_field
606         ;
607 group_field:   ident
608         {
609             parsedData->insertGroupField((char*)$1);
610             free( $1 );
611         }
612         ;
613 order_field_list: order_field_list order_field_list_L
614         | order_field
615         ;
616 order_field_list_L: ',' order_field
617         ;
618 order_field:   ident
619         {
620             parsedData->insertOrderByField((char*)$1);
621             free( $1 );
622         }
623         | ident ASC
624         {
625             parsedData->insertOrderByField((char*)$1);
626             free( $1 );
627         }
628         | ident DESC
629         {
630             parsedData->insertOrderByField((char*)$1, true);
631             free( $1 );
632         }
633         ;
634 conditions: conditions OR conditions
635         {
636             Predicate *pred;
637             pred = parsedData->insertPredicate((Predicate*) $1, OpOr, (Predicate*) $3);
638             //parsedData->setCondition((Predicate*)pred);
639             $$= pred;
641         }
642         | conditions AND conditions
643         {
644             Predicate *pred;
645             pred = parsedData->insertPredicate((Predicate*) $1, OpAnd, (Predicate*) $3);
646             //parsedData->setCondition((Predicate*)pred);
647             $$= pred;
648         }
649         | '(' conditions ')' { $$=$2; }
650         | NOT '(' conditions ')'
651         {
652             Predicate *pred;
653             pred = parsedData->insertPredicate((Predicate*) $3, OpNot, NULL);
654             //parsedData->setCondition((Predicate*)pred);
655             $$= pred;
657         }
658         | not_opt condition
659         {
660             if( $1 == (char*) 1 )
661             {
662                 Predicate *pred;
663                 pred = parsedData->insertPredicate((Predicate*) $2, OpNot, NULL);
664                 //parsedData->setCondition((Predicate*)pred);
665                 $$= pred;
666             }
667             else
668             {
669                 //parsedData->setCondition((Predicate*)$2);
670                 $$=$2;
671             }
672         }
673         ;
674 hconditions: hconditions OR hconditions
675         {
676             Predicate *pred;
677             pred = parsedData->insertPredicate((Predicate*) $1, OpOr, (Predicate*) $3);
678             parsedData->setHavingCondition((Predicate*)pred);
679             $$= pred;
681         }
682         | hconditions AND hconditions
683         {
684             Predicate *pred;
685             pred = parsedData->insertPredicate((Predicate*) $1, OpAnd, (Predicate*) $3);
686             parsedData->setHavingCondition((Predicate*)pred);
687             $$= pred;
688         }
689         | '(' hconditions ')' { $$=$2; }
690         | NOT '(' hconditions ')'
691         {
692             Predicate *pred;
693             pred = parsedData->insertPredicate((Predicate*) $3, OpNot, NULL);
694             parsedData->setHavingCondition((Predicate*)pred);
695             $$= pred;
697         }
698         | not_opt hcondition
699         {
700             if( $1 == (char*) 1 )
701             {
702                 Predicate *pred;
703                 pred = parsedData->insertPredicate((Predicate*) $2, OpNot, NULL);
704                 parsedData->setHavingCondition((Predicate*)pred);
705                 $$= pred;
706             }
707             else
708             {
709                 parsedData->setHavingCondition((Predicate*)$2);
710                 $$=$2;
711             }
712         }
713         ;
714 hcondition: MIN  '(' ident ')' OPERATOR value
715         {
716             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$5);
717             Predicate *pred;
718             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$3, (char*)$6, false, AGG_MIN, true);
719             pred = parsedData->insertPredicate((char*) $3, op, ptr, AGG_MIN);
720             free( $1 ); free ($3); free ($5); free ($6);
721             $$=pred;
722         }
723         | MAX  '(' ident ')' OPERATOR value
724         {
725             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$5);
726             Predicate *pred;
727             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$3, (char*)$6, false, AGG_MAX, true);
728             pred = parsedData->insertPredicate((char*) $3, op, ptr, AGG_MAX);
729             free( $1 ); free ($3); free ($5); free ($6);
730             $$=pred;
731         }
732         | SUM  '(' ident ')' OPERATOR value
733         {
734             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$5);
735             Predicate *pred;
736             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$3, (char*)$6, false, AGG_SUM, true);
737             pred = parsedData->insertPredicate((char*) $3, op, ptr, AGG_SUM);
738             free( $1 ); free ($3); free ($5); free ($6);
739             $$=pred;
740         }
741         | AVG  '(' ident ')' OPERATOR value
742         {
743             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$5);
744             Predicate *pred;
745             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$3, (char*)$6, false, AGG_AVG, true);
746             pred = parsedData->insertPredicate((char*) $3, op, ptr, AGG_AVG);
747             free( $1 ); free ($3); free ($5); free ($6);
748             $$=pred;
749         }
750         | COUNT  '(' ident ')' OPERATOR value
751         {
752             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$5);
753             Predicate *pred;
754             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$3, (char*)$6, false, AGG_COUNT, true);
755             pred = parsedData->insertPredicate((char*) $3, op, ptr, AGG_COUNT);
756             free( $1 ); free ($3); free ($5); free ($6);
757             $$=pred;
758         }
759         ;
761 condition: ident OPERATOR value 
762         {
763             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
764                         bool opLike = false;
765             if (op == OpLike) opLike = true;
766             Predicate *pred;
767             void **ptr = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$3, opLike);
768             pred = parsedData->insertPredicate((char*) $1, op, ptr);
769             free( $1 ); free($2); free( $3 ); 
770             $$=pred;
771         }
772         | ident OPERATOR ident
773         {
774             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
775             Predicate *pred;
776             parsedData->insertCondValue((char*) $1);
777             parsedData->insertCondValue((char*) $3);
778             pred = parsedData->insertPredicate((char*) $1, op, (char*) $3);
779             free( $1 ); free($2); free( $3 );
780             $$=pred;
781         }
783         | ident not_opt BETWEEN value AND value
784         {
785             void **ptr1 = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$4);
786             void **ptr2 = parsedData->insertCondValueAndGetPtr((char*)$1, (char*)$6);
787             Predicate *finalPred;
788  //           pred1 = parsedData->insertPredicate((char*) $1, OpGreaterThanEquals, ptr1);
789 //            pred2 = parsedData->insertPredicate((char*) $1, OpLessThanEquals, ptr2);
790             finalPred = parsedData->insertBetPredicate((char*) $1, 
791                         OpGreaterThanEquals, ptr1, OpLessThanEquals, ptr2);
792                         //OpLessThanEquals, ptr2, OpGreaterThanEquals, ptr1);
794             if( $2 == (char*) 1 )
795                 finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);
796             free( $1 );  free( $4 );  free( $6 );
797             $$= finalPred;
798         }
799         | ident not_opt IN '(' invalue_list ')'
800         {
801             ListIterator valIter = parsedData->getInValueList().getIterator();
802             FieldValue *value1, *value2;
803             Predicate *pred1, *pred2, *finalPred;
804             void **ptr1, **ptr2;
805             if (valIter.hasElement()) {
806                value1 = (FieldValue*) valIter.nextElement();
807                ptr1 = parsedData->insertCondValueAndGetPtr((char*)$1, value1->parsedString);
808                pred1 = parsedData->insertPredicate((char*) $1, OpEquals, ptr1);
809                finalPred=pred1;
810             }
811             while (valIter.hasElement()) {
812                value2 = (FieldValue*) valIter.nextElement();
813                ptr2 = parsedData->insertCondValueAndGetPtr((char*)$1, value2->parsedString);
814                pred2 = parsedData->insertPredicate((char*) $1, OpEquals, ptr2);
815                finalPred = parsedData->insertPredicate(pred1, OpOr, pred2);
816                pred1= finalPred;     
817             }
818             parsedData->resetInValueList();
819             if( $2 == (char*)1)
820                 finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);
822             free( $1 );  
823             $$= finalPred;
824         }
825         | ident IS NOT NULL_VALUE
826         {
827             Predicate *pred;
828             parsedData->insertCondValue((char*) $1);
829             pred = parsedData->insertNullPredicate((char*) $1, OpIsNull, false);
830             free( $1 ); free($2); free( $3 );
831             $$=pred;  
832         }
833         | ident IS NULL_VALUE
834         {
835             Predicate *pred;
836             parsedData->insertCondValue((char*) $1);
837             pred = parsedData->insertNullPredicate((char*) $1, OpIsNull, true);
838             free( $1 ); free($2); free( $3 );
839             $$=pred;  
840         }
841         | function_opt OPERATOR function_opt
842         {
843             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
844             Predicate *pred;
845             pred = parsedData->insertPredicate(((Expression*)$1), op, ((Expression*)$3));
846             $$=pred;
848         }
849         | function_opt OPERATOR ident
850         {
852             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
853             parsedData->insertCondValue((char*) $3);
854             Predicate *pred;
855             pred = parsedData->insertPredicate(((Expression*)$1), op, (char*) $3);
856             $$=pred;
857             
858         }
859         | function_opt OPERATOR value 
860         {
861             ComparisionOp  op = AllDataType::getComparisionOperator((char*)$2);
862             void **ptr = parsedData->insertCondValueAndGetPtr((char*)"dummy", (char*)$3, false, AGG_UNKNOWN, false, true);
863             Predicate *pred;
864             pred = parsedData->insertPredicate(((Expression*)$1), op, ptr);
865             $$=pred;
866         }
867         ;
868 not_opt: NOT
869         { $$=(char*) 1;
870         }
871         | 
872         { $$=(char*) 0; }
873         ;
874 table:   ident
875         {
876             parsedData->insertTableName((char*)$1);
877             free( $1 );
878         }
879         | ident AS ident
880         {
881             parsedData->insertTableName((char*)$1, (char*)$3);
882             free( $1 ); free($3);
883         }
884         | ident ident
885         {
886             parsedData->insertTableName((char*)$1, (char*)$2);
887             free( $1 ); free($2);
888         }
889         ;
890 field:   ident
891         {
892             parsedData->insertField((char*)$1);
893             free( $1 );
894             
895         }
896         | MIN  '(' ident ')'
897         { 
898             parsedData->insertField((char*)$3, AGG_MIN);
899             free( $1 );
900         }
901         | MAX  '(' ident ')'
902         { 
903             parsedData->insertField((char*)$3, AGG_MAX);
904             free( $1 );
905         }
906         | SUM  '(' ident ')'
907         { 
908             parsedData->insertField((char*)$3, AGG_SUM);
909             free( $1 );
910         }
911         | AVG  '(' ident ')'
912         { 
913             parsedData->insertField((char*)$3, AGG_AVG);
914             free( $1 );
915         }
916         | COUNT  '(' ident ')'
917         { 
918             parsedData->insertField((char*)$3, AGG_COUNT);
919             free( $1 );
920         }
921         | COUNT  '(' '*' ')'
922         { 
923             parsedData->insertField("*", AGG_COUNT);
924             free( $1 );
925         }
926         | '*'
927         { 
928             parsedData->insertField("*");
929         }
930         |ident'*'
931         {
932             parsedData->insertField("*");
933         }
934         ;
935 ident:    FIELD { $$ = $1; }
936         | '`'FIELD'`' { $$ = $2; }
937         ;
938 value:    STRING { $$ = $1; }
939         | num_value
940         | BINARY_STRING { $$ = $1; }
941         | doub_value
942         | PARAMETER { $$ = $1; }
943         | NULL_VALUE { $$ = (char*) 0; }
944         | NOW '(' ')'
945         {
946               char *str=(char*)malloc(20);
947               time_t rawtime;
948               struct tm * timeinfo;
949               time ( &rawtime );
950               timeinfo = localtime ( &rawtime );
951               sprintf(str,"%d-%d-%d %d:%d:%d",timeinfo->tm_year+1900,timeinfo->tm_mon+1,timeinfo->tm_mday,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);
952               $$=str;
955         }
956         ;
957 num_value: NUMBER_STRING { $$ =  $1; }
958         | '-' NUMBER_STRING %prec UMINUS
959         {
960              char *n;
961              n=(char*)malloc(30);
962              strcpy(n,"-");
963              strcat(n,(char*)$2);
964              $$=n;
965              free($2);
966         }
967         | '+' NUMBER_STRING %prec UMINUS{ $$ =  $2; }
968         ;
969 doub_value : DOUBLE { $$ = $1; }
970         | '-' DOUBLE %prec UMINUS
971         {
972              char *d;
973              d=(char*)malloc(30);
974              strcpy(d,"-");
975              strcat(d,(char*)$2);
976              $$=d;
977              free($2);
978         }
979         | '+' DOUBLE %prec UMINUS{ $$ = $2; }
980         ;
981 cache_statement: CACHE TABLE ident cache_opt semicolon_opt
982         {
983             if (!Conf::config.useCache())
984             {
985               printf("CACHE_TABLE is set to FALSE in csql.conf file.\n");
986               free($3);
987               YYABORT;
988             }
989             parsedData->setStmtType(CacheTableStatement);
990             parsedData->setTableName($3); 
991         }
992         | UNCACHE TABLE ident semicolon_opt
993         {
994             parsedData->setStmtType(CacheTableStatement);
995             parsedData->setUnCache(true);
996             parsedData->setTableName($3); 
997         }
998         ; 
999 cache_opt: hcond_cache vcond_cache pk_cache direct_opt dsn_opt no_schema
1000          ;
1001 hcond_cache: 
1002          | CONDITION value 
1003          {
1004             parsedData->setHCondFld(true);
1005             parsedData->setHCondition((char*)$2);
1006          }
1007          ;
1008 vcond_cache:
1009          | FIELDLIST value
1010          {
1011             parsedData->setVCondFld(true);
1012             parsedData->setVCondition((char*)$2);
1013             free($2);
1014          }
1015          ;
1016 pk_cache:
1017          | PK ident
1018          {
1019             parsedData->setPkFld(true);
1020             parsedData->setIndexName((char*)$2);
1021             free($2);
1022          }
1023          ;
1024 direct_opt:
1025          | DIRECT
1026          {
1027             parsedData->setDirect(true);
1028          }
1029          ;
1030 dsn_opt:
1031          | DSN value
1032          {
1033              parsedData->setDSN(true);
1034              parsedData->setPKTableName((char*)$2);
1035              free($2);
1036          }
1037 no_schema:
1038          | NOSCHEMA
1039          {
1040              parsedData->setNoSchema(true);
1041          }
1042          ;
1043 ddl_statement: CREATE TABLE ident '(' create_defn_list_con ')' semicolon_opt
1044         {
1045             parsedData->setStmtType(CreateTableStatement);
1046             parsedData->setTableName($3); 
1047             free($3);
1048         }
1049         | CREATE INDEX ident ON ident '(' field_list ')' opt_constr_type opt_ind_type opt_bucket semicolon_opt
1050         {
1051             parsedData->setStmtType(CreateIndexStatement);
1052             parsedData->setIndexName($3); 
1053             parsedData->setTableName($5); 
1054             free($3);
1055             free($5);
1056         }
1057         | DROP TABLE ident
1058         {
1059             parsedData->setStmtType(DropTableStatement);
1060             parsedData->setTableName($3); 
1061             free($3);
1062         }
1063         | DROP INDEX ident
1064         {
1065             parsedData->setStmtType(DropIndexStatement);
1066             parsedData->setIndexName($3); 
1067             free($3);
1068         }
1069         | TRUNCATE TABLE ident semicolon_opt
1070         {
1071             parsedData->setStmtType(TruncateStatement);
1072             parsedData->setTableName($3); 
1073             free($3);
1074         }
1075         ;
1076 opt_ind_type:
1077         | HASH  opt_constr_type
1078         {
1079             parsedData->setIndexType(hashIndex);
1080         }
1081         | TREE  opt_constr_type
1082         {
1083             parsedData->setIndexType(treeIndex);
1084         }
1085         | TRIE  opt_constr_type
1086         {
1087             parsedData->setIndexType(trieIndex);
1088         }
1089         |
1090         {
1091             parsedData->setIndexType(hashIndex);
1092         }
1093         ;
1094 opt_constr_type:
1095         | UNIQUE 
1096         {
1097             parsedData->setUnique(true);
1098         }
1099         | PRIMARY 
1100         {
1101             parsedData->setUnique(true);
1102             parsedData->setPrimary(true);
1103         }
1104         |
1105         {
1106             parsedData->setUnique(false);
1107             parsedData->setPrimary(false);
1108         }
1109         ;
1110 opt_bucket:
1111         | SIZE NUMBER_STRING
1112         {
1113             parsedData->setBucketSize(atoi($2));
1114             free($2);
1115         }
1116         ;
1117 create_defn_list_con:create_defn_list
1118         |create_defn_list ',' constraint_defn
1119         ;
1120 create_defn_list: create_defn_list create_defn_list_L
1121         | create_defn
1122         ;
1124 create_defn_list_L: ',' create_defn
1125         ;
1127 create_defn: field_defn
1128         {
1129             parsedData->insertFldDef();
1130         }
1131         ;
1133 field_defn: field_name field_type size_opt null_expr_opt default_expr_opt auto_increment_key 
1134         ;
1136 field_name: ident
1137         {
1138             parsedData->setFldName($1);
1139             free($1);
1140         }
1141 size_opt:
1142         | '(' NUMBER_STRING ')'
1143         {
1144             DbRetVal rv = parsedData->setFldLength(atoi($2));
1145             if (rv != OK) {
1146                 yyerror("Binary field length < 256");
1147                 free($2);
1148                 YYABORT;
1149             }
1150             free($2);
1151         }
1152         ;
1154 default_expr_opt:
1155         | DEFAULT value
1156         {
1157             DbRetVal rv = parsedData->setDefaultValue($2);
1158             if(rv != OK){
1159                 yyerror("Invalid Default value.");
1160                 free($2);
1161                 YYABORT;
1162             }
1163             free($2);
1164         }
1165         ;
1167 null_expr_opt:
1168         | NOT NULL_VALUE
1169         {
1170             parsedData->setFldNotNull(true);
1171         }
1172         ;
1173 constraint_defn : primary_key_constraint
1174         | foreign_key_constraint
1175         | primary_key_constraint ',' foreign_key_constraint
1176         ;
1177 foreign_key_constraint: foreign_key_constraint foreign_key_constraint_L
1178         | foreign_key_create
1179         ;
1180 foreign_key_constraint_L: ',' foreign_key_create
1181         ;
1182 foreign_key_create: FOREIGN KEY '(' fkField_list ')' REFERENCES ident'(' pkField_list ')'
1183         {
1184             parsedData->setForeign(true);
1185             parsedData->setPKTableName((char*)$7);
1186             parsedData->insertForeignKeyList();
1187         }
1188         ;
1189 fkField_list: fkField_list fkField_list_L
1190         | fkField
1191         ;
1192 fkField_list_L: ',' fkField
1193         ;
1194 fkField: ident
1195         {
1196            parsedData->insertFKField((char*)$1);
1197            free($1);
1198         }
1199         ;
1200 pkField_list: pkField_list pkField_list_L
1201         | pkField
1202         ;
1203 pkField_list_L: ',' pkField
1204         ;
1205 pkField: ident
1206         {
1207            parsedData->insertPKField((char*)$1);
1208            free($1);
1209         }
1210         ;
1212 primary_key_constraint: PRIMARY KEY '(' field_list ')' opt_bucket
1213         {
1214            parsedData->setPrimary(true);
1215         }
1216         ;
1217 auto_increment_key:
1218         | AUTO_INCREMENT
1219         {
1220            DataType type = parsedData->getFldType();
1221            if(type > 4)
1222            {
1223                yyerror("AUTO_INCREMENT KEY can't be created other than INTEGER field ");
1224                free($1);
1225                YYABORT;
1226            }
1227            DbRetVal ret = parsedData->setAutoIncreament(true);
1228            if(ret != OK){
1229                yyerror("A table should have ony one AUTO_INCREMENT KEY ");
1230                free($1);
1231                YYABORT;
1232            }
1233            parsedData->setFldNotNull(true);
1234            parsedData->setAutoFldName(parsedData->getFldName());
1235            parsedData->setPrimary(true);
1236         }
1237         ;
1239 field_type: INT_TYPE
1240         {
1241             parsedData->setFldType(typeInt);
1242         }
1243         | LONG_TYPE
1244         {
1245             parsedData->setFldType(typeLong);
1246         }
1247         | SHORT_TYPE
1248         {
1249             parsedData->setFldType(typeShort);
1250         }
1251         | BIGINT_TYPE
1252         {
1253             parsedData->setFldType(typeLongLong);
1254         }
1255         | TINYINT_TYPE
1256         {
1257             parsedData->setFldType(typeByteInt);
1258         }
1259         | FLOAT_TYPE
1260         {
1261             parsedData->setFldType(typeFloat);
1262         }
1263         | DOUBLE_TYPE
1264         {
1265             parsedData->setFldType(typeDouble);
1266         }
1267         ;
1268         | DATE_TYPE
1269         {
1270             parsedData->setFldType(typeDate);
1271         }
1272         ;
1273         | TIME_TYPE
1274         {
1275             parsedData->setFldType(typeTime);
1276         }
1277         ;
1278         | TIMESTAMP_TYPE
1279         {
1280             parsedData->setFldType(typeTimeStamp);
1281         }
1282         ;
1283         | CHAR_TYPE
1284         {
1285             parsedData->setFldType(typeString);
1286             parsedData->setFldLength(2);
1287         }
1288         ;
1289         | VARCHAR_TYPE
1290         {
1291             parsedData->setFldType(typeVarchar);
1292             parsedData->setFldLength(2);
1293         }
1294         ;
1295         | BINARY_TYPE
1296         {
1297             parsedData->setFldType(typeBinary);
1298             parsedData->setFldLength(1);
1299         }
1300         ;
1303 extern int lexEof;
1304 void yyerror(const char* Msg) { 
1305     if( lexEof == 0 )
1306         fprintf(stderr, "[Parser: %s] %s\n", Msg, yytext);
1308     return;