1 // All token codes are small integers with #defines that begin with "TK_"
2 %token_prefix T_
3
4 // The type of the data attached to each token is GValue. This is also the
5 // default type for non-terminals.
6 //
7 %token_type {GValue *}
8 %default_type {GValue *}
9 %token_destructor {if ($$) {
10 #ifdef GDA_DEBUG_NO
11 gchar *str = gda_sql_value_stringify ($$);
12 g_print ("___ token destructor /%s/\n", str)
13 g_free (str);
14 #endif
15 g_value_unset ($$); g_free ($$);}}
16
17 // The generated parser function takes a 4th argument as follows:
18 %extra_argument {GdaSqlParserIface *pdata}
19
20 // This code runs whenever there is a syntax error
21 //
22 %syntax_error {
23 gda_sql_parser_set_syntax_error (pdata->parser);
24 }
25 %stack_overflow {
26 gda_sql_parser_set_overflow_error (pdata->parser);
27 }
28
29 // The name of the generated procedure that implements the parser
30 // is as follows:
31 %name gda_lemon_firebird_parser
32
33 // The following text is included near the beginning of the C source
34 // code file that implements the parser.
35 //
36 %include {
37 #include <string.h>
38 #include <glib.h>
39 #include <glib-object.h>
40 #include <glib/gi18n-lib.h>
41 #include <libgda/sql-parser/gda-sql-parser-private.h>
42 #include <libgda/sql-parser/gda-statement-struct-util.h>
43 #include <libgda/sql-parser/gda-statement-struct-trans.h>
44 #include <libgda/sql-parser/gda-statement-struct-insert.h>
45 #include <libgda/sql-parser/gda-statement-struct-update.h>
46 #include <libgda/sql-parser/gda-statement-struct-delete.h>
47 #include <libgda/sql-parser/gda-statement-struct-select.h>
48 #include <libgda/sql-parser/gda-statement-struct-compound.h>
49 #include <libgda/sql-parser/gda-statement-struct-parts.h>
50 #include <assert.h>
51
52 typedef struct {
53 GValue *fname;
54 GdaSqlExpr *expr;
55 } UpdateSet;
56
57 typedef struct {
58 gboolean distinct;
59 GdaSqlExpr *expr;
60 } Distinct;
61
62 typedef struct {
63 GdaSqlExpr *count;
64 GdaSqlExpr *offset;
65 } Limit;
66
67 typedef struct {
68 GSList *when_list;
69 GSList *then_list;
70 } CaseBody;
71
72 static GdaSqlOperatorType
sql_operation_string_to_operator(const gchar * op)73 sql_operation_string_to_operator (const gchar *op)
74 {
75 switch (g_ascii_toupper (*op)) {
76 case 'A':
77 return GDA_SQL_OPERATOR_TYPE_AND;
78 case 'O':
79 return GDA_SQL_OPERATOR_TYPE_OR;
80 case 'N':
81 return GDA_SQL_OPERATOR_TYPE_NOT;
82 case '=':
83 return GDA_SQL_OPERATOR_TYPE_EQ;
84 case 'I':
85 if (op[1] == 'S')
86 return GDA_SQL_OPERATOR_TYPE_IS;
87 else if (op[1] == 'N')
88 return GDA_SQL_OPERATOR_TYPE_IN;
89 break;
90 case 'L':
91 return GDA_SQL_OPERATOR_TYPE_LIKE;
92 case 'B':
93 return GDA_SQL_OPERATOR_TYPE_BETWEEN;
94 case '>':
95 if (op[1] == '=')
96 return GDA_SQL_OPERATOR_TYPE_GEQ;
97 else if (op[1] == 0)
98 return GDA_SQL_OPERATOR_TYPE_GT;
99 break;
100 case '<':
101 if (op[1] == '=')
102 return GDA_SQL_OPERATOR_TYPE_LEQ;
103 else if (op[1] == '>')
104 return GDA_SQL_OPERATOR_TYPE_DIFF;
105 else if (op[1] == 0)
106 return GDA_SQL_OPERATOR_TYPE_LT;
107 break;
108 case '!':
109 if (op[1] == '=')
110 return GDA_SQL_OPERATOR_TYPE_DIFF;
111 else if (op[1] == '~') {
112 if (op[2] == 0)
113 return GDA_SQL_OPERATOR_TYPE_NOT_REGEXP;
114 else if (op[2] == '*')
115 return GDA_SQL_OPERATOR_TYPE_NOT_REGEXP_CI;
116 }
117 break;
118 case '~':
119 if (op[1] == '*')
120 return GDA_SQL_OPERATOR_TYPE_REGEXP_CI;
121 else if (op[1] == 0)
122 return GDA_SQL_OPERATOR_TYPE_REGEXP;
123 break;
124 case 'S':
125 return GDA_SQL_OPERATOR_TYPE_SIMILAR;
126 case '|':
127 if (op[1] == '|')
128 return GDA_SQL_OPERATOR_TYPE_CONCAT;
129 else
130 return GDA_SQL_OPERATOR_TYPE_BITOR;
131 case '+':
132 return GDA_SQL_OPERATOR_TYPE_PLUS;
133 case '-':
134 return GDA_SQL_OPERATOR_TYPE_MINUS;
135 case '*':
136 return GDA_SQL_OPERATOR_TYPE_STAR;
137 case '/':
138 return GDA_SQL_OPERATOR_TYPE_DIV;
139 case '%':
140 return GDA_SQL_OPERATOR_TYPE_REM;
141 case '&':
142 return GDA_SQL_OPERATOR_TYPE_BITAND;
143 }
144 g_error ("Unhandled operator named '%s'\n", op);
145 return 0;
146 }
147
148 static GdaSqlOperatorType
string_to_op_type(GValue * value)149 string_to_op_type (GValue *value)
150 {
151 GdaSqlOperatorType op;
152 op = sql_operation_string_to_operator (g_value_get_string (value));
153 g_value_reset (value);
154 g_free (value);
155 return op;
156 }
157
158 static GdaSqlExpr *
compose_multiple_expr(GdaSqlOperatorType op,GdaSqlExpr * left,GdaSqlExpr * right)159 compose_multiple_expr (GdaSqlOperatorType op, GdaSqlExpr *left, GdaSqlExpr *right) {
160 GdaSqlExpr *ret;
161 if (left->cond && (left->cond->operator_type == op)) {
162 ret = left;
163 ret->cond->operands = g_slist_append (ret->cond->operands, right);
164 }
165 else {
166 GdaSqlOperation *cond;
167 ret = gda_sql_expr_new (NULL);
168 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
169 ret->cond = cond;
170 cond->operator_type = op;
171 cond->operands = g_slist_prepend (NULL, right);
172 GDA_SQL_ANY_PART (right)->parent = GDA_SQL_ANY_PART (cond);
173 cond->operands = g_slist_prepend (cond->operands, left);
174 GDA_SQL_ANY_PART (left)->parent = GDA_SQL_ANY_PART (cond);
175 }
176 return ret;
177 }
178
179 static GdaSqlExpr *
create_two_expr(GdaSqlOperatorType op,GdaSqlExpr * left,GdaSqlExpr * right)180 create_two_expr (GdaSqlOperatorType op, GdaSqlExpr *left, GdaSqlExpr *right) {
181 GdaSqlExpr *ret;
182 GdaSqlOperation *cond;
183 ret = gda_sql_expr_new (NULL);
184 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
185 ret->cond = cond;
186 cond->operator_type = op;
187 cond->operands = g_slist_prepend (NULL, right);
188 GDA_SQL_ANY_PART (right)->parent = GDA_SQL_ANY_PART (cond);
189 cond->operands = g_slist_prepend (cond->operands, left);
190 GDA_SQL_ANY_PART (left)->parent = GDA_SQL_ANY_PART (cond);
191 return ret;
192 }
193
194 static GdaSqlExpr *
create_uni_expr(GdaSqlOperatorType op,GdaSqlExpr * expr)195 create_uni_expr (GdaSqlOperatorType op, GdaSqlExpr *expr) {
196 GdaSqlExpr *ret;
197 GdaSqlOperation *cond;
198 ret = gda_sql_expr_new (NULL);
199 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
200 ret->cond = cond;
201 cond->operator_type = op;
202 cond->operands = g_slist_prepend (NULL, expr);
203 GDA_SQL_ANY_PART (expr)->parent = GDA_SQL_ANY_PART (cond);
204 return ret;
205 }
206
207 static GdaSqlStatement *
compose_multiple_compounds(GdaSqlStatementCompoundType ctype,GdaSqlStatement * left,GdaSqlStatement * right)208 compose_multiple_compounds (GdaSqlStatementCompoundType ctype, GdaSqlStatement *left, GdaSqlStatement *right) {
209 GdaSqlStatement *ret = NULL;
210 GdaSqlStatementCompound *lc = (GdaSqlStatementCompound*) left->contents;
211 if (lc->compound_type == ctype) {
212 GdaSqlStatementCompound *rc = (GdaSqlStatementCompound*) right->contents;
213 if (!rc->stmt_list->next || rc->compound_type == ctype) {
214 GSList *list;
215 for (list = rc->stmt_list; list; list = list->next)
216 GDA_SQL_ANY_PART (((GdaSqlStatement*)list->data)->contents)->parent = GDA_SQL_ANY_PART (lc);
217
218 ret = left;
219 lc->stmt_list = g_slist_concat (lc->stmt_list, rc->stmt_list);
220 rc->stmt_list = NULL;
221 gda_sql_statement_free (right);
222 }
223 }
224 else {
225 ret = gda_sql_statement_new (GDA_SQL_STATEMENT_COMPOUND);
226 gda_sql_statement_compound_set_type (ret, ctype);
227 gda_sql_statement_compound_take_stmt (ret, left);
228 gda_sql_statement_compound_take_stmt (ret, right);
229 }
230 return ret;
231 }
232
233 }
234
235 // The following directive causes tokens ABORT, AFTER, ASC, etc. to
236 // fallback to ID if they will not parse as their original value.
237 %fallback ID
238 ABORT AFTER ANALYZE ASC ATTACH BEFORE BEGIN CASCADE CAST CONFLICT
239 DATABASE DEFERRED DESC DETACH EACH END EXCLUSIVE EXPLAIN FAIL FOR
240 IGNORE IMMEDIATE INITIALLY INSTEAD LIKE MATCH PLAN
241 QUERY KEY OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW
242 TEMP TRIGGER VACUUM VIEW VIRTUAL
243 REINDEX RENAME CTIME_KW IF
244 DELIMITER COMMIT ROLLBACK ISOLATION LEVEL SERIALIZABLE READ COMMITTED
245 UNCOMMITTED REPEATABLE WRITE ONLY SAVEPOINT RELEASE COMMENT FORCE WAIT NOWAIT BATCH.
246
247 // Define operator precedence early so that this is the first occurance
248 // of the operator tokens in the grammer. Keeping the operators together
249 // causes them to be assigned integer values that are close together,
250 // which keeps parser tables smaller.
251 %left OR.
252 %left AND.
253 %right NOT.
254 %left IS MATCH NOTLIKE LIKE IN ISNULL NOTNULL DIFF EQ.
255 %left BETWEEN.
256 %left GT LEQ LT GEQ.
257 %left REGEXP REGEXP_CI NOT_REGEXP NOT_REGEXP_CI.
258 %left SIMILAR.
259 %right ESCAPE.
260 %left BITAND BITOR LSHIFT RSHIFT.
261 %left PLUS MINUS.
262 %left STAR SLASH REM.
263 %left CONCAT.
264 %left COLLATE.
265 %right UMINUS UPLUS BITNOT.
266 %left LP RP.
267 %left JOIN INNER NATURAL LEFT RIGHT FULL CROSS.
268 %left UNION EXCEPT.
269 %left INTERSECT.
270 %left PGCAST.
271
272 // force the declaration of the ILLEGAL and SQLCOMMENT tokens
273 %nonassoc ILLEGAL.
274 %nonassoc SQLCOMMENT.
275
276 // Input is a single SQL command
277 %type stmt {GdaSqlStatement *}
278 %destructor stmt {g_print ("Statement destroyed by parser: %p\n", $$); gda_sql_statement_free ($$);}
cmd(C)279 stmt ::= cmd(C) eos. {pdata->parsed_statement = C;}
compound(C)280 stmt ::= compound(C) eos. {
281 GdaSqlStatementCompound *scompound = (GdaSqlStatementCompound *) C->contents;
282 if (scompound->stmt_list->next)
283 /* real compound (multiple statements) */
284 pdata->parsed_statement = C;
285 else {
286 /* false compound (only 1 select) */
287 pdata->parsed_statement = (GdaSqlStatement*) scompound->stmt_list->data;
288 GDA_SQL_ANY_PART (pdata->parsed_statement->contents)->parent = NULL;
289 g_slist_free (scompound->stmt_list);
290 scompound->stmt_list = NULL;
291 gda_sql_statement_free (C);
292 }
293 }
cmd(C)294 cmd(C) ::= LP cmd(E) RP. {C = E;}
compound(C)295 compound(C) ::= LP compound(E) RP. {C = E;}
296
297 eos ::= SEMI.
298 eos ::= END_OF_FILE.
299
300 %type cmd {GdaSqlStatement *}
301 %destructor cmd {gda_sql_statement_free ($$);}
302
303 //
304 // Transactions
305 //
cmd(C)306 cmd(C) ::= BEGIN. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);}
cmd(C)307 cmd(C) ::= BEGIN TRANSACTION nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
308 gda_sql_statement_trans_take_name (C, R);
309 }
310
cmd(C)311 cmd(C) ::= BEGIN transtype(Y) TRANSACTION nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
312 gda_sql_statement_trans_take_mode (C, Y);
313 gda_sql_statement_trans_take_name (C, R);
314 }
315
cmd(C)316 cmd(C) ::= BEGIN transtype(Y) nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
317 gda_sql_statement_trans_take_mode (C, Y);
318 gda_sql_statement_trans_take_name (C, R);
319 }
320
cmd(C)321 cmd(C) ::= BEGIN transilev(L). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
322 gda_sql_statement_trans_set_isol_level (C, L);
323 }
324
cmd(C)325 cmd(C) ::= BEGIN TRANSACTION transilev(L). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
326 gda_sql_statement_trans_set_isol_level (C, L);
327 }
328
cmd(C)329 cmd(C) ::= BEGIN TRANSACTION transtype(Y). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
330 gda_sql_statement_trans_take_mode (C, Y);
331 }
332
cmd(C)333 cmd(C) ::= BEGIN TRANSACTION transtype(Y) opt_comma transilev(L). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
334 gda_sql_statement_trans_take_mode (C, Y);
335 gda_sql_statement_trans_set_isol_level (C, L);
336 }
337
cmd(C)338 cmd(C) ::= BEGIN TRANSACTION transilev(L) opt_comma transtype(Y). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
339 gda_sql_statement_trans_take_mode (C, Y);
340 gda_sql_statement_trans_set_isol_level (C, L);
341 }
342
cmd(C)343 cmd(C) ::= BEGIN transtype(Y) opt_comma transilev(L). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
344 gda_sql_statement_trans_take_mode (C, Y);
345 gda_sql_statement_trans_set_isol_level (C, L);
346 }
347
cmd(C)348 cmd(C) ::= BEGIN transilev(L) opt_comma transtype(Y). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
349 gda_sql_statement_trans_take_mode (C, Y);
350 gda_sql_statement_trans_set_isol_level (C, L);
351 }
352
cmd(C)353 cmd(C) ::= END trans_opt_kw nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
354 gda_sql_statement_trans_take_name (C, R);
355 }
356
cmd(C)357 cmd(C) ::= COMMIT nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
358 gda_sql_statement_trans_take_name (C, R);
359 }
360
cmd(C)361 cmd(C) ::= COMMIT TRANSACTION nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
362 gda_sql_statement_trans_take_name (C, R);
363 }
364
cmd(C)365 cmd(C) ::= COMMIT FORCE STRING. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);}
cmd(C)366 cmd(C) ::= COMMIT FORCE STRING COMMA INTEGER. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);}
cmd(C)367 cmd(C) ::= COMMIT COMMENT STRING. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);}
cmd(C)368 cmd(C) ::= COMMIT COMMENT STRING ora_commit_write. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);}
cmd(C)369 cmd(C) ::= COMMIT ora_commit_write. {C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);}
370
cmd(C)371 cmd(C) ::= ROLLBACK trans_opt_kw nm_opt(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK);
372 gda_sql_statement_trans_take_name (C, R);
373 }
374
375 ora_commit_write ::= WRITE IMMEDIATE.
376 ora_commit_write ::= WRITE BATCH.
377 ora_commit_write ::= WRITE WAIT.
378 ora_commit_write ::= WRITE NOWAIT.
379 ora_commit_write ::= WRITE IMMEDIATE WAIT.
380 ora_commit_write ::= WRITE IMMEDIATE NOWAIT.
381 ora_commit_write ::= WRITE BATCH WAIT.
382 ora_commit_write ::= WRITE BATCH NOWAIT.
383
384 trans_opt_kw ::= .
385 trans_opt_kw ::= TRANSACTION.
386
387 opt_comma ::= .
388 opt_comma ::= COMMA.
389
390 %type transilev {GdaTransactionIsolation}
transilev(L)391 transilev(L) ::= ISOLATION LEVEL SERIALIZABLE. {L = GDA_TRANSACTION_ISOLATION_SERIALIZABLE;}
transilev(L)392 transilev(L) ::= ISOLATION LEVEL REPEATABLE READ. {L = GDA_TRANSACTION_ISOLATION_REPEATABLE_READ;}
transilev(L)393 transilev(L) ::= ISOLATION LEVEL READ COMMITTED. {L = GDA_TRANSACTION_ISOLATION_READ_COMMITTED;}
transilev(L)394 transilev(L) ::= ISOLATION LEVEL READ UNCOMMITTED. {L = GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED;}
395
nm_opt(R)396 nm_opt(R) ::= . {R = NULL;}
nm_opt(R)397 nm_opt(R) ::= nm(N). {R = N;}
398
transtype(A)399 transtype(A) ::= DEFERRED(X). {A = X;}
transtype(A)400 transtype(A) ::= IMMEDIATE(X). {A = X;}
transtype(A)401 transtype(A) ::= EXCLUSIVE(X). {A = X;}
transtype(A)402 transtype(A) ::= READ WRITE. {A = g_new0 (GValue, 1);
403 g_value_init (A, G_TYPE_STRING);
404 g_value_set_string (A, "READ_WRITE");
405 }
transtype(A)406 transtype(A) ::= READ ONLY. {A = g_new0 (GValue, 1);
407 g_value_init (A, G_TYPE_STRING);
408 g_value_set_string (A, "READ_ONLY");
409 }
410
411 //
412 // Savepoints
413 //
cmd(C)414 cmd(C) ::= SAVEPOINT nm(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_SAVEPOINT);
415 gda_sql_statement_trans_take_name (C, R);
416 }
417
cmd(C)418 cmd(C) ::= RELEASE SAVEPOINT nm(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE_SAVEPOINT);
419 gda_sql_statement_trans_take_name (C, R);
420 }
421
cmd(C)422 cmd(C) ::= RELEASE nm(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE_SAVEPOINT);
423 gda_sql_statement_trans_take_name (C, R);
424 }
425
cmd(C)426 cmd(C) ::= ROLLBACK trans_opt_kw TO nm(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT);
427 gda_sql_statement_trans_take_name (C, R);
428 }
429
cmd(C)430 cmd(C) ::= ROLLBACK trans_opt_kw TO SAVEPOINT nm(R). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT);
431 gda_sql_statement_trans_take_name (C, R);
432 }
433
434 //
435 // INSERT
436 //
cmd(C)437 cmd(C) ::= INSERT opt_on_conflict(O) INTO fullname(X) inscollist_opt(F) VALUES LP rexprlist(Y) RP. {
438 C = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
439 gda_sql_statement_insert_take_table_name (C, X);
440 gda_sql_statement_insert_take_fields_list (C, F);
441 gda_sql_statement_insert_take_1_values_list (C, g_slist_reverse (Y));
442 gda_sql_statement_insert_take_on_conflict (C, O);
443 }
444
cmd(C)445 cmd(C) ::= INSERT opt_on_conflict(O) INTO fullname(X) inscollist_opt(F) VALUES LP rexprlist(Y) RP ins_extra_values(E). {
446 C = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
447 gda_sql_statement_insert_take_table_name (C, X);
448 gda_sql_statement_insert_take_fields_list (C, F);
449 gda_sql_statement_insert_take_1_values_list (C, g_slist_reverse (Y));
450 gda_sql_statement_insert_take_extra_values_list (C, E);
451 gda_sql_statement_insert_take_on_conflict (C, O);
452 }
453
cmd(C)454 cmd(C) ::= INSERT opt_on_conflict(O) INTO fullname(X) inscollist_opt(F) compound(S). {
455 C = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
456 gda_sql_statement_insert_take_table_name (C, X);
457 gda_sql_statement_insert_take_fields_list (C, F);
458 gda_sql_statement_insert_take_select (C, S);
459 gda_sql_statement_insert_take_on_conflict (C, O);
460 }
461
462
opt_on_conflict(O)463 opt_on_conflict(O) ::= . {O = NULL;}
opt_on_conflict(O)464 opt_on_conflict(O) ::= OR ID(V). {O = V;}
465
466 %type ins_extra_values {GSList*}
467 %destructor ins_extra_values {GSList *list;
468 for (list = $$; list; list = list->next) {
469 g_slist_foreach ((GSList*) list->data, (GFunc) gda_sql_field_free, NULL);
470 g_slist_free ((GSList*) list->data);
471 }
472 g_slist_free ($$);
473 }
ins_extra_values(E)474 ins_extra_values(E) ::= ins_extra_values(A) COMMA LP rexprlist(L) RP. {E = g_slist_append (A, g_slist_reverse (L));}
ins_extra_values(E)475 ins_extra_values(E) ::= COMMA LP rexprlist(L) RP. {E = g_slist_append (NULL, g_slist_reverse (L));}
476
477 %type inscollist_opt {GSList*}
478 %destructor inscollist_opt {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_field_free, NULL); g_slist_free ($$);}}
inscollist_opt(A)479 inscollist_opt(A) ::= . {A = NULL;}
inscollist_opt(A)480 inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;}
481
482 %type inscollist {GSList*}
483 %destructor inscollist {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_field_free, NULL); g_slist_free ($$);}}
inscollist(A)484 inscollist(A) ::= inscollist(X) COMMA fullname(Y). {GdaSqlField *field;
485 field = gda_sql_field_new (NULL);
486 gda_sql_field_take_name (field, Y);
487 A = g_slist_append (X, field);
488 }
inscollist(A)489 inscollist(A) ::= fullname(Y). {GdaSqlField *field = gda_sql_field_new (NULL);
490 gda_sql_field_take_name (field, Y);
491 A = g_slist_prepend (NULL, field);
492 }
493
494 // DELETE
cmd(C)495 cmd(C) ::= DELETE FROM fullname(T) where_opt(X). {C = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE);
496 gda_sql_statement_delete_take_table_name (C, T);
497 gda_sql_statement_delete_take_condition (C, X);}
498
499 %type where_opt {GdaSqlExpr *}
500 %destructor where_opt {gda_sql_expr_free ($$);}
where_opt(A)501 where_opt(A) ::= . {A = NULL;}
where_opt(A)502 where_opt(A) ::= WHERE expr(X). {A = X;}
503
504 // UPDATE
cmd(C)505 cmd(C) ::= UPDATE opt_on_conflict(O) fullname(T) SET setlist(S) where_opt(X). {
506 GSList *list;
507 C = gda_sql_statement_new (GDA_SQL_STATEMENT_UPDATE);
508 gda_sql_statement_update_take_table_name (C, T);
509 gda_sql_statement_update_take_on_conflict (C, O);
510 gda_sql_statement_update_take_condition (C, X);
511 for (list = S; list; list = list->next) {
512 UpdateSet *set = (UpdateSet*) list->data;
513 gda_sql_statement_update_take_set_value (C, set->fname, set->expr);
514 g_free (set);
515 }
516 g_slist_free (S);
517 }
518
519 %type setlist {GSList*}
520 %destructor setlist {GSList *list;
521 for (list = $$; list; list = list->next) {
522 UpdateSet *set = (UpdateSet*) list->data;
523 g_value_reset (set->fname); g_free (set->fname);
524 gda_sql_expr_free (set->expr);
525 g_free (set);
526 }
527 g_slist_free ($$);
528 }
setlist(A)529 setlist(A) ::= setlist(Z) COMMA fullname(X) EQ expr(Y). {UpdateSet *set;
530 set = g_new (UpdateSet, 1);
531 set->fname = X;
532 set->expr = Y;
533 A = g_slist_append (Z, set);
534 }
setlist(A)535 setlist(A) ::= fullname(X) EQ expr(Y). {UpdateSet *set;
536 set = g_new (UpdateSet, 1);
537 set->fname = X;
538 set->expr = Y;
539 A = g_slist_append (NULL, set);
540 }
541
542 // COMPOUND SELECT
543 %type compound {GdaSqlStatement *}
544 %destructor compound {gda_sql_statement_free ($$);}
545 //compound(C) ::= LP compound(E) RP. {C = E;}
compound(C)546 compound(C) ::= selectcmd(S). {
547 C = gda_sql_statement_new (GDA_SQL_STATEMENT_COMPOUND);
548 gda_sql_statement_compound_take_stmt (C, S);
549 }
compound(C)550 compound(C) ::= compound(L) UNION opt_compound_all(A) compound(R). {
551 C = compose_multiple_compounds (A ? GDA_SQL_STATEMENT_COMPOUND_UNION_ALL : GDA_SQL_STATEMENT_COMPOUND_UNION,
552 L, R);
553 }
554
compound(C)555 compound(C) ::= compound(L) EXCEPT opt_compound_all(A) compound(R). {
556 C = compose_multiple_compounds (A ? GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL : GDA_SQL_STATEMENT_COMPOUND_EXCEPT,
557 L, R);
558 }
559
compound(C)560 compound(C) ::= compound(L) INTERSECT opt_compound_all(A) compound(R). {
561 C = compose_multiple_compounds (A ? GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL : GDA_SQL_STATEMENT_COMPOUND_INTERSECT,
562 L, R);
563 }
564
565 %type opt_compound_all {gboolean}
opt_compound_all(A)566 opt_compound_all(A) ::= . {A = FALSE;}
opt_compound_all(A)567 opt_compound_all(A) ::= ALL. {A = TRUE;}
568
569
570 // SELECT
571 %type selectcmd {GdaSqlStatement *}
572 %destructor selectcmd {gda_sql_statement_free ($$);}
selectcmd(C)573 selectcmd(C) ::= SELECT distinct(D) selcollist(W) from(F) where_opt(Y)
574 groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). {
575 C = gda_sql_statement_new (GDA_SQL_STATEMENT_SELECT);
576 if (D) {
577 gda_sql_statement_select_take_distinct (C, D->distinct, D->expr);
578 g_free (D);
579 }
580 gda_sql_statement_select_take_expr_list (C, W);
581 gda_sql_statement_select_take_from (C, F);
582 gda_sql_statement_select_take_where_cond (C, Y);
583 gda_sql_statement_select_take_group_by (C, P);
584 gda_sql_statement_select_take_having_cond (C, Q);
585 gda_sql_statement_select_take_order_by (C, Z);
586 gda_sql_statement_select_take_limits (C, L.count, L.offset);
587 }
588
589 %type limit_opt {Limit}
590 %destructor limit_opt {gda_sql_expr_free ($$.count); gda_sql_expr_free ($$.offset);}
limit_opt(A)591 limit_opt(A) ::= . {A.count = NULL; A.offset = NULL;}
limit_opt(A)592 limit_opt(A) ::= LIMIT expr(X). {A.count = X; A.offset = NULL;}
limit_opt(A)593 limit_opt(A) ::= LIMIT expr(X) OFFSET expr(Y). {A.count = X; A.offset = Y;}
limit_opt(A)594 limit_opt(A) ::= LIMIT expr(X) COMMA expr(Y). {A.count = X; A.offset = Y;}
595
596 %type orderby_opt {GSList *}
597 %destructor orderby_opt {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_select_order_free, NULL); g_slist_free ($$);}}
orderby_opt(A)598 orderby_opt(A) ::= . {A = 0;}
orderby_opt(A)599 orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;}
600
601 %type sortlist {GSList *}
602 %destructor sortlist {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_select_order_free, NULL); g_slist_free ($$);}}
sortlist(A)603 sortlist(A) ::= sortlist(X) COMMA expr(Y) sortorder(Z). {GdaSqlSelectOrder *order;
604 order = gda_sql_select_order_new (NULL);
605 order->expr = Y;
606 order->asc = Z;
607 A = g_slist_append (X, order);
608 }
sortlist(A)609 sortlist(A) ::= expr(Y) sortorder(Z). {GdaSqlSelectOrder *order;
610 order = gda_sql_select_order_new (NULL);
611 order->expr = Y;
612 order->asc = Z;
613 A = g_slist_prepend (NULL, order);
614 }
615
616 %type sortorder {gboolean}
sortorder(A)617 sortorder(A) ::= ASC. {A = TRUE;}
sortorder(A)618 sortorder(A) ::= DESC. {A = FALSE;}
sortorder(A)619 sortorder(A) ::= . {A = TRUE;}
620
621
622 %type having_opt {GdaSqlExpr *}
623 %destructor having_opt {gda_sql_expr_free ($$);}
having_opt(A)624 having_opt(A) ::= . {A = NULL;}
having_opt(A)625 having_opt(A) ::= HAVING expr(X). {A = X;}
626
627 %type groupby_opt {GSList*}
628 %destructor groupby_opt {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_expr_free, NULL); g_slist_free ($$);}}
groupby_opt(A)629 groupby_opt(A) ::= . {A = 0;}
groupby_opt(A)630 groupby_opt(A) ::= GROUP BY rnexprlist(X). {A = g_slist_reverse (X);}
631
632 %type from {GdaSqlSelectFrom *}
633 %destructor from {gda_sql_select_from_free ($$);}
from(F)634 from(F) ::= . {F = NULL;}
from(F)635 from(F) ::= FROM seltablist(X). {F = X;}
636
637 %type seltablist {GdaSqlSelectFrom *}
638 %destructor seltablist {gda_sql_select_from_free ($$);}
639 %type stl_prefix {GdaSqlSelectFrom *}
640 %destructor stl_prefix {gda_sql_select_from_free ($$);}
641
seltablist(L)642 seltablist(L) ::= stl_prefix(P) seltarget(T) on_cond(C) using_opt(U). {
643 GSList *last;
644 if (P)
645 L = P;
646 else
647 L = gda_sql_select_from_new (NULL);
648 gda_sql_select_from_take_new_target (L, T);
649 last = g_slist_last (L->joins);
650 if (last) {
651 GdaSqlSelectJoin *join = (GdaSqlSelectJoin *) (last->data);
652 join->expr = C;
653 join->position = g_slist_length (L->targets) - 1;
654 join->use = U;
655 }
656 }
657
658 %type using_opt {GSList*}
659 %destructor using_opt {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_field_free, NULL); g_slist_free ($$);}}
using_opt(U)660 using_opt(U) ::= USING LP inscollist(L) RP. {U = L;}
using_opt(U)661 using_opt(U) ::= . {U = NULL;}
662
stl_prefix(P)663 stl_prefix(P) ::= . {P = NULL;}
stl_prefix(P)664 stl_prefix(P) ::= seltablist(L) jointype(J). {GdaSqlSelectJoin *join;
665 P = L;
666 join = gda_sql_select_join_new (GDA_SQL_ANY_PART (P));
667 join->type = J;
668 gda_sql_select_from_take_new_join (P, join);
669 }
670
671
672 %type on_cond {GdaSqlExpr *}
673 %destructor on_cond {gda_sql_expr_free ($$);}
on_cond(N)674 on_cond(N) ::= ON expr(E). {N = E;}
on_cond(N)675 on_cond(N) ::= . {N = NULL;}
676
677 %type jointype {GdaSqlSelectJoinType}
jointype(J)678 jointype(J) ::= COMMA. {J = GDA_SQL_SELECT_JOIN_CROSS;}
jointype(J)679 jointype(J) ::= JOIN. {J = GDA_SQL_SELECT_JOIN_INNER;}
jointype(J)680 jointype(J) ::= CROSS JOIN. {J = GDA_SQL_SELECT_JOIN_CROSS;}
jointype(J)681 jointype(J) ::= INNER JOIN. {J = GDA_SQL_SELECT_JOIN_INNER;}
jointype(J)682 jointype(J) ::= NATURAL JOIN. {J = GDA_SQL_SELECT_JOIN_NATURAL;}
jointype(J)683 jointype(J) ::= LEFT JOIN. {J = GDA_SQL_SELECT_JOIN_LEFT;}
jointype(J)684 jointype(J) ::= LEFT OUTER JOIN. {J = GDA_SQL_SELECT_JOIN_LEFT;}
jointype(J)685 jointype(J) ::= RIGHT JOIN. {J = GDA_SQL_SELECT_JOIN_RIGHT;}
jointype(J)686 jointype(J) ::= RIGHT OUTER JOIN. {J = GDA_SQL_SELECT_JOIN_RIGHT;}
jointype(J)687 jointype(J) ::= FULL JOIN. {J = GDA_SQL_SELECT_JOIN_FULL;}
jointype(J)688 jointype(J) ::= FULL OUTER JOIN. {J = GDA_SQL_SELECT_JOIN_FULL;}
689
690
691 %type seltarget {GdaSqlSelectTarget *}
692 %destructor seltarget {gda_sql_select_target_free ($$);}
seltarget(T)693 seltarget(T) ::= fullname(F) as(A). {T = gda_sql_select_target_new (NULL);
694 gda_sql_select_target_take_alias (T, A);
695 gda_sql_select_target_take_table_name (T, F);
696 }
seltarget(T)697 seltarget(T) ::= fullname(F) ID(A). {T = gda_sql_select_target_new (NULL);
698 gda_sql_select_target_take_alias (T, A);
699 gda_sql_select_target_take_table_name (T, F);
700 }
seltarget(T)701 seltarget(T) ::= LP compound(S) RP as(A). {T = gda_sql_select_target_new (NULL);
702 gda_sql_select_target_take_alias (T, A);
703 gda_sql_select_target_take_select (T, S);
704 }
705
706 %type selcollist {GSList *}
707 %destructor selcollist {g_slist_foreach ($$, (GFunc) gda_sql_select_field_free, NULL); g_slist_free ($$);}
708
709 %type sclp {GSList *}
710 %destructor sclp {g_slist_foreach ($$, (GFunc) gda_sql_select_field_free, NULL); g_slist_free ($$);}
sclp(A)711 sclp(A) ::= selcollist(X) COMMA. {A = X;}
sclp(A)712 sclp(A) ::= . {A = NULL;}
713
selcollist(L)714 selcollist(L) ::= sclp(E) expr(X) as(A). {GdaSqlSelectField *field;
715 field = gda_sql_select_field_new (NULL);
716 gda_sql_select_field_take_expr (field, X);
717 gda_sql_select_field_take_alias (field, A);
718 L = g_slist_append (E, field);}
selcollist(L)719 selcollist(L) ::= sclp(E) starname(X). {GdaSqlSelectField *field;
720 field = gda_sql_select_field_new (NULL);
721 gda_sql_select_field_take_star_value (field, X);
722 L = g_slist_append (E, field);}
723
starname(S)724 starname(S) ::= STAR(X). {S = X;}
starname(A)725 starname(A) ::= nm(S) DOT STAR(X). {gchar *str;
726 str = g_strdup_printf ("%s.%s", g_value_get_string (S), g_value_get_string (X));
727 A = g_new0 (GValue, 1);
728 g_value_init (A, G_TYPE_STRING);
729 g_value_take_string (A, str);
730 g_value_reset (S); g_free (S);
731 g_value_reset (X); g_free (X);
732 }
733
starname(A)734 starname(A) ::= nm(C) DOT nm(S) DOT STAR(X). {gchar *str;
735 str = g_strdup_printf ("%s.%s.%s", g_value_get_string (C),
736 g_value_get_string (S), g_value_get_string (X));
737 A = g_new0 (GValue, 1);
738 g_value_init (A, G_TYPE_STRING);
739 g_value_take_string (A, str);
740 g_value_reset (C); g_free (C);
741 g_value_reset (S); g_free (S);
742 g_value_reset (X); g_free (X);
743 }
744
as(A)745 as(A) ::= AS fullname(F). {A = F;}
as(A)746 as(A) ::= AS value(F). {A = F;}
as(A)747 as(A) ::= . {A = NULL;}
748
749 %type distinct {Distinct *}
750 %destructor distinct {if ($$) {if ($$->expr) gda_sql_expr_free ($$->expr); g_free ($$);}}
distinct(E)751 distinct(E) ::= . {E = NULL;}
distinct(E)752 distinct(E) ::= ALL. {E = NULL;}
distinct(E)753 distinct(E) ::= DISTINCT. {E = g_new0 (Distinct, 1); E->distinct = TRUE;}
distinct(E)754 distinct(E) ::= DISTINCT ON expr(X). [OR] {E = g_new0 (Distinct, 1); E->distinct = TRUE; E->expr = X;}
755
756 // Non empty list of expressions
757 %type rnexprlist {GSList *}
758 %destructor rnexprlist {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_expr_free, NULL); g_slist_free ($$);}}
rnexprlist(L)759 rnexprlist(L) ::= rnexprlist(E) COMMA expr(X). {L = g_slist_prepend (E, X);}
rnexprlist(L)760 rnexprlist(L) ::= expr(E). {L = g_slist_append (NULL, E);}
761
762 // List of expressions
763 %type rexprlist {GSList *}
764 %destructor rexprlist {if ($$) {g_slist_foreach ($$, (GFunc) gda_sql_expr_free, NULL); g_slist_free ($$);}}
rexprlist(L)765 rexprlist(L) ::= . {L = NULL;}
rexprlist(L)766 rexprlist(L) ::= rexprlist(E) COMMA expr(X). {L = g_slist_prepend (E, X);}
rexprlist(L)767 rexprlist(L) ::= expr(E). {L = g_slist_append (NULL, E);}
768
769 // A single expression
770 %type expr {GdaSqlExpr *}
771 %destructor expr {gda_sql_expr_free ($$);}
expr(E)772 expr(E) ::= pvalue(V). {E = V;}
expr(E)773 expr(E) ::= value(V). {E = gda_sql_expr_new (NULL); E->value = V;}
expr(E)774 expr(E) ::= LP expr(X) RP. {E = X;}
expr(E)775 expr(E) ::= fullname(V). {E = gda_sql_expr_new (NULL); E->value = V;}
expr(E)776 expr(E) ::= fullname(V) LP rexprlist(A) RP. {GdaSqlFunction *func;
777 E = gda_sql_expr_new (NULL);
778 func = gda_sql_function_new (GDA_SQL_ANY_PART (E));
779 gda_sql_function_take_name (func, V);
780 gda_sql_function_take_args_list (func, g_slist_reverse (A));
781 E->func = func;}
expr(E)782 expr(E) ::= fullname(V) LP compound(S) RP. {GdaSqlFunction *func;
783 GdaSqlExpr *expr;
784 E = gda_sql_expr_new (NULL);
785 func = gda_sql_function_new (GDA_SQL_ANY_PART (E));
786 gda_sql_function_take_name (func, V);
787 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (func));
788 gda_sql_expr_take_select (expr, S);
789 gda_sql_function_take_args_list (func, g_slist_prepend (NULL, expr));
790 E->func = func;}
expr(E)791 expr(E) ::= fullname(V) LP starname(A) RP. {GdaSqlFunction *func;
792 GdaSqlExpr *expr;
793 E = gda_sql_expr_new (NULL);
794 func = gda_sql_function_new (GDA_SQL_ANY_PART (E));
795 gda_sql_function_take_name (func, V);
796 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (func));
797 expr->value = A;
798 gda_sql_function_take_args_list (func, g_slist_prepend (NULL, expr));
799 E->func = func;}
expr(E)800 expr(E) ::= CAST LP expr(A) AS fullname(T) RP. {E = A;
801 A->cast_as = g_value_dup_string (T);
802 g_value_reset (T);
803 g_free (T);}
expr(E)804 expr(E) ::= expr(A) PGCAST fullname(T). {E = A;
805 A->cast_as = g_value_dup_string (T);
806 g_value_reset (T);
807 g_free (T);}
808
809 expr(C) ::= expr(L) PLUS|MINUS(O) expr(R). {C = compose_multiple_expr (string_to_op_type (O), L, R);}
expr(C)810 expr(C) ::= expr(L) STAR expr(R). {C = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_STAR, L, R);}
811 expr(C) ::= expr(L) SLASH|REM(O) expr(R). {C = create_two_expr (string_to_op_type (O), L, R);}
812 expr(C) ::= expr(L) BITAND|BITOR(O) expr(R). {C = create_two_expr (string_to_op_type (O), L, R);}
813
expr(C)814 expr(C) ::= MINUS expr(X). [UMINUS] {C = create_uni_expr (GDA_SQL_OPERATOR_TYPE_MINUS, X);}
expr(C)815 expr(C) ::= PLUS expr(X). [UPLUS] {C = create_uni_expr (GDA_SQL_OPERATOR_TYPE_PLUS, X);}
816
expr(C)817 expr(C) ::= expr(L) AND expr(R). {C = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_AND, L, R);}
expr(C)818 expr(C) ::= expr(L) OR expr(R). {C = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_OR, L, R);}
expr(C)819 expr(C) ::= expr(L) CONCAT expr(R). {C = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_CONCAT, L, R);}
820
821 expr(C) ::= expr(L) GT|LEQ|GEQ|LT(O) expr(R). {C = create_two_expr (string_to_op_type (O), L, R);}
822 expr(C) ::= expr(L) DIFF|EQ(O) expr(R). {C = create_two_expr (string_to_op_type (O), L, R);}
expr(C)823 expr(C) ::= expr(L) LIKE expr(R). {C = create_two_expr (GDA_SQL_OPERATOR_TYPE_LIKE, L, R);}
expr(C)824 expr(C) ::= expr(L) NOTLIKE expr(R). {C = create_two_expr (GDA_SQL_OPERATOR_TYPE_NOTLIKE, L, R);}
825 expr(C) ::= expr(L) REGEXP|REGEXP_CI|NOT_REGEXP|NOT_REGEXP_CI|SIMILAR(O) expr(R). {C = create_two_expr (string_to_op_type (O), L, R);}
expr(C)826 expr(C) ::= expr(L) BETWEEN expr(R) AND expr(E). {GdaSqlOperation *cond;
827 C = gda_sql_expr_new (NULL);
828 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (C));
829 C->cond = cond;
830 cond->operator_type = GDA_SQL_OPERATOR_TYPE_BETWEEN;
831 cond->operands = g_slist_append (NULL, L);
832 GDA_SQL_ANY_PART (L)->parent = GDA_SQL_ANY_PART (cond);
833 cond->operands = g_slist_append (cond->operands, R);
834 GDA_SQL_ANY_PART (R)->parent = GDA_SQL_ANY_PART (cond);
835 cond->operands = g_slist_append (cond->operands, E);
836 GDA_SQL_ANY_PART (E)->parent = GDA_SQL_ANY_PART (cond);
837 }
838
expr(C)839 expr(C) ::= expr(L) NOT BETWEEN expr(R) AND expr(E). {GdaSqlOperation *cond;
840 GdaSqlExpr *expr;
841 expr = gda_sql_expr_new (NULL);
842 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (expr));
843 expr->cond = cond;
844 cond->operator_type = GDA_SQL_OPERATOR_TYPE_BETWEEN;
845 cond->operands = g_slist_append (NULL, L);
846 GDA_SQL_ANY_PART (L)->parent = GDA_SQL_ANY_PART (cond);
847 cond->operands = g_slist_append (cond->operands, R);
848 GDA_SQL_ANY_PART (R)->parent = GDA_SQL_ANY_PART (cond);
849 cond->operands = g_slist_append (cond->operands, E);
850 GDA_SQL_ANY_PART (E)->parent = GDA_SQL_ANY_PART (cond);
851
852 C = gda_sql_expr_new (NULL);
853 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (C));
854 C->cond = cond;
855 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOT;
856 cond->operands = g_slist_prepend (NULL, expr);
857 GDA_SQL_ANY_PART (expr)->parent = GDA_SQL_ANY_PART (cond);
858 }
859
expr(C)860 expr(C) ::= NOT expr(R). {C = create_uni_expr (GDA_SQL_OPERATOR_TYPE_NOT, R);}
expr(C)861 expr(C) ::= BITNOT expr(R). {C = create_uni_expr (GDA_SQL_OPERATOR_TYPE_BITNOT, R);}
expr(C)862 expr(C) ::= expr(R) uni_op(O) . {C = create_uni_expr (O, R);}
863
expr(C)864 expr(C) ::= expr(L) IS expr(R). {C = create_two_expr (GDA_SQL_OPERATOR_TYPE_IS, L, R);}
expr(E)865 expr(E) ::= LP compound(S) RP. {E = gda_sql_expr_new (NULL); gda_sql_expr_take_select (E, S);}
expr(E)866 expr(E) ::= expr(R) IN LP rexprlist(L) RP. {GdaSqlOperation *cond;
867 GSList *list;
868 E = gda_sql_expr_new (NULL);
869 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (E));
870 E->cond = cond;
871 cond->operator_type = GDA_SQL_OPERATOR_TYPE_IN;
872 cond->operands = g_slist_prepend (g_slist_reverse (L), R);
873 for (list = cond->operands; list; list = list->next)
874 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (cond);
875 }
expr(E)876 expr(E) ::= expr(R) IN LP compound(S) RP. {GdaSqlOperation *cond;
877 GdaSqlExpr *expr;
878 E = gda_sql_expr_new (NULL);
879 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (E));
880 E->cond = cond;
881 cond->operator_type = GDA_SQL_OPERATOR_TYPE_IN;
882
883 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
884 gda_sql_expr_take_select (expr, S);
885 cond->operands = g_slist_prepend (NULL, expr);
886 cond->operands = g_slist_prepend (cond->operands, R);
887 GDA_SQL_ANY_PART (R)->parent = GDA_SQL_ANY_PART (cond);
888 }
expr(E)889 expr(E) ::= expr(R) NOT IN LP rexprlist(L) RP. {GdaSqlOperation *cond;
890 GSList *list;
891 E = gda_sql_expr_new (NULL);
892 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (E));
893 E->cond = cond;
894 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOTIN;
895 cond->operands = g_slist_prepend (g_slist_reverse (L), R);
896 for (list = cond->operands; list; list = list->next)
897 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (cond);
898 }
expr(E)899 expr(E) ::= expr(R) NOT IN LP compound(S) RP. {GdaSqlOperation *cond;
900 GdaSqlExpr *expr;
901 E = gda_sql_expr_new (NULL);
902 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (E));
903 E->cond = cond;
904 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOTIN;
905
906 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
907 gda_sql_expr_take_select (expr, S);
908 cond->operands = g_slist_prepend (NULL, expr);
909 cond->operands = g_slist_prepend (cond->operands, R);
910 GDA_SQL_ANY_PART (R)->parent = GDA_SQL_ANY_PART (cond);
911 }
expr(A)912 expr(A) ::= CASE case_operand(X) case_exprlist(Y) case_else(Z) END. {
913 GdaSqlCase *sc;
914 GSList *list;
915 A = gda_sql_expr_new (NULL);
916 sc = gda_sql_case_new (GDA_SQL_ANY_PART (A));
917 sc->base_expr = X;
918 sc->else_expr = Z;
919 sc->when_expr_list = Y.when_list;
920 sc->then_expr_list = Y.then_list;
921 A->case_s = sc;
922 for (list = sc->when_expr_list; list; list = list->next)
923 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (sc);
924 for (list = sc->then_expr_list; list; list = list->next)
925 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (sc);
926 }
927
928 %type case_operand {GdaSqlExpr*}
929 %destructor case_operand {gda_sql_expr_free ($$);}
case_operand(A)930 case_operand(A) ::= expr(X). {A = X;}
case_operand(A)931 case_operand(A) ::= . {A = NULL;}
932
933 %type case_exprlist {CaseBody}
934 %destructor case_exprlist {g_slist_foreach ($$.when_list, (GFunc) gda_sql_expr_free, NULL); g_slist_free ($$.when_list);
935 g_slist_foreach ($$.then_list, (GFunc) gda_sql_expr_free, NULL); g_slist_free ($$.then_list);}
936
case_exprlist(A)937 case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). {
938 A.when_list = g_slist_append (X.when_list, Y);
939 A.then_list = g_slist_append (X.then_list, Z);
940 }
case_exprlist(A)941 case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). {
942 A.when_list = g_slist_prepend (NULL, Y);
943 A.then_list = g_slist_prepend (NULL, Z);
944 }
945
946 %type case_else {GdaSqlExpr*}
947 %destructor case_else {gda_sql_expr_free ($$);}
case_else(A)948 case_else(A) ::= ELSE expr(X). {A = X;}
case_else(A)949 case_else(A) ::= . {A = NULL;}
950
951 %type uni_op {GdaSqlOperatorType}
uni_op(O)952 uni_op(O) ::= ISNULL. {O = GDA_SQL_OPERATOR_TYPE_ISNULL;}
uni_op(O)953 uni_op(O) ::= IS NOTNULL. {O = GDA_SQL_OPERATOR_TYPE_ISNOTNULL;}
954
955
956 // Values: for all constants (G_TYPE_STRING GValue)
value(V)957 value(V) ::= NULL. {V = NULL;}
value(V)958 value(V) ::= STRING(S). {V = S;}
959 //value(V) ::= TEXTUAL(T). {V = T;}
value(V)960 value(V) ::= INTEGER(I). {V = I;}
value(V)961 value(V) ::= FLOAT(F). {V = F;}
962
963 // pvalue: values which are parameters (GdaSqlExpr)
964 %type pvalue {GdaSqlExpr *}
965 %destructor pvalue {gda_sql_expr_free ($$);}
pvalue(E)966 pvalue(E) ::= UNSPECVAL LSBRACKET paramspec(P) RSBRACKET. {E = gda_sql_expr_new (NULL); E->param_spec = P;}
pvalue(E)967 pvalue(E) ::= value(V) LSBRACKET paramspec(P) RSBRACKET. {E = gda_sql_expr_new (NULL); E->value = V; E->param_spec = P;}
pvalue(E)968 pvalue(E) ::= SIMPLEPARAM(S). {E = gda_sql_expr_new (NULL); E->param_spec = gda_sql_param_spec_new (S);}
969
970 // paramspec: parameter's specifications
971 %type paramspec {GdaSqlParamSpec *}
972 %destructor paramspec {gda_sql_param_spec_free ($$);}
paramspec(P)973 paramspec(P) ::= . {P = NULL;}
paramspec(P)974 paramspec(P) ::= paramspec(E) PNAME(N). {if (!E) P = gda_sql_param_spec_new (NULL); else P = E;
975 gda_sql_param_spec_take_name (P, N);}
paramspec(P)976 paramspec(P) ::= paramspec(E) PDESCR(N). {if (!E) P = gda_sql_param_spec_new (NULL); else P = E;
977 gda_sql_param_spec_take_descr (P, N);}
paramspec(P)978 paramspec(P) ::= paramspec(E) PTYPE(N). {if (!E) P = gda_sql_param_spec_new (NULL); else P = E;
979 gda_sql_param_spec_take_type (P, N);}
paramspec(P)980 paramspec(P) ::= paramspec(E) PNULLOK(N). {if (!E) P = gda_sql_param_spec_new (NULL); else P = E;
981 gda_sql_param_spec_take_nullok (P, N);}
982
983 // The name of a column or table can be any of the following:
984 //
nm(A)985 nm(A) ::= JOIN(X). {A = X;}
nm(A)986 nm(A) ::= ID(X). {A = X;}
nm(A)987 nm(A) ::= TEXTUAL(X). {A = X;}
988
989 // Fully qualified name
fullname(A)990 fullname(A) ::= nm(X). {A = X;}
fullname(A)991 fullname(A) ::= nm(S) DOT nm(X). {gchar *str;
992 str = g_strdup_printf ("%s.%s", g_value_get_string (S), g_value_get_string (X));
993 A = g_new0 (GValue, 1);
994 g_value_init (A, G_TYPE_STRING);
995 g_value_take_string (A, str);
996 g_value_reset (S); g_free (S);
997 g_value_reset (X); g_free (X);
998 }
999
fullname(A)1000 fullname(A) ::= nm(C) DOT nm(S) DOT nm(X). {gchar *str;
1001 str = g_strdup_printf ("%s.%s.%s", g_value_get_string (C),
1002 g_value_get_string (S), g_value_get_string (X));
1003 A = g_new0 (GValue, 1);
1004 g_value_init (A, G_TYPE_STRING);
1005 g_value_take_string (A, str);
1006 g_value_reset (C); g_free (C);
1007 g_value_reset (S); g_free (S);
1008 g_value_reset (X); g_free (X);
1009 }
1010