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