Line data Source code
1 : /* header */
2 : /* src/interfaces/ecpg/preproc/ecpg.header */
3 :
4 : /* Copyright comment */
5 : %{
6 : #include "postgres_fe.h"
7 :
8 : #include "preproc_extern.h"
9 : #include "preproc.h"
10 : #include "ecpg_config.h"
11 : #include <unistd.h>
12 :
13 : /* silence -Wmissing-variable-declarations */
14 : extern int base_yychar;
15 : extern int base_yynerrs;
16 :
17 :
18 : /*
19 : * The %name-prefix option below will make bison call base_yylex, but we
20 : * really want it to call filtered_base_yylex (see parser.c).
21 : */
22 : #define base_yylex filtered_base_yylex
23 :
24 : /*
25 : * This is only here so the string gets into the POT. Bison uses it
26 : * internally.
27 : */
28 : #define bison_gettext_dummy gettext_noop("syntax error")
29 :
30 : /*
31 : * Variables containing simple states.
32 : */
33 : int struct_level = 0;
34 : int braces_open; /* brace level counter */
35 : char *current_function;
36 : int ecpg_internal_var = 0;
37 : char *connection = NULL;
38 : char *input_filename = NULL;
39 :
40 : static int FoundInto = 0;
41 : static int initializer = 0;
42 : static int pacounter = 1;
43 : static struct this_type actual_type[STRUCT_DEPTH];
44 : static char *actual_startline[STRUCT_DEPTH];
45 : static int varchar_counter = 1;
46 : static int bytea_counter = 1;
47 :
48 : /*
49 : * We temporarily store struct members here while parsing struct declarations.
50 : * The struct_member_list (at a given nesting depth) is constructed while
51 : * scanning the fields within "struct { .... }", but we can't remove it upon
52 : * seeing the right brace. It's kept around and copied into the variables
53 : * or typedefs that follow, in order to handle cases like
54 : * "struct foo { ... } foovar1, foovar2;". We recycle the storage only
55 : * upon closing the current nesting level or starting the next struct
56 : * declaration within the same nesting level.
57 : * For cases like "struct foo foovar1, foovar2;", we copy the saved struct
58 : * field list for the typedef or struct tag into the struct_member_list
59 : * global variable, and then copy it again to the newly-declared variables.
60 : */
61 : struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = {NULL};
62 :
63 : /* also store struct type so we can do a sizeof() later */
64 : static char *ECPGstruct_sizeof = NULL;
65 :
66 : /* for forward declarations we have to store some data as well */
67 : static char *forward_name = NULL;
68 :
69 : struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, NULL, {NULL}, 0};
70 : struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};
71 :
72 : static struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, NULL, {NULL}, 0};
73 :
74 : static bool check_declared_list(const char *name);
75 : static void update_connection(const char *newconn);
76 :
77 :
78 : /*
79 : * "Location tracking" support. We commandeer Bison's location tracking
80 : * mechanism to manage the output string for productions that ordinarily would
81 : * return a <str> result. This allows the majority of those productions to
82 : * have default semantic actions, reducing the size of the parser, and also
83 : * greatly reducing its compilation time on some versions of clang.
84 : *
85 : * To do this, we make YYLTYPE be a pointer to a malloc'd string, and then
86 : * merge the location strings of the input tokens in the default YYLLOC
87 : * computation. Productions that are okay with the standard merge need not
88 : * do anything more; otherwise, they can override it by assigning to @$.
89 : */
90 : #define YYLLOC_DEFAULT(Current, Rhs, N) yylloc_default(&(Current), Rhs, N)
91 :
92 : static void
93 243646 : yylloc_default(YYLTYPE *target, YYLTYPE *rhs, int N)
94 : {
95 243646 : if (N > 1)
96 : {
97 : /* Concatenate non-empty inputs with one space between them */
98 : char *result,
99 : *ptr;
100 61876 : size_t needed = 0;
101 :
102 205874 : for (int i = 1; i <= N; i++)
103 : {
104 143998 : size_t thislen = strlen(rhs[i]);
105 :
106 143998 : if (needed > 0 && thislen > 0)
107 20480 : needed++;
108 143998 : needed += thislen;
109 : }
110 61876 : result = (char *) loc_alloc(needed + 1);
111 61876 : ptr = result;
112 205874 : for (int i = 1; i <= N; i++)
113 : {
114 143998 : size_t thislen = strlen(rhs[i]);
115 :
116 143998 : if (ptr > result && thislen > 0)
117 20480 : *ptr++ = ' ';
118 143998 : memcpy(ptr, rhs[i], thislen);
119 143998 : ptr += thislen;
120 : }
121 61876 : *ptr = '\0';
122 61876 : *target = result;
123 : }
124 181770 : else if (N == 1)
125 : {
126 : /* Just re-use the single input */
127 170524 : *target = rhs[1];
128 : }
129 : else
130 : {
131 : /* No need to allocate any space */
132 11246 : *target = "";
133 : }
134 243646 : }
135 :
136 : /* and the rest */
137 : static char *
138 246 : create_questionmarks(const char *name, bool array)
139 : {
140 246 : struct variable *p = find_variable(name);
141 : int count;
142 246 : char *result = "";
143 :
144 : /*
145 : * In case we have a struct, we have to print as many "?" as there are
146 : * attributes in the struct
147 : *
148 : * An array is only allowed together with an element argument
149 : *
150 : * This is essentially only used for inserts, but using a struct as input
151 : * parameter is an error anywhere else so we don't have to worry here.
152 : */
153 :
154 246 : if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct))
155 0 : {
156 : struct ECPGstruct_member *m;
157 :
158 0 : if (p->type->type == ECPGt_struct)
159 0 : m = p->type->u.members;
160 : else
161 0 : m = p->type->u.element->u.members;
162 :
163 0 : for (count = 0; m != NULL; m = m->next, count++);
164 : }
165 : else
166 246 : count = 1;
167 :
168 492 : for (; count > 0; count--)
169 : {
170 : char buf[32];
171 :
172 246 : snprintf(buf, sizeof(buf), "$%d", pacounter++);
173 246 : result = cat_str(3, result, buf, " , ");
174 : }
175 :
176 : /* remove the trailing " ," */
177 246 : result[strlen(result) - 3] = '\0';
178 246 : return result;
179 : }
180 :
181 : static char *
182 74 : adjust_outofscope_cursor_vars(struct cursor *cur)
183 : {
184 : /*
185 : * Informix accepts DECLARE with variables that are out of scope when OPEN
186 : * is called. For instance you can DECLARE a cursor in one function, and
187 : * OPEN/FETCH/CLOSE it in another functions. This is very useful for e.g.
188 : * event-driver programming, but may also lead to dangerous programming.
189 : * The limitation when this is allowed and doesn't cause problems have to
190 : * be documented, like the allocated variables must not be realloc()'ed.
191 : *
192 : * We have to change the variables to our own struct and just store the
193 : * pointer instead of the variable. Do it only for local variables, not
194 : * for globals.
195 : */
196 74 : char *result = "";
197 : int insert;
198 :
199 222 : for (insert = 1; insert >= 0; insert--)
200 : {
201 : struct arguments *list;
202 : struct arguments *ptr;
203 148 : struct arguments *newlist = NULL;
204 : struct variable *newvar,
205 : *newind;
206 :
207 148 : list = (insert ? cur->argsinsert : cur->argsresult);
208 :
209 214 : for (ptr = list; ptr != NULL; ptr = ptr->next)
210 : {
211 : char var_text[20];
212 : char *original_var;
213 66 : bool skip_set_var = false;
214 66 : bool var_ptr = false;
215 :
216 : /* change variable name to "ECPGget_var(<counter>)" */
217 66 : original_var = ptr->variable->name;
218 66 : snprintf(var_text, sizeof(var_text), "%d))", ecpg_internal_var);
219 :
220 : /* Don't emit ECPGset_var() calls for global variables */
221 66 : if (ptr->variable->brace_level == 0)
222 : {
223 40 : newvar = ptr->variable;
224 40 : skip_set_var = true;
225 : }
226 26 : else if ((ptr->variable->type->type == ECPGt_char_variable)
227 0 : && (strncmp(ptr->variable->name, "ECPGprepared_statement", strlen("ECPGprepared_statement")) == 0))
228 : {
229 0 : newvar = ptr->variable;
230 0 : skip_set_var = true;
231 : }
232 26 : else if ((ptr->variable->type->type != ECPGt_varchar
233 24 : && ptr->variable->type->type != ECPGt_char
234 14 : && ptr->variable->type->type != ECPGt_unsigned_char
235 14 : && ptr->variable->type->type != ECPGt_string
236 14 : && ptr->variable->type->type != ECPGt_bytea)
237 12 : && atoi(ptr->variable->type->size) > 1)
238 : {
239 0 : newvar = new_variable(cat_str(4, "(",
240 0 : ecpg_type_name(ptr->variable->type->u.element->type),
241 : " *)(ECPGget_var(",
242 : var_text),
243 0 : ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,
244 : "1",
245 0 : ptr->variable->type->u.element->counter),
246 0 : ptr->variable->type->size),
247 : 0);
248 : }
249 26 : else if ((ptr->variable->type->type == ECPGt_varchar
250 24 : || ptr->variable->type->type == ECPGt_char
251 14 : || ptr->variable->type->type == ECPGt_unsigned_char
252 14 : || ptr->variable->type->type == ECPGt_string
253 14 : || ptr->variable->type->type == ECPGt_bytea)
254 14 : && atoi(ptr->variable->type->size) > 1)
255 : {
256 6 : newvar = new_variable(cat_str(4, "(",
257 6 : ecpg_type_name(ptr->variable->type->type),
258 : " *)(ECPGget_var(",
259 : var_text),
260 6 : ECPGmake_simple_type(ptr->variable->type->type,
261 6 : ptr->variable->type->size,
262 6 : ptr->variable->type->counter),
263 : 0);
264 6 : if (ptr->variable->type->type == ECPGt_varchar ||
265 4 : ptr->variable->type->type == ECPGt_bytea)
266 4 : var_ptr = true;
267 : }
268 20 : else if (ptr->variable->type->type == ECPGt_struct
269 20 : || ptr->variable->type->type == ECPGt_union)
270 : {
271 0 : newvar = new_variable(cat_str(5, "(*(",
272 0 : ptr->variable->type->type_name,
273 : " *)(ECPGget_var(",
274 : var_text,
275 : ")"),
276 0 : ECPGmake_struct_type(ptr->variable->type->u.members,
277 0 : ptr->variable->type->type,
278 0 : ptr->variable->type->type_name,
279 0 : ptr->variable->type->struct_sizeof),
280 : 0);
281 0 : var_ptr = true;
282 : }
283 20 : else if (ptr->variable->type->type == ECPGt_array)
284 : {
285 2 : if (ptr->variable->type->u.element->type == ECPGt_struct
286 0 : || ptr->variable->type->u.element->type == ECPGt_union)
287 : {
288 2 : newvar = new_variable(cat_str(5, "(*(",
289 2 : ptr->variable->type->u.element->type_name,
290 : " *)(ECPGget_var(",
291 : var_text,
292 : ")"),
293 2 : ECPGmake_struct_type(ptr->variable->type->u.element->u.members,
294 2 : ptr->variable->type->u.element->type,
295 2 : ptr->variable->type->u.element->type_name,
296 2 : ptr->variable->type->u.element->struct_sizeof),
297 : 0);
298 : }
299 : else
300 : {
301 0 : newvar = new_variable(cat_str(4, "(",
302 0 : ecpg_type_name(ptr->variable->type->u.element->type),
303 : " *)(ECPGget_var(",
304 : var_text),
305 0 : ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,
306 0 : ptr->variable->type->u.element->size,
307 0 : ptr->variable->type->u.element->counter),
308 0 : ptr->variable->type->size),
309 : 0);
310 0 : var_ptr = true;
311 : }
312 : }
313 : else
314 : {
315 18 : newvar = new_variable(cat_str(4, "*(",
316 18 : ecpg_type_name(ptr->variable->type->type),
317 : " *)(ECPGget_var(",
318 : var_text),
319 18 : ECPGmake_simple_type(ptr->variable->type->type,
320 18 : ptr->variable->type->size,
321 18 : ptr->variable->type->counter),
322 : 0);
323 18 : var_ptr = true;
324 : }
325 :
326 : /*
327 : * create call to "ECPGset_var(<counter>, <connection>, <pointer>.
328 : * <line number>)"
329 : */
330 66 : if (!skip_set_var)
331 : {
332 26 : snprintf(var_text, sizeof(var_text), "%d, %s",
333 : ecpg_internal_var++, var_ptr ? "&(" : "(");
334 26 : result = cat_str(5, result, "ECPGset_var(",
335 : var_text, original_var,
336 : "), __LINE__);\n");
337 : }
338 :
339 : /*
340 : * now the indicator if there is one and it's not a global
341 : * variable
342 : */
343 66 : if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0))
344 : {
345 64 : newind = ptr->indicator;
346 : }
347 : else
348 : {
349 : /* change variable name to "ECPGget_var(<counter>)" */
350 2 : original_var = ptr->indicator->name;
351 2 : snprintf(var_text, sizeof(var_text), "%d))", ecpg_internal_var);
352 2 : var_ptr = false;
353 :
354 2 : if (ptr->indicator->type->type == ECPGt_struct
355 2 : || ptr->indicator->type->type == ECPGt_union)
356 : {
357 0 : newind = new_variable(cat_str(5, "(*(",
358 0 : ptr->indicator->type->type_name,
359 : " *)(ECPGget_var(",
360 : var_text,
361 : ")"),
362 0 : ECPGmake_struct_type(ptr->indicator->type->u.members,
363 0 : ptr->indicator->type->type,
364 0 : ptr->indicator->type->type_name,
365 0 : ptr->indicator->type->struct_sizeof),
366 : 0);
367 0 : var_ptr = true;
368 : }
369 2 : else if (ptr->indicator->type->type == ECPGt_array)
370 : {
371 2 : if (ptr->indicator->type->u.element->type == ECPGt_struct
372 0 : || ptr->indicator->type->u.element->type == ECPGt_union)
373 : {
374 2 : newind = new_variable(cat_str(5, "(*(",
375 2 : ptr->indicator->type->u.element->type_name,
376 : " *)(ECPGget_var(",
377 : var_text,
378 : ")"),
379 2 : ECPGmake_struct_type(ptr->indicator->type->u.element->u.members,
380 2 : ptr->indicator->type->u.element->type,
381 2 : ptr->indicator->type->u.element->type_name,
382 2 : ptr->indicator->type->u.element->struct_sizeof),
383 : 0);
384 : }
385 : else
386 : {
387 0 : newind = new_variable(cat_str(4, "(",
388 0 : ecpg_type_name(ptr->indicator->type->u.element->type),
389 : " *)(ECPGget_var(",
390 : var_text),
391 0 : ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type,
392 0 : ptr->indicator->type->u.element->size,
393 0 : ptr->indicator->type->u.element->counter),
394 0 : ptr->indicator->type->size),
395 : 0);
396 0 : var_ptr = true;
397 : }
398 : }
399 0 : else if (atoi(ptr->indicator->type->size) > 1)
400 : {
401 0 : newind = new_variable(cat_str(4, "(",
402 0 : ecpg_type_name(ptr->indicator->type->type),
403 : " *)(ECPGget_var(",
404 : var_text),
405 0 : ECPGmake_simple_type(ptr->indicator->type->type,
406 0 : ptr->indicator->type->size,
407 0 : ptr->variable->type->counter),
408 : 0);
409 : }
410 : else
411 : {
412 0 : newind = new_variable(cat_str(4, "*(",
413 0 : ecpg_type_name(ptr->indicator->type->type),
414 : " *)(ECPGget_var(",
415 : var_text),
416 0 : ECPGmake_simple_type(ptr->indicator->type->type,
417 0 : ptr->indicator->type->size,
418 0 : ptr->variable->type->counter),
419 : 0);
420 0 : var_ptr = true;
421 : }
422 :
423 : /*
424 : * create call to "ECPGset_var(<counter>, <pointer>. <line
425 : * number>)"
426 : */
427 2 : snprintf(var_text, sizeof(var_text), "%d, %s",
428 : ecpg_internal_var++, var_ptr ? "&(" : "(");
429 2 : result = cat_str(5, result, "ECPGset_var(",
430 : var_text, original_var,
431 : "), __LINE__);\n");
432 : }
433 :
434 66 : add_variable_to_tail(&newlist, newvar, newind);
435 : }
436 :
437 148 : if (insert)
438 74 : cur->argsinsert_oos = newlist;
439 : else
440 74 : cur->argsresult_oos = newlist;
441 : }
442 :
443 74 : return result;
444 : }
445 :
446 : /* This tests whether the cursor was declared and opened in the same function. */
447 : #define SAMEFUNC(cur) \
448 : ((cur->function == NULL) || \
449 : (cur->function != NULL && current_function != NULL && \
450 : strcmp(cur->function, current_function) == 0))
451 :
452 : static struct cursor *
453 202 : add_additional_variables(const char *name, bool insert)
454 : {
455 : struct cursor *ptr;
456 : struct arguments *p;
457 202 : int (*strcmp_fn) (const char *, const char *) = ((name[0] == ':' || name[0] == '"') ? strcmp : pg_strcasecmp);
458 :
459 216 : for (ptr = cur; ptr != NULL; ptr = ptr->next)
460 : {
461 216 : if (strcmp_fn(ptr->name, name) == 0)
462 202 : break;
463 : }
464 :
465 202 : if (ptr == NULL)
466 : {
467 0 : mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name);
468 0 : return NULL;
469 : }
470 :
471 202 : if (insert)
472 : {
473 : /*
474 : * add all those input variables that were given earlier
475 : *
476 : * note that we have to append here but have to keep the existing
477 : * order
478 : */
479 136 : for (p = (SAMEFUNC(ptr) ? ptr->argsinsert : ptr->argsinsert_oos); p; p = p->next)
480 60 : add_variable_to_tail(&argsinsert, p->variable, p->indicator);
481 : }
482 :
483 : /* add all those output variables that were given earlier */
484 238 : for (p = (SAMEFUNC(ptr) ? ptr->argsresult : ptr->argsresult_oos); p; p = p->next)
485 36 : add_variable_to_tail(&argsresult, p->variable, p->indicator);
486 :
487 202 : return ptr;
488 : }
489 :
490 : static void
491 44 : add_typedef(const char *name, const char *dimension, const char *length,
492 : enum ECPGttype type_enum,
493 : const char *type_dimension, const char *type_index,
494 : int initializer, int array)
495 : {
496 : /* add entry to list */
497 : struct typedefs *ptr,
498 : *this;
499 :
500 44 : if ((type_enum == ECPGt_struct ||
501 20 : type_enum == ECPGt_union) &&
502 : initializer == 1)
503 0 : mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition");
504 44 : else if (INFORMIX_MODE && strcmp(name, "string") == 0)
505 0 : mmerror(PARSE_ERROR, ET_ERROR, "type name \"string\" is reserved in Informix mode");
506 : else
507 : {
508 116 : for (ptr = types; ptr != NULL; ptr = ptr->next)
509 : {
510 72 : if (strcmp(name, ptr->name) == 0)
511 : /* re-definition is a bug */
512 0 : mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name);
513 : }
514 44 : adjust_array(type_enum, &dimension, &length,
515 : type_dimension, type_index, array, true);
516 :
517 44 : this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
518 :
519 : /* initial definition */
520 44 : this->next = types;
521 44 : this->name = mm_strdup(name);
522 44 : this->brace_level = braces_open;
523 44 : this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
524 44 : this->type->type_storage = NULL;
525 44 : this->type->type_enum = type_enum;
526 44 : this->type->type_str = mm_strdup(name);
527 44 : this->type->type_dimension = mm_strdup(dimension); /* dimension of array */
528 44 : this->type->type_index = mm_strdup(length); /* length of string */
529 44 : this->type->type_sizeof = ECPGstruct_sizeof ? mm_strdup(ECPGstruct_sizeof) : NULL;
530 28 : this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ?
531 72 : ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL;
532 :
533 44 : if (type_enum != ECPGt_varchar &&
534 40 : type_enum != ECPGt_bytea &&
535 28 : type_enum != ECPGt_char &&
536 28 : type_enum != ECPGt_unsigned_char &&
537 28 : type_enum != ECPGt_string &&
538 28 : atoi(this->type->type_index) >= 0)
539 0 : mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
540 :
541 44 : types = this;
542 : }
543 44 : }
544 :
545 : /*
546 : * check an SQL identifier is declared or not.
547 : * If it is already declared, the global variable
548 : * connection will be changed to the related connection.
549 : */
550 : static bool
551 328 : check_declared_list(const char *name)
552 : {
553 328 : struct declared_list *ptr = NULL;
554 :
555 376 : for (ptr = g_declared_list; ptr != NULL; ptr = ptr->next)
556 : {
557 62 : if (!ptr->connection)
558 36 : continue;
559 26 : if (strcmp(name, ptr->name) == 0)
560 : {
561 14 : if (connection && strcmp(ptr->connection, connection) != 0)
562 0 : mmerror(PARSE_ERROR, ET_WARNING, "connection %s is overwritten with %s by DECLARE statement %s", connection, ptr->connection, name);
563 14 : update_connection(ptr->connection);
564 14 : return true;
565 : }
566 : }
567 314 : return false;
568 : }
569 :
570 : /*
571 : * If newconn isn't NULL, update the global "connection" variable to that;
572 : * otherwise do nothing.
573 : */
574 : static void
575 212 : update_connection(const char *newconn)
576 : {
577 212 : if (newconn)
578 : {
579 92 : free(connection);
580 92 : connection = mm_strdup(newconn);
581 : }
582 212 : }
583 : %}
584 :
585 : %expect 0
586 : %name-prefix="base_yy"
587 : %locations
588 :
589 : %union {
590 : double dval;
591 : char *str;
592 : int ival;
593 : struct when action;
594 : struct index index;
595 : int tagname;
596 : struct this_type type;
597 : enum ECPGttype type_enum;
598 : enum ECPGdtype dtype_enum;
599 : struct fetch_desc descriptor;
600 : struct su_symbol struct_union;
601 : struct prep prep;
602 : struct exec exec;
603 : struct describe describe;
604 : }
605 : /* tokens */
606 : /* src/interfaces/ecpg/preproc/ecpg.tokens */
607 :
608 : /* special embedded SQL tokens */
609 : %token SQL_ALLOCATE SQL_AUTOCOMMIT SQL_BOOL SQL_BREAK
610 : SQL_CARDINALITY SQL_CONNECT
611 : SQL_COUNT
612 : SQL_DATETIME_INTERVAL_CODE
613 : SQL_DATETIME_INTERVAL_PRECISION SQL_DESCRIBE
614 : SQL_DESCRIPTOR SQL_DISCONNECT SQL_FOUND
615 : SQL_FREE SQL_GET SQL_GO SQL_GOTO SQL_IDENTIFIED
616 : SQL_INDICATOR SQL_KEY_MEMBER SQL_LENGTH
617 : SQL_LONG SQL_NULLABLE SQL_OCTET_LENGTH
618 : SQL_OPEN SQL_OUTPUT SQL_REFERENCE
619 : SQL_RETURNED_LENGTH SQL_RETURNED_OCTET_LENGTH SQL_SCALE
620 : SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQLERROR
621 : SQL_SQLPRINT SQL_SQLWARNING SQL_START SQL_STOP
622 : SQL_STRUCT SQL_UNSIGNED SQL_VAR SQL_WHENEVER
623 :
624 : /* C tokens */
625 : %token S_ADD S_AND S_ANYTHING S_AUTO S_CONST S_DEC S_DIV
626 : S_DOTPOINT S_EQUAL S_EXTERN S_INC S_LSHIFT S_MEMPOINT
627 : S_MEMBER S_MOD S_MUL S_NEQUAL S_OR S_REGISTER S_RSHIFT
628 : S_STATIC S_SUB S_VOLATILE
629 : S_TYPEDEF
630 :
631 : %token CSTRING CVARIABLE CPP_LINE IP
632 : /* types */
633 : %type <prep> PrepareStmt
634 : %type <exec> ExecuteStmt
635 : %type <index> opt_array_bounds
636 : /* ecpgtype */
637 : /* src/interfaces/ecpg/preproc/ecpg.type */
638 : %type <struct_union> s_struct_union_symbol
639 :
640 : %type <descriptor> ECPGGetDescriptor
641 : %type <descriptor> ECPGSetDescriptor
642 :
643 : %type <type_enum> simple_type
644 : %type <type_enum> signed_type
645 : %type <type_enum> unsigned_type
646 :
647 : %type <dtype_enum> descriptor_item
648 : %type <dtype_enum> desc_header_item
649 :
650 : %type <type> var_type
651 :
652 : %type <action> action
653 :
654 : %type <describe> ECPGDescribe
655 : /* orig_tokens */
656 : %token IDENT UIDENT FCONST SCONST USCONST BCONST XCONST Op
657 : %token ICONST PARAM
658 : %token TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER
659 : %token LESS_EQUALS GREATER_EQUALS NOT_EQUALS
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 : %token ABORT_P ABSENT ABSOLUTE_P ACCESS ACTION ADD_P ADMIN AFTER
668 : AGGREGATE ALL ALSO ALTER ALWAYS ANALYSE ANALYZE AND ANY ARRAY AS ASC
669 : ASENSITIVE ASSERTION ASSIGNMENT ASYMMETRIC ATOMIC AT ATTACH ATTRIBUTE AUTHORIZATION
670 : BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
671 : BOOLEAN_P BOTH BREADTH BY
672 : CACHE CALL CALLED CASCADE CASCADED CASE CAST CATALOG_P CHAIN CHAR_P
673 : CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
674 : CLUSTER COALESCE COLLATE COLLATION COLUMN COLUMNS COMMENT COMMENTS COMMIT
675 : COMMITTED COMPRESSION CONCURRENTLY CONDITIONAL CONFIGURATION CONFLICT
676 : CONNECTION CONSTRAINT CONSTRAINTS CONTENT_P CONTINUE_P CONVERSION_P COPY
677 : COST CREATE CROSS CSV CUBE CURRENT_P
678 : CURRENT_CATALOG CURRENT_DATE CURRENT_ROLE CURRENT_SCHEMA
679 : CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
680 : DATA_P DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
681 : DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS DEPENDS DEPTH DESC
682 : DETACH DICTIONARY DISABLE_P DISCARD DISTINCT DO DOCUMENT_P DOMAIN_P
683 : DOUBLE_P DROP
684 : EACH ELSE EMPTY_P ENABLE_P ENCODING ENCRYPTED END_P ENFORCED ENUM_P ERROR_P
685 : ESCAPE EVENT EXCEPT EXCLUDE EXCLUDING EXCLUSIVE EXECUTE EXISTS EXPLAIN
686 : EXPRESSION EXTENSION EXTERNAL EXTRACT
687 : FALSE_P FAMILY FETCH FILTER FINALIZE FIRST_P FLOAT_P FOLLOWING FOR
688 : FORCE FOREIGN FORMAT FORWARD FREEZE FROM FULL FUNCTION FUNCTIONS
689 : GENERATED GLOBAL GRANT GRANTED GREATEST GROUP_P GROUPING GROUPS
690 : HANDLER HAVING HEADER_P HOLD HOUR_P
691 : IDENTITY_P IF_P ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IMPORT_P IN_P INCLUDE
692 : INCLUDING INCREMENT INDENT INDEX INDEXES INHERIT INHERITS INITIALLY INLINE_P
693 : INNER_P INOUT INPUT_P INSENSITIVE INSERT INSTEAD INT_P INTEGER
694 : INTERSECT INTERVAL INTO INVOKER IS ISNULL ISOLATION
695 : JOIN JSON JSON_ARRAY JSON_ARRAYAGG JSON_EXISTS JSON_OBJECT JSON_OBJECTAGG
696 : JSON_QUERY JSON_SCALAR JSON_SERIALIZE JSON_TABLE JSON_VALUE
697 : KEEP KEY KEYS
698 : LABEL LANGUAGE LARGE_P LAST_P LATERAL_P
699 : LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL
700 : LOCALTIME LOCALTIMESTAMP LOCATION LOCK_P LOCKED LOGGED
701 : MAPPING MATCH MATCHED MATERIALIZED MAXVALUE MERGE MERGE_ACTION METHOD
702 : MINUTE_P MINVALUE MODE MONTH_P MOVE
703 : NAME_P NAMES NATIONAL NATURAL NCHAR NESTED NEW NEXT NFC NFD NFKC NFKD NO
704 : NONE NORMALIZE NORMALIZED
705 : NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF
706 : NULLS_P NUMERIC
707 : OBJECT_P OF OFF OFFSET OIDS OLD OMIT ON ONLY OPERATOR OPTION OPTIONS OR
708 : ORDER ORDINALITY OTHERS OUT_P OUTER_P
709 : OVER OVERLAPS OVERLAY OVERRIDING OWNED OWNER
710 : PARALLEL PARAMETER PARSER PARTIAL PARTITION PASSING PASSWORD PATH
711 : PERIOD PLACING PLAN PLANS POLICY
712 : POSITION PRECEDING PRECISION PRESERVE PREPARE PREPARED PRIMARY
713 : PRIOR PRIVILEGES PROCEDURAL PROCEDURE PROCEDURES PROGRAM PUBLICATION
714 : QUOTE QUOTES
715 : RANGE READ REAL REASSIGN RECURSIVE REF_P REFERENCES REFERENCING
716 : REFRESH REINDEX RELATIVE_P RELEASE RENAME REPEATABLE REPLACE REPLICA
717 : RESET RESTART RESTRICT RETURN RETURNING RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
718 : ROUTINE ROUTINES ROW ROWS RULE
719 : SAVEPOINT SCALAR SCHEMA SCHEMAS SCROLL SEARCH SECOND_P SECURITY SELECT
720 : SEQUENCE SEQUENCES
721 : SERIALIZABLE SERVER SESSION SESSION_USER SET SETS SETOF SHARE SHOW
722 : SIMILAR SIMPLE SKIP SMALLINT SNAPSHOT SOME SOURCE SQL_P STABLE STANDALONE_P
723 : START STATEMENT STATISTICS STDIN STDOUT STORAGE STORED STRICT_P STRING_P STRIP_P
724 : SUBSCRIPTION SUBSTRING SUPPORT SYMMETRIC SYSID SYSTEM_P SYSTEM_USER
725 : TABLE TABLES TABLESAMPLE TABLESPACE TARGET TEMP TEMPLATE TEMPORARY TEXT_P THEN
726 : TIES TIME TIMESTAMP TO TRAILING TRANSACTION TRANSFORM
727 : TREAT TRIGGER TRIM TRUE_P
728 : TRUNCATE TRUSTED TYPE_P TYPES_P
729 : UESCAPE UNBOUNDED UNCONDITIONAL UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN
730 : UNLISTEN UNLOGGED UNTIL UPDATE USER USING
731 : VACUUM VALID VALIDATE VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
732 : VERBOSE VERSION_P VIEW VIEWS VOLATILE
733 : WHEN WHERE WHITESPACE_P WINDOW WITH WITHIN WITHOUT WORK WRAPPER WRITE
734 : XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLEXISTS XMLFOREST XMLNAMESPACES
735 : XMLPARSE XMLPI XMLROOT XMLSERIALIZE XMLTABLE
736 : YEAR_P YES_P
737 : ZONE
738 :
739 :
740 :
741 :
742 :
743 :
744 :
745 :
746 :
747 :
748 :
749 : %token FORMAT_LA NOT_LA NULLS_LA WITH_LA WITHOUT_LA
750 :
751 :
752 :
753 :
754 :
755 :
756 :
757 : %token MODE_TYPE_NAME
758 : %token MODE_PLPGSQL_EXPR
759 : %token MODE_PLPGSQL_ASSIGN1
760 : %token MODE_PLPGSQL_ASSIGN2
761 : %token MODE_PLPGSQL_ASSIGN3
762 :
763 : %left UNION EXCEPT
764 : %left INTERSECT
765 : %left OR
766 : %left AND
767 : %right NOT
768 : %nonassoc IS ISNULL NOTNULL
769 : %nonassoc '<' '>' '=' LESS_EQUALS GREATER_EQUALS NOT_EQUALS
770 : %nonassoc BETWEEN IN_P LIKE ILIKE SIMILAR NOT_LA
771 : %nonassoc ESCAPE
772 :
773 :
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 :
782 :
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 :
807 :
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 : %nonassoc UNBOUNDED NESTED
819 : %nonassoc IDENT CSTRING PARTITION RANGE ROWS GROUPS PRECEDING FOLLOWING CUBE ROLLUP
820 : SET KEYS OBJECT_P SCALAR VALUE_P WITH WITHOUT PATH
821 : %left Op OPERATOR
822 : %left '+' '-'
823 : %left '*' '/' '%'
824 : %left '^'
825 :
826 : %left AT
827 : %left COLLATE
828 : %right UMINUS
829 : %left '[' ']'
830 : %left '(' ')'
831 : %left TYPECAST
832 : %left '.'
833 :
834 :
835 :
836 :
837 :
838 :
839 :
840 : %left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
841 : %%
842 : prog: statements;
843 : /* rules */
844 : toplevel_stmt:
845 : stmt
846 : | TransactionStmtLegacy
847 : {
848 16 : fprintf(base_yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", @1);
849 16 : whenever_action(2);
850 : }
851 : ;
852 :
853 :
854 : stmt:
855 : AlterEventTrigStmt
856 0 : { output_statement(@1, 0, ECPGst_normal); }
857 : | AlterCollationStmt
858 0 : { output_statement(@1, 0, ECPGst_normal); }
859 : | AlterDatabaseStmt
860 0 : { output_statement(@1, 0, ECPGst_normal); }
861 : | AlterDatabaseSetStmt
862 0 : { output_statement(@1, 0, ECPGst_normal); }
863 : | AlterDefaultPrivilegesStmt
864 0 : { output_statement(@1, 0, ECPGst_normal); }
865 : | AlterDomainStmt
866 0 : { output_statement(@1, 0, ECPGst_normal); }
867 : | AlterEnumStmt
868 0 : { output_statement(@1, 0, ECPGst_normal); }
869 : | AlterExtensionStmt
870 0 : { output_statement(@1, 0, ECPGst_normal); }
871 : | AlterExtensionContentsStmt
872 0 : { output_statement(@1, 0, ECPGst_normal); }
873 : | AlterFdwStmt
874 0 : { output_statement(@1, 0, ECPGst_normal); }
875 : | AlterForeignServerStmt
876 0 : { output_statement(@1, 0, ECPGst_normal); }
877 : | AlterFunctionStmt
878 0 : { output_statement(@1, 0, ECPGst_normal); }
879 : | AlterGroupStmt
880 0 : { output_statement(@1, 0, ECPGst_normal); }
881 : | AlterObjectDependsStmt
882 0 : { output_statement(@1, 0, ECPGst_normal); }
883 : | AlterObjectSchemaStmt
884 0 : { output_statement(@1, 0, ECPGst_normal); }
885 : | AlterOwnerStmt
886 0 : { output_statement(@1, 0, ECPGst_normal); }
887 : | AlterOperatorStmt
888 0 : { output_statement(@1, 0, ECPGst_normal); }
889 : | AlterTypeStmt
890 0 : { output_statement(@1, 0, ECPGst_normal); }
891 : | AlterPolicyStmt
892 0 : { output_statement(@1, 0, ECPGst_normal); }
893 : | AlterSeqStmt
894 0 : { output_statement(@1, 0, ECPGst_normal); }
895 : | AlterSystemStmt
896 0 : { output_statement(@1, 0, ECPGst_normal); }
897 : | AlterTableStmt
898 4 : { output_statement(@1, 0, ECPGst_normal); }
899 : | AlterTblSpcStmt
900 0 : { output_statement(@1, 0, ECPGst_normal); }
901 : | AlterCompositeTypeStmt
902 0 : { output_statement(@1, 0, ECPGst_normal); }
903 : | AlterPublicationStmt
904 0 : { output_statement(@1, 0, ECPGst_normal); }
905 : | AlterRoleSetStmt
906 0 : { output_statement(@1, 0, ECPGst_normal); }
907 : | AlterRoleStmt
908 6 : { output_statement(@1, 0, ECPGst_normal); }
909 : | AlterSubscriptionStmt
910 0 : { output_statement(@1, 0, ECPGst_normal); }
911 : | AlterStatsStmt
912 0 : { output_statement(@1, 0, ECPGst_normal); }
913 : | AlterTSConfigurationStmt
914 0 : { output_statement(@1, 0, ECPGst_normal); }
915 : | AlterTSDictionaryStmt
916 0 : { output_statement(@1, 0, ECPGst_normal); }
917 : | AlterUserMappingStmt
918 0 : { output_statement(@1, 0, ECPGst_normal); }
919 : | AnalyzeStmt
920 0 : { output_statement(@1, 0, ECPGst_normal); }
921 : | CallStmt
922 0 : { output_statement(@1, 0, ECPGst_normal); }
923 : | CheckPointStmt
924 0 : { output_statement(@1, 0, ECPGst_normal); }
925 : | ClosePortalStmt
926 : {
927 76 : if (INFORMIX_MODE)
928 : {
929 8 : if (pg_strcasecmp(@1 + strlen("close "), "database") == 0)
930 : {
931 4 : if (connection)
932 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CLOSE DATABASE statement");
933 :
934 4 : fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, \"CURRENT\");");
935 4 : whenever_action(2);
936 4 : break;
937 : }
938 : }
939 :
940 72 : output_statement(@1, 0, ECPGst_normal);
941 : }
942 : | ClusterStmt
943 0 : { output_statement(@1, 0, ECPGst_normal); }
944 : | CommentStmt
945 0 : { output_statement(@1, 0, ECPGst_normal); }
946 : | ConstraintsSetStmt
947 0 : { output_statement(@1, 0, ECPGst_normal); }
948 : | CopyStmt
949 2 : { output_statement(@1, 0, ECPGst_normal); }
950 : | CreateAmStmt
951 0 : { output_statement(@1, 0, ECPGst_normal); }
952 : | CreateAsStmt
953 4 : { output_statement(@1, 0, ECPGst_normal); }
954 : | CreateAssertionStmt
955 0 : { output_statement(@1, 0, ECPGst_normal); }
956 : | CreateCastStmt
957 0 : { output_statement(@1, 0, ECPGst_normal); }
958 : | CreateConversionStmt
959 0 : { output_statement(@1, 0, ECPGst_normal); }
960 : | CreateDomainStmt
961 0 : { output_statement(@1, 0, ECPGst_normal); }
962 : | CreateExtensionStmt
963 0 : { output_statement(@1, 0, ECPGst_normal); }
964 : | CreateFdwStmt
965 0 : { output_statement(@1, 0, ECPGst_normal); }
966 : | CreateForeignServerStmt
967 0 : { output_statement(@1, 0, ECPGst_normal); }
968 : | CreateForeignTableStmt
969 0 : { output_statement(@1, 0, ECPGst_normal); }
970 : | CreateFunctionStmt
971 2 : { output_statement(@1, 0, ECPGst_normal); }
972 : | CreateGroupStmt
973 0 : { output_statement(@1, 0, ECPGst_normal); }
974 : | CreateMatViewStmt
975 0 : { output_statement(@1, 0, ECPGst_normal); }
976 : | CreateOpClassStmt
977 0 : { output_statement(@1, 0, ECPGst_normal); }
978 : | CreateOpFamilyStmt
979 0 : { output_statement(@1, 0, ECPGst_normal); }
980 : | CreatePublicationStmt
981 0 : { output_statement(@1, 0, ECPGst_normal); }
982 : | AlterOpFamilyStmt
983 0 : { output_statement(@1, 0, ECPGst_normal); }
984 : | CreatePolicyStmt
985 0 : { output_statement(@1, 0, ECPGst_normal); }
986 : | CreatePLangStmt
987 0 : { output_statement(@1, 0, ECPGst_normal); }
988 : | CreateSchemaStmt
989 0 : { output_statement(@1, 0, ECPGst_normal); }
990 : | CreateSeqStmt
991 0 : { output_statement(@1, 0, ECPGst_normal); }
992 : | CreateStmt
993 100 : { output_statement(@1, 0, ECPGst_normal); }
994 : | CreateSubscriptionStmt
995 0 : { output_statement(@1, 0, ECPGst_normal); }
996 : | CreateStatsStmt
997 0 : { output_statement(@1, 0, ECPGst_normal); }
998 : | CreateTableSpaceStmt
999 0 : { output_statement(@1, 0, ECPGst_normal); }
1000 : | CreateTransformStmt
1001 0 : { output_statement(@1, 0, ECPGst_normal); }
1002 : | CreateTrigStmt
1003 2 : { output_statement(@1, 0, ECPGst_normal); }
1004 : | CreateEventTrigStmt
1005 0 : { output_statement(@1, 0, ECPGst_normal); }
1006 : | CreateRoleStmt
1007 0 : { output_statement(@1, 0, ECPGst_normal); }
1008 : | CreateUserStmt
1009 0 : { output_statement(@1, 0, ECPGst_normal); }
1010 : | CreateUserMappingStmt
1011 0 : { output_statement(@1, 0, ECPGst_normal); }
1012 : | CreatedbStmt
1013 0 : { output_statement(@1, 0, ECPGst_normal); }
1014 : | DeallocateStmt
1015 : {
1016 76 : output_deallocate_prepare_statement(@1);
1017 : }
1018 : | DeclareCursorStmt
1019 : {
1020 34 : output_simple_statement(@1, (strncmp(@1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0);
1021 : }
1022 : | DefineStmt
1023 0 : { output_statement(@1, 0, ECPGst_normal); }
1024 : | DeleteStmt
1025 4 : { output_statement(@1, 1, ECPGst_prepnormal); }
1026 : | DiscardStmt
1027 0 : { output_statement(@1, 1, ECPGst_normal); }
1028 : | DoStmt
1029 0 : { output_statement(@1, 0, ECPGst_normal); }
1030 : | DropCastStmt
1031 0 : { output_statement(@1, 0, ECPGst_normal); }
1032 : | DropOpClassStmt
1033 0 : { output_statement(@1, 0, ECPGst_normal); }
1034 : | DropOpFamilyStmt
1035 0 : { output_statement(@1, 0, ECPGst_normal); }
1036 : | DropOwnedStmt
1037 0 : { output_statement(@1, 0, ECPGst_normal); }
1038 : | DropStmt
1039 76 : { output_statement(@1, 0, ECPGst_normal); }
1040 : | DropSubscriptionStmt
1041 0 : { output_statement(@1, 0, ECPGst_normal); }
1042 : | DropTableSpaceStmt
1043 0 : { output_statement(@1, 0, ECPGst_normal); }
1044 : | DropTransformStmt
1045 0 : { output_statement(@1, 0, ECPGst_normal); }
1046 : | DropRoleStmt
1047 0 : { output_statement(@1, 0, ECPGst_normal); }
1048 : | DropUserMappingStmt
1049 0 : { output_statement(@1, 0, ECPGst_normal); }
1050 : | DropdbStmt
1051 0 : { output_statement(@1, 0, ECPGst_normal); }
1052 : | ExecuteStmt
1053 : {
1054 66 : check_declared_list($1.name);
1055 66 : if ($1.type == NULL || strlen($1.type) == 0)
1056 48 : output_statement($1.name, 1, ECPGst_execute);
1057 : else
1058 : {
1059 18 : if ($1.name[0] != '"')
1060 : /* case of char_variable */
1061 8 : add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
1062 : else
1063 : {
1064 : /* case of ecpg_ident or CSTRING */
1065 : char length[32];
1066 : char *str;
1067 :
1068 : /* Remove double quotes from name */
1069 10 : str = loc_strdup($1.name + 1);
1070 10 : str[strlen(str) - 1] = '\0';
1071 10 : snprintf(length, sizeof(length), "%zu", strlen(str));
1072 10 : add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
1073 : }
1074 18 : output_statement(cat_str(3, "execute", "$0", $1.type), 0, ECPGst_exec_with_exprlist);
1075 : }
1076 : }
1077 : | ExplainStmt
1078 0 : { output_statement(@1, 0, ECPGst_normal); }
1079 : | FetchStmt
1080 126 : { output_statement(@1, 1, ECPGst_normal); }
1081 : | GrantStmt
1082 0 : { output_statement(@1, 0, ECPGst_normal); }
1083 : | GrantRoleStmt
1084 0 : { output_statement(@1, 0, ECPGst_normal); }
1085 : | ImportForeignSchemaStmt
1086 0 : { output_statement(@1, 0, ECPGst_normal); }
1087 : | IndexStmt
1088 0 : { output_statement(@1, 0, ECPGst_normal); }
1089 : | InsertStmt
1090 224 : { output_statement(@1, 1, ECPGst_prepnormal); }
1091 : | ListenStmt
1092 0 : { output_statement(@1, 0, ECPGst_normal); }
1093 : | RefreshMatViewStmt
1094 0 : { output_statement(@1, 0, ECPGst_normal); }
1095 : | LoadStmt
1096 0 : { output_statement(@1, 0, ECPGst_normal); }
1097 : | LockStmt
1098 0 : { output_statement(@1, 0, ECPGst_normal); }
1099 : | MergeStmt
1100 0 : { output_statement(@1, 0, ECPGst_normal); }
1101 : | NotifyStmt
1102 0 : { output_statement(@1, 0, ECPGst_normal); }
1103 : | PrepareStmt
1104 : {
1105 106 : check_declared_list($1.name);
1106 106 : if ($1.type == NULL)
1107 94 : output_prepare_statement($1.name, $1.stmt);
1108 12 : else if (strlen($1.type) == 0)
1109 : {
1110 2 : char *stmt = cat_str(3, "\"", $1.stmt, "\"");
1111 :
1112 2 : output_prepare_statement($1.name, stmt);
1113 : }
1114 : else
1115 : {
1116 10 : if ($1.name[0] != '"')
1117 : /* case of char_variable */
1118 4 : add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
1119 : else
1120 : {
1121 : char length[32];
1122 : char *str;
1123 :
1124 : /* Remove double quotes from name */
1125 6 : str = loc_strdup($1.name + 1);
1126 6 : str[strlen(str) - 1] = '\0';
1127 6 : snprintf(length, sizeof(length), "%zu", strlen(str));
1128 6 : add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
1129 : }
1130 10 : output_statement(cat_str(5, "prepare", "$0", $1.type, "as", $1.stmt), 0, ECPGst_prepare);
1131 : }
1132 : }
1133 : | ReassignOwnedStmt
1134 0 : { output_statement(@1, 0, ECPGst_normal); }
1135 : | ReindexStmt
1136 0 : { output_statement(@1, 0, ECPGst_normal); }
1137 : | RemoveAggrStmt
1138 0 : { output_statement(@1, 0, ECPGst_normal); }
1139 : | RemoveFuncStmt
1140 2 : { output_statement(@1, 0, ECPGst_normal); }
1141 : | RemoveOperStmt
1142 0 : { output_statement(@1, 0, ECPGst_normal); }
1143 : | RenameStmt
1144 0 : { output_statement(@1, 0, ECPGst_normal); }
1145 : | RevokeStmt
1146 0 : { output_statement(@1, 0, ECPGst_normal); }
1147 : | RevokeRoleStmt
1148 0 : { output_statement(@1, 0, ECPGst_normal); }
1149 : | RuleStmt
1150 0 : { output_statement(@1, 0, ECPGst_normal); }
1151 : | SecLabelStmt
1152 0 : { output_statement(@1, 0, ECPGst_normal); }
1153 : | SelectStmt
1154 202 : { output_statement(@1, 1, ECPGst_prepnormal); }
1155 : | TransactionStmt
1156 : {
1157 158 : fprintf(base_yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", @1);
1158 158 : whenever_action(2);
1159 : }
1160 : | TruncateStmt
1161 44 : { output_statement(@1, 0, ECPGst_normal); }
1162 : | UnlistenStmt
1163 0 : { output_statement(@1, 0, ECPGst_normal); }
1164 : | UpdateStmt
1165 10 : { output_statement(@1, 1, ECPGst_prepnormal); }
1166 : | VacuumStmt
1167 0 : { output_statement(@1, 0, ECPGst_normal); }
1168 : | VariableResetStmt
1169 0 : { output_statement(@1, 0, ECPGst_normal); }
1170 : | VariableSetStmt
1171 46 : { output_statement(@1, 0, ECPGst_normal); }
1172 : | VariableShowStmt
1173 14 : { output_statement(@1, 0, ECPGst_normal); }
1174 : | ViewStmt
1175 0 : { output_statement(@1, 0, ECPGst_normal); }
1176 : | ECPGAllocateDescr
1177 : {
1178 36 : fprintf(base_yyout, "ECPGallocate_desc(__LINE__, %s);", @1);
1179 36 : whenever_action(0);
1180 : }
1181 : | ECPGConnect
1182 : {
1183 186 : if (connection)
1184 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CONNECT statement");
1185 :
1186 186 : fprintf(base_yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, @1, autocommit);
1187 186 : reset_variables();
1188 186 : whenever_action(2);
1189 : }
1190 : | ECPGDeclareStmt
1191 : {
1192 10 : output_simple_statement(@1, 0);
1193 : }
1194 : | ECPGCursorStmt
1195 : {
1196 40 : output_simple_statement(@1, (strncmp(@1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0);
1197 : }
1198 : | ECPGDeallocateDescr
1199 : {
1200 32 : fprintf(base_yyout, "ECPGdeallocate_desc(__LINE__, %s);", @1);
1201 32 : whenever_action(0);
1202 : }
1203 : | ECPGDeclare
1204 : {
1205 0 : output_simple_statement(@1, 0);
1206 : }
1207 : | ECPGDescribe
1208 : {
1209 42 : check_declared_list($1.stmt_name);
1210 :
1211 42 : fprintf(base_yyout, "{ ECPGdescribe(__LINE__, %d, %d, %s, %s,", compat, $1.input, connection ? connection : "NULL", $1.stmt_name);
1212 42 : dump_variables(argsresult, 1);
1213 42 : argsresult = NULL;
1214 42 : fputs("ECPGt_EORT);", base_yyout);
1215 42 : fprintf(base_yyout, "}");
1216 42 : output_line_number();
1217 : }
1218 : | ECPGDisconnect
1219 : {
1220 172 : if (connection)
1221 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DISCONNECT statement");
1222 :
1223 172 : fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, %s);",
1224 172 : @1 ? @1 : "\"CURRENT\"");
1225 172 : whenever_action(2);
1226 : }
1227 : | ECPGExecuteImmediateStmt
1228 : {
1229 14 : output_statement(@1, 0, ECPGst_exec_immediate);
1230 : }
1231 : | ECPGFree
1232 : {
1233 2 : const char *con = connection ? connection : "NULL";
1234 :
1235 2 : if (strcmp(@1, "all") == 0)
1236 0 : fprintf(base_yyout, "{ ECPGdeallocate_all(__LINE__, %d, %s);", compat, con);
1237 2 : else if (@1[0] == ':')
1238 0 : fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, %s);", compat, con, @1 + 1);
1239 : else
1240 2 : fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, \"%s\");", compat, con, @1);
1241 :
1242 2 : whenever_action(2);
1243 : }
1244 : | ECPGGetDescriptor
1245 : {
1246 62 : lookup_descriptor($1.name, connection);
1247 62 : output_get_descr($1.name, $1.str);
1248 : }
1249 : | ECPGGetDescriptorHeader
1250 : {
1251 22 : lookup_descriptor(@1, connection);
1252 22 : output_get_descr_header(@1);
1253 : }
1254 : | ECPGOpen
1255 : {
1256 : struct cursor *ptr;
1257 :
1258 76 : if ((ptr = add_additional_variables(@1, true)) != NULL)
1259 : {
1260 76 : free(connection);
1261 76 : connection = ptr->connection ? mm_strdup(ptr->connection) : NULL;
1262 76 : output_statement(ptr->command, 0, ECPGst_normal);
1263 76 : ptr->opened = true;
1264 : }
1265 : }
1266 : | ECPGSetAutocommit
1267 : {
1268 26 : fprintf(base_yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", @1, connection ? connection : "NULL");
1269 26 : whenever_action(2);
1270 : }
1271 : | ECPGSetConnection
1272 : {
1273 4 : if (connection)
1274 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in SET CONNECTION statement");
1275 :
1276 4 : fprintf(base_yyout, "{ ECPGsetconn(__LINE__, %s);", @1);
1277 4 : whenever_action(2);
1278 : }
1279 : | ECPGSetDescriptor
1280 : {
1281 22 : lookup_descriptor($1.name, connection);
1282 22 : output_set_descr($1.name, $1.str);
1283 : }
1284 : | ECPGSetDescriptorHeader
1285 : {
1286 2 : lookup_descriptor(@1, connection);
1287 2 : output_set_descr_header(@1);
1288 : }
1289 : | ECPGTypedef
1290 : {
1291 26 : if (connection)
1292 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in TYPE statement");
1293 :
1294 26 : fprintf(base_yyout, "%s", @1);
1295 26 : output_line_number();
1296 : }
1297 : | ECPGVar
1298 : {
1299 4 : if (connection)
1300 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in VAR statement");
1301 :
1302 4 : output_simple_statement(@1, 0);
1303 : }
1304 : | ECPGWhenever
1305 : {
1306 200 : if (connection)
1307 0 : mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in WHENEVER statement");
1308 :
1309 200 : output_simple_statement(@1, 0);
1310 : }
1311 : |
1312 : ;
1313 :
1314 :
1315 : opt_single_name:
1316 : ColId
1317 : |
1318 : ;
1319 :
1320 :
1321 : opt_qualified_name:
1322 : any_name
1323 : |
1324 : ;
1325 :
1326 :
1327 : opt_concurrently:
1328 : CONCURRENTLY
1329 : |
1330 : ;
1331 :
1332 :
1333 : opt_drop_behavior:
1334 : CASCADE
1335 : | RESTRICT
1336 : |
1337 : ;
1338 :
1339 :
1340 : CallStmt:
1341 : CALL func_application
1342 : ;
1343 :
1344 :
1345 : CreateRoleStmt:
1346 : CREATE ROLE RoleId opt_with OptRoleList
1347 : ;
1348 :
1349 :
1350 : opt_with:
1351 : WITH
1352 : | WITH_LA
1353 : |
1354 : ;
1355 :
1356 :
1357 : OptRoleList:
1358 : OptRoleList CreateOptRoleElem
1359 : |
1360 : ;
1361 :
1362 :
1363 : AlterOptRoleList:
1364 : AlterOptRoleList AlterOptRoleElem
1365 : |
1366 : ;
1367 :
1368 :
1369 : AlterOptRoleElem:
1370 : PASSWORD ecpg_sconst
1371 : | PASSWORD NULL_P
1372 : | ENCRYPTED PASSWORD ecpg_sconst
1373 : | UNENCRYPTED PASSWORD ecpg_sconst
1374 : {
1375 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
1376 : }
1377 : | INHERIT
1378 : | CONNECTION LIMIT SignedIconst
1379 : | VALID UNTIL ecpg_sconst
1380 : | USER role_list
1381 : | ecpg_ident
1382 : ;
1383 :
1384 :
1385 : CreateOptRoleElem:
1386 : AlterOptRoleElem
1387 : | SYSID Iconst
1388 : | ADMIN role_list
1389 : | ROLE role_list
1390 : | IN_P ROLE role_list
1391 : | IN_P GROUP_P role_list
1392 : ;
1393 :
1394 :
1395 : CreateUserStmt:
1396 : CREATE USER RoleId opt_with OptRoleList
1397 : ;
1398 :
1399 :
1400 : AlterRoleStmt:
1401 : ALTER ROLE RoleSpec opt_with AlterOptRoleList
1402 : | ALTER USER RoleSpec opt_with AlterOptRoleList
1403 : ;
1404 :
1405 :
1406 : opt_in_database:
1407 :
1408 : | IN_P DATABASE name
1409 : ;
1410 :
1411 :
1412 : AlterRoleSetStmt:
1413 : ALTER ROLE RoleSpec opt_in_database SetResetClause
1414 : | ALTER ROLE ALL opt_in_database SetResetClause
1415 : | ALTER USER RoleSpec opt_in_database SetResetClause
1416 : | ALTER USER ALL opt_in_database SetResetClause
1417 : ;
1418 :
1419 :
1420 : DropRoleStmt:
1421 : DROP ROLE role_list
1422 : | DROP ROLE IF_P EXISTS role_list
1423 : | DROP USER role_list
1424 : | DROP USER IF_P EXISTS role_list
1425 : | DROP GROUP_P role_list
1426 : | DROP GROUP_P IF_P EXISTS role_list
1427 : ;
1428 :
1429 :
1430 : CreateGroupStmt:
1431 : CREATE GROUP_P RoleId opt_with OptRoleList
1432 : ;
1433 :
1434 :
1435 : AlterGroupStmt:
1436 : ALTER GROUP_P RoleSpec add_drop USER role_list
1437 : ;
1438 :
1439 :
1440 : add_drop:
1441 : ADD_P
1442 : | DROP
1443 : ;
1444 :
1445 :
1446 : CreateSchemaStmt:
1447 : CREATE SCHEMA opt_single_name AUTHORIZATION RoleSpec OptSchemaEltList
1448 : | CREATE SCHEMA ColId OptSchemaEltList
1449 : | CREATE SCHEMA IF_P NOT EXISTS opt_single_name AUTHORIZATION RoleSpec OptSchemaEltList
1450 : | CREATE SCHEMA IF_P NOT EXISTS ColId OptSchemaEltList
1451 : ;
1452 :
1453 :
1454 : OptSchemaEltList:
1455 : OptSchemaEltList schema_stmt
1456 : |
1457 : ;
1458 :
1459 :
1460 : schema_stmt:
1461 : CreateStmt
1462 : | IndexStmt
1463 : | CreateSeqStmt
1464 : | CreateTrigStmt
1465 : | GrantStmt
1466 : | ViewStmt
1467 : ;
1468 :
1469 :
1470 : VariableSetStmt:
1471 : SET set_rest
1472 : | SET LOCAL set_rest
1473 : | SET SESSION set_rest
1474 : ;
1475 :
1476 :
1477 : set_rest:
1478 : TRANSACTION transaction_mode_list
1479 : | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
1480 : | set_rest_more
1481 : ;
1482 :
1483 :
1484 : generic_set:
1485 : var_name TO var_list
1486 : | var_name '=' var_list
1487 : | var_name TO DEFAULT
1488 : | var_name '=' DEFAULT
1489 : ;
1490 :
1491 :
1492 : set_rest_more:
1493 : generic_set
1494 : | var_name FROM CURRENT_P
1495 : | TIME ZONE zone_value
1496 : | CATALOG_P ecpg_sconst
1497 : {
1498 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
1499 : }
1500 : | SCHEMA ecpg_sconst
1501 : | NAMES opt_encoding
1502 : | ROLE NonReservedWord_or_Sconst
1503 : | SESSION AUTHORIZATION NonReservedWord_or_Sconst
1504 : | SESSION AUTHORIZATION DEFAULT
1505 : | XML_P OPTION document_or_content
1506 : | TRANSACTION SNAPSHOT ecpg_sconst
1507 : ;
1508 :
1509 :
1510 : var_name:
1511 : ECPGColId
1512 : | var_name '.' ColId
1513 : ;
1514 :
1515 :
1516 : var_list:
1517 : var_value
1518 : | var_list ',' var_value
1519 : ;
1520 :
1521 :
1522 : var_value:
1523 : opt_boolean_or_string
1524 : | NumericOnly
1525 : {
1526 2 : if (@1[0] == '$')
1527 2 : @$ = "$0";
1528 : }
1529 : ;
1530 :
1531 :
1532 : iso_level:
1533 : READ UNCOMMITTED
1534 : | READ COMMITTED
1535 : | REPEATABLE READ
1536 : | SERIALIZABLE
1537 : ;
1538 :
1539 :
1540 : opt_boolean_or_string:
1541 : TRUE_P
1542 : | FALSE_P
1543 : | ON
1544 : | NonReservedWord_or_Sconst
1545 : ;
1546 :
1547 :
1548 : zone_value:
1549 : ecpg_sconst
1550 : | ecpg_ident
1551 : | ConstInterval ecpg_sconst opt_interval
1552 : | ConstInterval '(' Iconst ')' ecpg_sconst
1553 : | NumericOnly
1554 : | DEFAULT
1555 : | LOCAL
1556 : ;
1557 :
1558 :
1559 : opt_encoding:
1560 : ecpg_sconst
1561 : | DEFAULT
1562 : |
1563 : ;
1564 :
1565 :
1566 : NonReservedWord_or_Sconst:
1567 : NonReservedWord
1568 : | ecpg_sconst
1569 : ;
1570 :
1571 :
1572 : VariableResetStmt:
1573 : RESET reset_rest
1574 : ;
1575 :
1576 :
1577 : reset_rest:
1578 : generic_reset
1579 : | TIME ZONE
1580 : | TRANSACTION ISOLATION LEVEL
1581 : | SESSION AUTHORIZATION
1582 : ;
1583 :
1584 :
1585 : generic_reset:
1586 : var_name
1587 : | ALL
1588 : ;
1589 :
1590 :
1591 : SetResetClause:
1592 : SET set_rest
1593 : | VariableResetStmt
1594 : ;
1595 :
1596 :
1597 : FunctionSetResetClause:
1598 : SET set_rest_more
1599 : | VariableResetStmt
1600 : ;
1601 :
1602 :
1603 : VariableShowStmt:
1604 : SHOW var_name ecpg_into
1605 : | SHOW TIME ZONE ecpg_into
1606 : | SHOW TRANSACTION ISOLATION LEVEL ecpg_into
1607 : | SHOW SESSION AUTHORIZATION ecpg_into
1608 : | SHOW ALL
1609 : {
1610 0 : mmerror(PARSE_ERROR, ET_ERROR, "SHOW ALL is not implemented");
1611 : }
1612 : ;
1613 :
1614 :
1615 : ConstraintsSetStmt:
1616 : SET CONSTRAINTS constraints_set_list constraints_set_mode
1617 : ;
1618 :
1619 :
1620 : constraints_set_list:
1621 : ALL
1622 : | qualified_name_list
1623 : ;
1624 :
1625 :
1626 : constraints_set_mode:
1627 : DEFERRED
1628 : | IMMEDIATE
1629 : ;
1630 :
1631 :
1632 : CheckPointStmt:
1633 : CHECKPOINT
1634 : ;
1635 :
1636 :
1637 : DiscardStmt:
1638 : DISCARD ALL
1639 : | DISCARD TEMP
1640 : | DISCARD TEMPORARY
1641 : | DISCARD PLANS
1642 : | DISCARD SEQUENCES
1643 : ;
1644 :
1645 :
1646 : AlterTableStmt:
1647 : ALTER TABLE relation_expr alter_table_cmds
1648 : | ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds
1649 : | ALTER TABLE relation_expr partition_cmd
1650 : | ALTER TABLE IF_P EXISTS relation_expr partition_cmd
1651 : | ALTER TABLE ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
1652 : | ALTER TABLE ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
1653 : | ALTER INDEX qualified_name alter_table_cmds
1654 : | ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds
1655 : | ALTER INDEX qualified_name index_partition_cmd
1656 : | ALTER INDEX ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
1657 : | ALTER INDEX ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
1658 : | ALTER SEQUENCE qualified_name alter_table_cmds
1659 : | ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds
1660 : | ALTER VIEW qualified_name alter_table_cmds
1661 : | ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds
1662 : | ALTER MATERIALIZED VIEW qualified_name alter_table_cmds
1663 : | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name alter_table_cmds
1664 : | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
1665 : | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
1666 : | ALTER FOREIGN TABLE relation_expr alter_table_cmds
1667 : | ALTER FOREIGN TABLE IF_P EXISTS relation_expr alter_table_cmds
1668 : ;
1669 :
1670 :
1671 : alter_table_cmds:
1672 : alter_table_cmd
1673 : | alter_table_cmds ',' alter_table_cmd
1674 : ;
1675 :
1676 :
1677 : partition_cmd:
1678 : ATTACH PARTITION qualified_name PartitionBoundSpec
1679 : | DETACH PARTITION qualified_name opt_concurrently
1680 : | DETACH PARTITION qualified_name FINALIZE
1681 : ;
1682 :
1683 :
1684 : index_partition_cmd:
1685 : ATTACH PARTITION qualified_name
1686 : ;
1687 :
1688 :
1689 : alter_table_cmd:
1690 : ADD_P columnDef
1691 : | ADD_P IF_P NOT EXISTS columnDef
1692 : | ADD_P COLUMN columnDef
1693 : | ADD_P COLUMN IF_P NOT EXISTS columnDef
1694 : | ALTER opt_column ColId alter_column_default
1695 : | ALTER opt_column ColId DROP NOT NULL_P
1696 : | ALTER opt_column ColId SET NOT NULL_P
1697 : | ALTER opt_column ColId SET EXPRESSION AS '(' a_expr ')'
1698 : | ALTER opt_column ColId DROP EXPRESSION
1699 : | ALTER opt_column ColId DROP EXPRESSION IF_P EXISTS
1700 : | ALTER opt_column ColId SET STATISTICS set_statistics_value
1701 : | ALTER opt_column Iconst SET STATISTICS set_statistics_value
1702 : | ALTER opt_column ColId SET reloptions
1703 : | ALTER opt_column ColId RESET reloptions
1704 : | ALTER opt_column ColId SET column_storage
1705 : | ALTER opt_column ColId SET column_compression
1706 : | ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
1707 : | ALTER opt_column ColId alter_identity_column_option_list
1708 : | ALTER opt_column ColId DROP IDENTITY_P
1709 : | ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS
1710 : | DROP opt_column IF_P EXISTS ColId opt_drop_behavior
1711 : | DROP opt_column ColId opt_drop_behavior
1712 : | ALTER opt_column ColId opt_set_data TYPE_P Typename opt_collate_clause alter_using
1713 : | ALTER opt_column ColId alter_generic_options
1714 : | ADD_P TableConstraint
1715 : | ALTER CONSTRAINT name ConstraintAttributeSpec
1716 : | VALIDATE CONSTRAINT name
1717 : | DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
1718 : | DROP CONSTRAINT name opt_drop_behavior
1719 : | SET WITHOUT OIDS
1720 : | CLUSTER ON name
1721 : | SET WITHOUT CLUSTER
1722 : | SET LOGGED
1723 : | SET UNLOGGED
1724 : | ENABLE_P TRIGGER name
1725 : | ENABLE_P ALWAYS TRIGGER name
1726 : | ENABLE_P REPLICA TRIGGER name
1727 : | ENABLE_P TRIGGER ALL
1728 : | ENABLE_P TRIGGER USER
1729 : | DISABLE_P TRIGGER name
1730 : | DISABLE_P TRIGGER ALL
1731 : | DISABLE_P TRIGGER USER
1732 : | ENABLE_P RULE name
1733 : | ENABLE_P ALWAYS RULE name
1734 : | ENABLE_P REPLICA RULE name
1735 : | DISABLE_P RULE name
1736 : | INHERIT qualified_name
1737 : | NO INHERIT qualified_name
1738 : | OF any_name
1739 : | NOT OF
1740 : | OWNER TO RoleSpec
1741 : | SET ACCESS METHOD set_access_method_name
1742 : | SET TABLESPACE name
1743 : | SET reloptions
1744 : | RESET reloptions
1745 : | REPLICA IDENTITY_P replica_identity
1746 : | ENABLE_P ROW LEVEL SECURITY
1747 : | DISABLE_P ROW LEVEL SECURITY
1748 : | FORCE ROW LEVEL SECURITY
1749 : | NO FORCE ROW LEVEL SECURITY
1750 : | alter_generic_options
1751 : ;
1752 :
1753 :
1754 : alter_column_default:
1755 : SET DEFAULT a_expr
1756 : | DROP DEFAULT
1757 : ;
1758 :
1759 :
1760 : opt_collate_clause:
1761 : COLLATE any_name
1762 : |
1763 : ;
1764 :
1765 :
1766 : alter_using:
1767 : USING a_expr
1768 : |
1769 : ;
1770 :
1771 :
1772 : replica_identity:
1773 : NOTHING
1774 : | FULL
1775 : | DEFAULT
1776 : | USING INDEX name
1777 : ;
1778 :
1779 :
1780 : reloptions:
1781 : '(' reloption_list ')'
1782 : ;
1783 :
1784 :
1785 : opt_reloptions:
1786 : WITH reloptions
1787 : |
1788 : ;
1789 :
1790 :
1791 : reloption_list:
1792 : reloption_elem
1793 : | reloption_list ',' reloption_elem
1794 : ;
1795 :
1796 :
1797 : reloption_elem:
1798 : ColLabel '=' def_arg
1799 : | ColLabel
1800 : | ColLabel '.' ColLabel '=' def_arg
1801 : | ColLabel '.' ColLabel
1802 : ;
1803 :
1804 :
1805 : alter_identity_column_option_list:
1806 : alter_identity_column_option
1807 : | alter_identity_column_option_list alter_identity_column_option
1808 : ;
1809 :
1810 :
1811 : alter_identity_column_option:
1812 : RESTART
1813 : | RESTART opt_with NumericOnly
1814 : | SET SeqOptElem
1815 : | SET GENERATED generated_when
1816 : ;
1817 :
1818 :
1819 : set_statistics_value:
1820 : SignedIconst
1821 : | DEFAULT
1822 : ;
1823 :
1824 :
1825 : set_access_method_name:
1826 : ColId
1827 : | DEFAULT
1828 : ;
1829 :
1830 :
1831 : PartitionBoundSpec:
1832 : FOR VALUES WITH '(' hash_partbound ')'
1833 : | FOR VALUES IN_P '(' expr_list ')'
1834 : | FOR VALUES FROM '(' expr_list ')' TO '(' expr_list ')'
1835 : | DEFAULT
1836 : ;
1837 :
1838 :
1839 : hash_partbound_elem:
1840 : NonReservedWord Iconst
1841 : ;
1842 :
1843 :
1844 : hash_partbound:
1845 : hash_partbound_elem
1846 : | hash_partbound ',' hash_partbound_elem
1847 : ;
1848 :
1849 :
1850 : AlterCompositeTypeStmt:
1851 : ALTER TYPE_P any_name alter_type_cmds
1852 : ;
1853 :
1854 :
1855 : alter_type_cmds:
1856 : alter_type_cmd
1857 : | alter_type_cmds ',' alter_type_cmd
1858 : ;
1859 :
1860 :
1861 : alter_type_cmd:
1862 : ADD_P ATTRIBUTE TableFuncElement opt_drop_behavior
1863 : | DROP ATTRIBUTE IF_P EXISTS ColId opt_drop_behavior
1864 : | DROP ATTRIBUTE ColId opt_drop_behavior
1865 : | ALTER ATTRIBUTE ColId opt_set_data TYPE_P Typename opt_collate_clause opt_drop_behavior
1866 : ;
1867 :
1868 :
1869 : ClosePortalStmt:
1870 : CLOSE cursor_name
1871 : {
1872 76 : const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
1873 76 : struct cursor *ptr = NULL;
1874 :
1875 80 : for (ptr = cur; ptr != NULL; ptr = ptr->next)
1876 : {
1877 76 : if (strcmp(@2, ptr->name) == 0)
1878 : {
1879 72 : update_connection(ptr->connection);
1880 72 : break;
1881 : }
1882 : }
1883 76 : @$ = cat2_str("close", cursor_marker);
1884 : }
1885 : | CLOSE ALL
1886 : ;
1887 :
1888 :
1889 : CopyStmt:
1890 : COPY opt_binary qualified_name opt_column_list copy_from opt_program copy_file_name copy_delimiter opt_with copy_options where_clause
1891 : {
1892 2 : if (strcmp(@5, "from") == 0 &&
1893 0 : (strcmp(@7, "stdin") == 0 || strcmp(@7, "stdout") == 0))
1894 0 : mmerror(PARSE_ERROR, ET_WARNING, "COPY FROM STDIN is not implemented");
1895 : }
1896 : | COPY '(' PreparableStmt ')' TO opt_program copy_file_name opt_with copy_options
1897 : ;
1898 :
1899 :
1900 : copy_from:
1901 : FROM
1902 : | TO
1903 : ;
1904 :
1905 :
1906 : opt_program:
1907 : PROGRAM
1908 : |
1909 : ;
1910 :
1911 :
1912 : copy_file_name:
1913 : ecpg_sconst
1914 : | STDIN
1915 : | STDOUT
1916 : ;
1917 :
1918 :
1919 : copy_options:
1920 : copy_opt_list
1921 : | '(' copy_generic_opt_list ')'
1922 : ;
1923 :
1924 :
1925 : copy_opt_list:
1926 : copy_opt_list copy_opt_item
1927 : |
1928 : ;
1929 :
1930 :
1931 : copy_opt_item:
1932 : BINARY
1933 : | FREEZE
1934 : | DELIMITER opt_as ecpg_sconst
1935 : | NULL_P opt_as ecpg_sconst
1936 : | CSV
1937 : | HEADER_P
1938 : | QUOTE opt_as ecpg_sconst
1939 : | ESCAPE opt_as ecpg_sconst
1940 : | FORCE QUOTE columnList
1941 : | FORCE QUOTE '*'
1942 : | FORCE NOT NULL_P columnList
1943 : | FORCE NOT NULL_P '*'
1944 : | FORCE NULL_P columnList
1945 : | FORCE NULL_P '*'
1946 : | ENCODING ecpg_sconst
1947 : ;
1948 :
1949 :
1950 : opt_binary:
1951 : BINARY
1952 : |
1953 : ;
1954 :
1955 :
1956 : copy_delimiter:
1957 : opt_using DELIMITERS ecpg_sconst
1958 : |
1959 : ;
1960 :
1961 :
1962 : opt_using:
1963 : USING
1964 : |
1965 : ;
1966 :
1967 :
1968 : copy_generic_opt_list:
1969 : copy_generic_opt_elem
1970 : | copy_generic_opt_list ',' copy_generic_opt_elem
1971 : ;
1972 :
1973 :
1974 : copy_generic_opt_elem:
1975 : ColLabel copy_generic_opt_arg
1976 : ;
1977 :
1978 :
1979 : copy_generic_opt_arg:
1980 : opt_boolean_or_string
1981 : | NumericOnly
1982 : | '*'
1983 : | DEFAULT
1984 : | '(' copy_generic_opt_arg_list ')'
1985 : |
1986 : ;
1987 :
1988 :
1989 : copy_generic_opt_arg_list:
1990 : copy_generic_opt_arg_list_item
1991 : | copy_generic_opt_arg_list ',' copy_generic_opt_arg_list_item
1992 : ;
1993 :
1994 :
1995 : copy_generic_opt_arg_list_item:
1996 : opt_boolean_or_string
1997 : ;
1998 :
1999 :
2000 : CreateStmt:
2001 : CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2002 : | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2003 : | CREATE OptTemp TABLE qualified_name OF any_name OptTypedTableElementList OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2004 : | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name OF any_name OptTypedTableElementList OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2005 : | CREATE OptTemp TABLE qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2006 : | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
2007 : ;
2008 :
2009 :
2010 : OptTemp:
2011 : TEMPORARY
2012 : | TEMP
2013 : | LOCAL TEMPORARY
2014 : | LOCAL TEMP
2015 : | GLOBAL TEMPORARY
2016 : | GLOBAL TEMP
2017 : | UNLOGGED
2018 : |
2019 : ;
2020 :
2021 :
2022 : OptTableElementList:
2023 : TableElementList
2024 : |
2025 : ;
2026 :
2027 :
2028 : OptTypedTableElementList:
2029 : '(' TypedTableElementList ')'
2030 : |
2031 : ;
2032 :
2033 :
2034 : TableElementList:
2035 : TableElement
2036 : | TableElementList ',' TableElement
2037 : ;
2038 :
2039 :
2040 : TypedTableElementList:
2041 : TypedTableElement
2042 : | TypedTableElementList ',' TypedTableElement
2043 : ;
2044 :
2045 :
2046 : TableElement:
2047 : columnDef
2048 : | TableLikeClause
2049 : | TableConstraint
2050 : ;
2051 :
2052 :
2053 : TypedTableElement:
2054 : columnOptions
2055 : | TableConstraint
2056 : ;
2057 :
2058 :
2059 : columnDef:
2060 : ColId Typename opt_column_storage opt_column_compression create_generic_options ColQualList
2061 : ;
2062 :
2063 :
2064 : columnOptions:
2065 : ColId ColQualList
2066 : | ColId WITH OPTIONS ColQualList
2067 : ;
2068 :
2069 :
2070 : column_compression:
2071 : COMPRESSION ColId
2072 : | COMPRESSION DEFAULT
2073 : ;
2074 :
2075 :
2076 : opt_column_compression:
2077 : column_compression
2078 : |
2079 : ;
2080 :
2081 :
2082 : column_storage:
2083 : STORAGE ColId
2084 : | STORAGE DEFAULT
2085 : ;
2086 :
2087 :
2088 : opt_column_storage:
2089 : column_storage
2090 : |
2091 : ;
2092 :
2093 :
2094 : ColQualList:
2095 : ColQualList ColConstraint
2096 : |
2097 : ;
2098 :
2099 :
2100 : ColConstraint:
2101 : CONSTRAINT name ColConstraintElem
2102 : | ColConstraintElem
2103 : | ConstraintAttr
2104 : | COLLATE any_name
2105 : ;
2106 :
2107 :
2108 : ColConstraintElem:
2109 : NOT NULL_P opt_no_inherit
2110 : | NULL_P
2111 : | UNIQUE opt_unique_null_treatment opt_definition OptConsTableSpace
2112 : | PRIMARY KEY opt_definition OptConsTableSpace
2113 : | CHECK '(' a_expr ')' opt_no_inherit
2114 : | DEFAULT b_expr
2115 : | GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
2116 : | GENERATED generated_when AS '(' a_expr ')' STORED
2117 : | REFERENCES qualified_name opt_column_list key_match key_actions
2118 : ;
2119 :
2120 :
2121 : opt_unique_null_treatment:
2122 : NULLS_P DISTINCT
2123 : | NULLS_P NOT DISTINCT
2124 : |
2125 : ;
2126 :
2127 :
2128 : generated_when:
2129 : ALWAYS
2130 : | BY DEFAULT
2131 : ;
2132 :
2133 :
2134 : ConstraintAttr:
2135 : DEFERRABLE
2136 : | NOT DEFERRABLE
2137 : | INITIALLY DEFERRED
2138 : | INITIALLY IMMEDIATE
2139 : | ENFORCED
2140 : | NOT ENFORCED
2141 : ;
2142 :
2143 :
2144 : TableLikeClause:
2145 : LIKE qualified_name TableLikeOptionList
2146 : ;
2147 :
2148 :
2149 : TableLikeOptionList:
2150 : TableLikeOptionList INCLUDING TableLikeOption
2151 : | TableLikeOptionList EXCLUDING TableLikeOption
2152 : |
2153 : ;
2154 :
2155 :
2156 : TableLikeOption:
2157 : COMMENTS
2158 : | COMPRESSION
2159 : | CONSTRAINTS
2160 : | DEFAULTS
2161 : | IDENTITY_P
2162 : | GENERATED
2163 : | INDEXES
2164 : | STATISTICS
2165 : | STORAGE
2166 : | ALL
2167 : ;
2168 :
2169 :
2170 : TableConstraint:
2171 : CONSTRAINT name ConstraintElem
2172 : | ConstraintElem
2173 : ;
2174 :
2175 :
2176 : ConstraintElem:
2177 : CHECK '(' a_expr ')' ConstraintAttributeSpec
2178 : | NOT NULL_P ColId ConstraintAttributeSpec
2179 : | UNIQUE opt_unique_null_treatment '(' columnList opt_without_overlaps ')' opt_c_include opt_definition OptConsTableSpace ConstraintAttributeSpec
2180 : | UNIQUE ExistingIndex ConstraintAttributeSpec
2181 : | PRIMARY KEY '(' columnList opt_without_overlaps ')' opt_c_include opt_definition OptConsTableSpace ConstraintAttributeSpec
2182 : | PRIMARY KEY ExistingIndex ConstraintAttributeSpec
2183 : | EXCLUDE access_method_clause '(' ExclusionConstraintList ')' opt_c_include opt_definition OptConsTableSpace OptWhereClause ConstraintAttributeSpec
2184 : | FOREIGN KEY '(' columnList optionalPeriodName ')' REFERENCES qualified_name opt_column_and_period_list key_match key_actions ConstraintAttributeSpec
2185 : ;
2186 :
2187 :
2188 : DomainConstraint:
2189 : CONSTRAINT name DomainConstraintElem
2190 : | DomainConstraintElem
2191 : ;
2192 :
2193 :
2194 : DomainConstraintElem:
2195 : CHECK '(' a_expr ')' ConstraintAttributeSpec
2196 : | NOT NULL_P ConstraintAttributeSpec
2197 : ;
2198 :
2199 :
2200 : opt_no_inherit:
2201 : NO INHERIT
2202 : |
2203 : ;
2204 :
2205 :
2206 : opt_without_overlaps:
2207 : WITHOUT OVERLAPS
2208 : |
2209 : ;
2210 :
2211 :
2212 : opt_column_list:
2213 : '(' columnList ')'
2214 : |
2215 : ;
2216 :
2217 :
2218 : columnList:
2219 : columnElem
2220 : | columnList ',' columnElem
2221 : ;
2222 :
2223 :
2224 : optionalPeriodName:
2225 : ',' PERIOD columnElem
2226 : |
2227 : ;
2228 :
2229 :
2230 : opt_column_and_period_list:
2231 : '(' columnList optionalPeriodName ')'
2232 : |
2233 : ;
2234 :
2235 :
2236 : columnElem:
2237 : ColId
2238 : ;
2239 :
2240 :
2241 : opt_c_include:
2242 : INCLUDE '(' columnList ')'
2243 : |
2244 : ;
2245 :
2246 :
2247 : key_match:
2248 : MATCH FULL
2249 : | MATCH PARTIAL
2250 : {
2251 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
2252 : }
2253 : | MATCH SIMPLE
2254 : |
2255 : ;
2256 :
2257 :
2258 : ExclusionConstraintList:
2259 : ExclusionConstraintElem
2260 : | ExclusionConstraintList ',' ExclusionConstraintElem
2261 : ;
2262 :
2263 :
2264 : ExclusionConstraintElem:
2265 : index_elem WITH any_operator
2266 : | index_elem WITH OPERATOR '(' any_operator ')'
2267 : ;
2268 :
2269 :
2270 : OptWhereClause:
2271 : WHERE '(' a_expr ')'
2272 : |
2273 : ;
2274 :
2275 :
2276 : key_actions:
2277 : key_update
2278 : | key_delete
2279 : | key_update key_delete
2280 : | key_delete key_update
2281 : |
2282 : ;
2283 :
2284 :
2285 : key_update:
2286 : ON UPDATE key_action
2287 : ;
2288 :
2289 :
2290 : key_delete:
2291 : ON DELETE_P key_action
2292 : ;
2293 :
2294 :
2295 : key_action:
2296 : NO ACTION
2297 : | RESTRICT
2298 : | CASCADE
2299 : | SET NULL_P opt_column_list
2300 : | SET DEFAULT opt_column_list
2301 : ;
2302 :
2303 :
2304 : OptInherit:
2305 : INHERITS '(' qualified_name_list ')'
2306 : |
2307 : ;
2308 :
2309 :
2310 : OptPartitionSpec:
2311 : PartitionSpec
2312 : |
2313 : ;
2314 :
2315 :
2316 : PartitionSpec:
2317 : PARTITION BY ColId '(' part_params ')'
2318 : ;
2319 :
2320 :
2321 : part_params:
2322 : part_elem
2323 : | part_params ',' part_elem
2324 : ;
2325 :
2326 :
2327 : part_elem:
2328 : ColId opt_collate opt_qualified_name
2329 : | func_expr_windowless opt_collate opt_qualified_name
2330 : | '(' a_expr ')' opt_collate opt_qualified_name
2331 : ;
2332 :
2333 :
2334 : table_access_method_clause:
2335 : USING name
2336 : |
2337 : ;
2338 :
2339 :
2340 : OptWith:
2341 : WITH reloptions
2342 : | WITHOUT OIDS
2343 : |
2344 : ;
2345 :
2346 :
2347 : OnCommitOption:
2348 : ON COMMIT DROP
2349 : | ON COMMIT DELETE_P ROWS
2350 : | ON COMMIT PRESERVE ROWS
2351 : |
2352 : ;
2353 :
2354 :
2355 : OptTableSpace:
2356 : TABLESPACE name
2357 : |
2358 : ;
2359 :
2360 :
2361 : OptConsTableSpace:
2362 : USING INDEX TABLESPACE name
2363 : |
2364 : ;
2365 :
2366 :
2367 : ExistingIndex:
2368 : USING INDEX name
2369 : ;
2370 :
2371 :
2372 : CreateStatsStmt:
2373 : CREATE STATISTICS opt_qualified_name opt_name_list ON stats_params FROM from_list
2374 : | CREATE STATISTICS IF_P NOT EXISTS any_name opt_name_list ON stats_params FROM from_list
2375 : ;
2376 :
2377 :
2378 : stats_params:
2379 : stats_param
2380 : | stats_params ',' stats_param
2381 : ;
2382 :
2383 :
2384 : stats_param:
2385 : ColId
2386 : | func_expr_windowless
2387 : | '(' a_expr ')'
2388 : ;
2389 :
2390 :
2391 : AlterStatsStmt:
2392 : ALTER STATISTICS any_name SET STATISTICS set_statistics_value
2393 : | ALTER STATISTICS IF_P EXISTS any_name SET STATISTICS set_statistics_value
2394 : ;
2395 :
2396 :
2397 : create_as_target:
2398 : qualified_name opt_column_list table_access_method_clause OptWith OnCommitOption OptTableSpace
2399 : ;
2400 :
2401 :
2402 : opt_with_data:
2403 : WITH DATA_P
2404 : | WITH NO DATA_P
2405 : |
2406 : ;
2407 :
2408 :
2409 : CreateMatViewStmt:
2410 : CREATE OptNoLog MATERIALIZED VIEW create_mv_target AS SelectStmt opt_with_data
2411 : | CREATE OptNoLog MATERIALIZED VIEW IF_P NOT EXISTS create_mv_target AS SelectStmt opt_with_data
2412 : ;
2413 :
2414 :
2415 : create_mv_target:
2416 : qualified_name opt_column_list table_access_method_clause opt_reloptions OptTableSpace
2417 : ;
2418 :
2419 :
2420 : OptNoLog:
2421 : UNLOGGED
2422 : |
2423 : ;
2424 :
2425 :
2426 : RefreshMatViewStmt:
2427 : REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data
2428 : ;
2429 :
2430 :
2431 : CreateSeqStmt:
2432 : CREATE OptTemp SEQUENCE qualified_name OptSeqOptList
2433 : | CREATE OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList
2434 : ;
2435 :
2436 :
2437 : AlterSeqStmt:
2438 : ALTER SEQUENCE qualified_name SeqOptList
2439 : | ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList
2440 : ;
2441 :
2442 :
2443 : OptSeqOptList:
2444 : SeqOptList
2445 : |
2446 : ;
2447 :
2448 :
2449 : OptParenthesizedSeqOptList:
2450 : '(' SeqOptList ')'
2451 : |
2452 : ;
2453 :
2454 :
2455 : SeqOptList:
2456 : SeqOptElem
2457 : | SeqOptList SeqOptElem
2458 : ;
2459 :
2460 :
2461 : SeqOptElem:
2462 : AS SimpleTypename
2463 : | CACHE NumericOnly
2464 : | CYCLE
2465 : | NO CYCLE
2466 : | INCREMENT opt_by NumericOnly
2467 : | LOGGED
2468 : | MAXVALUE NumericOnly
2469 : | MINVALUE NumericOnly
2470 : | NO MAXVALUE
2471 : | NO MINVALUE
2472 : | OWNED BY any_name
2473 : | SEQUENCE NAME_P any_name
2474 : | START opt_with NumericOnly
2475 : | RESTART
2476 : | RESTART opt_with NumericOnly
2477 : | UNLOGGED
2478 : ;
2479 :
2480 :
2481 : opt_by:
2482 : BY
2483 : |
2484 : ;
2485 :
2486 :
2487 : NumericOnly:
2488 : ecpg_fconst
2489 : | '+' ecpg_fconst
2490 : | '-' ecpg_fconst
2491 : | SignedIconst
2492 : ;
2493 :
2494 :
2495 : NumericOnly_list:
2496 : NumericOnly
2497 : | NumericOnly_list ',' NumericOnly
2498 : ;
2499 :
2500 :
2501 : CreatePLangStmt:
2502 : CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name
2503 : | CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name HANDLER handler_name opt_inline_handler opt_validator
2504 : ;
2505 :
2506 :
2507 : opt_trusted:
2508 : TRUSTED
2509 : |
2510 : ;
2511 :
2512 :
2513 : handler_name:
2514 : name
2515 : | name attrs
2516 : ;
2517 :
2518 :
2519 : opt_inline_handler:
2520 : INLINE_P handler_name
2521 : |
2522 : ;
2523 :
2524 :
2525 : validator_clause:
2526 : VALIDATOR handler_name
2527 : | NO VALIDATOR
2528 : ;
2529 :
2530 :
2531 : opt_validator:
2532 : validator_clause
2533 : |
2534 : ;
2535 :
2536 :
2537 : opt_procedural:
2538 : PROCEDURAL
2539 : |
2540 : ;
2541 :
2542 :
2543 : CreateTableSpaceStmt:
2544 : CREATE TABLESPACE name OptTableSpaceOwner LOCATION ecpg_sconst opt_reloptions
2545 : ;
2546 :
2547 :
2548 : OptTableSpaceOwner:
2549 : OWNER RoleSpec
2550 : |
2551 : ;
2552 :
2553 :
2554 : DropTableSpaceStmt:
2555 : DROP TABLESPACE name
2556 : | DROP TABLESPACE IF_P EXISTS name
2557 : ;
2558 :
2559 :
2560 : CreateExtensionStmt:
2561 : CREATE EXTENSION name opt_with create_extension_opt_list
2562 : | CREATE EXTENSION IF_P NOT EXISTS name opt_with create_extension_opt_list
2563 : ;
2564 :
2565 :
2566 : create_extension_opt_list:
2567 : create_extension_opt_list create_extension_opt_item
2568 : |
2569 : ;
2570 :
2571 :
2572 : create_extension_opt_item:
2573 : SCHEMA name
2574 : | VERSION_P NonReservedWord_or_Sconst
2575 : | FROM NonReservedWord_or_Sconst
2576 : {
2577 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
2578 : }
2579 : | CASCADE
2580 : ;
2581 :
2582 :
2583 : AlterExtensionStmt:
2584 : ALTER EXTENSION name UPDATE alter_extension_opt_list
2585 : ;
2586 :
2587 :
2588 : alter_extension_opt_list:
2589 : alter_extension_opt_list alter_extension_opt_item
2590 : |
2591 : ;
2592 :
2593 :
2594 : alter_extension_opt_item:
2595 : TO NonReservedWord_or_Sconst
2596 : ;
2597 :
2598 :
2599 : AlterExtensionContentsStmt:
2600 : ALTER EXTENSION name add_drop object_type_name name
2601 : | ALTER EXTENSION name add_drop object_type_any_name any_name
2602 : | ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes
2603 : | ALTER EXTENSION name add_drop CAST '(' Typename AS Typename ')'
2604 : | ALTER EXTENSION name add_drop DOMAIN_P Typename
2605 : | ALTER EXTENSION name add_drop FUNCTION function_with_argtypes
2606 : | ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes
2607 : | ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name
2608 : | ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name
2609 : | ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes
2610 : | ALTER EXTENSION name add_drop ROUTINE function_with_argtypes
2611 : | ALTER EXTENSION name add_drop TRANSFORM FOR Typename LANGUAGE name
2612 : | ALTER EXTENSION name add_drop TYPE_P Typename
2613 : ;
2614 :
2615 :
2616 : CreateFdwStmt:
2617 : CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options
2618 : ;
2619 :
2620 :
2621 : fdw_option:
2622 : HANDLER handler_name
2623 : | NO HANDLER
2624 : | VALIDATOR handler_name
2625 : | NO VALIDATOR
2626 : ;
2627 :
2628 :
2629 : fdw_options:
2630 : fdw_option
2631 : | fdw_options fdw_option
2632 : ;
2633 :
2634 :
2635 : opt_fdw_options:
2636 : fdw_options
2637 : |
2638 : ;
2639 :
2640 :
2641 : AlterFdwStmt:
2642 : ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options
2643 : | ALTER FOREIGN DATA_P WRAPPER name fdw_options
2644 : ;
2645 :
2646 :
2647 : create_generic_options:
2648 : OPTIONS '(' generic_option_list ')'
2649 : |
2650 : ;
2651 :
2652 :
2653 : generic_option_list:
2654 : generic_option_elem
2655 : | generic_option_list ',' generic_option_elem
2656 : ;
2657 :
2658 :
2659 : alter_generic_options:
2660 : OPTIONS '(' alter_generic_option_list ')'
2661 : ;
2662 :
2663 :
2664 : alter_generic_option_list:
2665 : alter_generic_option_elem
2666 : | alter_generic_option_list ',' alter_generic_option_elem
2667 : ;
2668 :
2669 :
2670 : alter_generic_option_elem:
2671 : generic_option_elem
2672 : | SET generic_option_elem
2673 : | ADD_P generic_option_elem
2674 : | DROP generic_option_name
2675 : ;
2676 :
2677 :
2678 : generic_option_elem:
2679 : generic_option_name generic_option_arg
2680 : ;
2681 :
2682 :
2683 : generic_option_name:
2684 : ColLabel
2685 : ;
2686 :
2687 :
2688 : generic_option_arg:
2689 : ecpg_sconst
2690 : ;
2691 :
2692 :
2693 : CreateForeignServerStmt:
2694 : CREATE SERVER name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options
2695 : | CREATE SERVER IF_P NOT EXISTS name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options
2696 : ;
2697 :
2698 :
2699 : opt_type:
2700 : TYPE_P ecpg_sconst
2701 : |
2702 : ;
2703 :
2704 :
2705 : foreign_server_version:
2706 : VERSION_P ecpg_sconst
2707 : | VERSION_P NULL_P
2708 : ;
2709 :
2710 :
2711 : opt_foreign_server_version:
2712 : foreign_server_version
2713 : |
2714 : ;
2715 :
2716 :
2717 : AlterForeignServerStmt:
2718 : ALTER SERVER name foreign_server_version alter_generic_options
2719 : | ALTER SERVER name foreign_server_version
2720 : | ALTER SERVER name alter_generic_options
2721 : ;
2722 :
2723 :
2724 : CreateForeignTableStmt:
2725 : CREATE FOREIGN TABLE qualified_name '(' OptTableElementList ')' OptInherit SERVER name create_generic_options
2726 : | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptInherit SERVER name create_generic_options
2727 : | CREATE FOREIGN TABLE qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec SERVER name create_generic_options
2728 : | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec SERVER name create_generic_options
2729 : ;
2730 :
2731 :
2732 : ImportForeignSchemaStmt:
2733 : IMPORT_P FOREIGN SCHEMA name import_qualification FROM SERVER name INTO name create_generic_options
2734 : ;
2735 :
2736 :
2737 : import_qualification_type:
2738 : LIMIT TO
2739 : | EXCEPT
2740 : ;
2741 :
2742 :
2743 : import_qualification:
2744 : import_qualification_type '(' relation_expr_list ')'
2745 : |
2746 : ;
2747 :
2748 :
2749 : CreateUserMappingStmt:
2750 : CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
2751 : | CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options
2752 : ;
2753 :
2754 :
2755 : auth_ident:
2756 : RoleSpec
2757 : | USER
2758 : ;
2759 :
2760 :
2761 : DropUserMappingStmt:
2762 : DROP USER MAPPING FOR auth_ident SERVER name
2763 : | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
2764 : ;
2765 :
2766 :
2767 : AlterUserMappingStmt:
2768 : ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
2769 : ;
2770 :
2771 :
2772 : CreatePolicyStmt:
2773 : CREATE POLICY name ON qualified_name RowSecurityDefaultPermissive RowSecurityDefaultForCmd RowSecurityDefaultToRole RowSecurityOptionalExpr RowSecurityOptionalWithCheck
2774 : ;
2775 :
2776 :
2777 : AlterPolicyStmt:
2778 : ALTER POLICY name ON qualified_name RowSecurityOptionalToRole RowSecurityOptionalExpr RowSecurityOptionalWithCheck
2779 : ;
2780 :
2781 :
2782 : RowSecurityOptionalExpr:
2783 : USING '(' a_expr ')'
2784 : |
2785 : ;
2786 :
2787 :
2788 : RowSecurityOptionalWithCheck:
2789 : WITH CHECK '(' a_expr ')'
2790 : |
2791 : ;
2792 :
2793 :
2794 : RowSecurityDefaultToRole:
2795 : TO role_list
2796 : |
2797 : ;
2798 :
2799 :
2800 : RowSecurityOptionalToRole:
2801 : TO role_list
2802 : |
2803 : ;
2804 :
2805 :
2806 : RowSecurityDefaultPermissive:
2807 : AS ecpg_ident
2808 : |
2809 : ;
2810 :
2811 :
2812 : RowSecurityDefaultForCmd:
2813 : FOR row_security_cmd
2814 : |
2815 : ;
2816 :
2817 :
2818 : row_security_cmd:
2819 : ALL
2820 : | SELECT
2821 : | INSERT
2822 : | UPDATE
2823 : | DELETE_P
2824 : ;
2825 :
2826 :
2827 : CreateAmStmt:
2828 : CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name
2829 : ;
2830 :
2831 :
2832 : am_type:
2833 : INDEX
2834 : | TABLE
2835 : ;
2836 :
2837 :
2838 : CreateTrigStmt:
2839 : CREATE opt_or_replace TRIGGER name TriggerActionTime TriggerEvents ON qualified_name TriggerReferencing TriggerForSpec TriggerWhen EXECUTE FUNCTION_or_PROCEDURE func_name '(' TriggerFuncArgs ')'
2840 : | CREATE opt_or_replace CONSTRAINT TRIGGER name AFTER TriggerEvents ON qualified_name OptConstrFromTable ConstraintAttributeSpec FOR EACH ROW TriggerWhen EXECUTE FUNCTION_or_PROCEDURE func_name '(' TriggerFuncArgs ')'
2841 : ;
2842 :
2843 :
2844 : TriggerActionTime:
2845 : BEFORE
2846 : | AFTER
2847 : | INSTEAD OF
2848 : ;
2849 :
2850 :
2851 : TriggerEvents:
2852 : TriggerOneEvent
2853 : | TriggerEvents OR TriggerOneEvent
2854 : ;
2855 :
2856 :
2857 : TriggerOneEvent:
2858 : INSERT
2859 : | DELETE_P
2860 : | UPDATE
2861 : | UPDATE OF columnList
2862 : | TRUNCATE
2863 : ;
2864 :
2865 :
2866 : TriggerReferencing:
2867 : REFERENCING TriggerTransitions
2868 : |
2869 : ;
2870 :
2871 :
2872 : TriggerTransitions:
2873 : TriggerTransition
2874 : | TriggerTransitions TriggerTransition
2875 : ;
2876 :
2877 :
2878 : TriggerTransition:
2879 : TransitionOldOrNew TransitionRowOrTable opt_as TransitionRelName
2880 : ;
2881 :
2882 :
2883 : TransitionOldOrNew:
2884 : NEW
2885 : | OLD
2886 : ;
2887 :
2888 :
2889 : TransitionRowOrTable:
2890 : TABLE
2891 : | ROW
2892 : ;
2893 :
2894 :
2895 : TransitionRelName:
2896 : ColId
2897 : ;
2898 :
2899 :
2900 : TriggerForSpec:
2901 : FOR TriggerForOptEach TriggerForType
2902 : |
2903 : ;
2904 :
2905 :
2906 : TriggerForOptEach:
2907 : EACH
2908 : |
2909 : ;
2910 :
2911 :
2912 : TriggerForType:
2913 : ROW
2914 : | STATEMENT
2915 : ;
2916 :
2917 :
2918 : TriggerWhen:
2919 : WHEN '(' a_expr ')'
2920 : |
2921 : ;
2922 :
2923 :
2924 : FUNCTION_or_PROCEDURE:
2925 : FUNCTION
2926 : | PROCEDURE
2927 : ;
2928 :
2929 :
2930 : TriggerFuncArgs:
2931 : TriggerFuncArg
2932 : | TriggerFuncArgs ',' TriggerFuncArg
2933 : |
2934 : ;
2935 :
2936 :
2937 : TriggerFuncArg:
2938 : Iconst
2939 : | ecpg_fconst
2940 : | ecpg_sconst
2941 : | ColLabel
2942 : ;
2943 :
2944 :
2945 : OptConstrFromTable:
2946 : FROM qualified_name
2947 : |
2948 : ;
2949 :
2950 :
2951 : ConstraintAttributeSpec:
2952 :
2953 : | ConstraintAttributeSpec ConstraintAttributeElem
2954 : ;
2955 :
2956 :
2957 : ConstraintAttributeElem:
2958 : NOT DEFERRABLE
2959 : | DEFERRABLE
2960 : | INITIALLY IMMEDIATE
2961 : | INITIALLY DEFERRED
2962 : | NOT VALID
2963 : | NO INHERIT
2964 : | NOT ENFORCED
2965 : | ENFORCED
2966 : ;
2967 :
2968 :
2969 : CreateEventTrigStmt:
2970 : CREATE EVENT TRIGGER name ON ColLabel EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
2971 : | CREATE EVENT TRIGGER name ON ColLabel WHEN event_trigger_when_list EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
2972 : ;
2973 :
2974 :
2975 : event_trigger_when_list:
2976 : event_trigger_when_item
2977 : | event_trigger_when_list AND event_trigger_when_item
2978 : ;
2979 :
2980 :
2981 : event_trigger_when_item:
2982 : ColId IN_P '(' event_trigger_value_list ')'
2983 : ;
2984 :
2985 :
2986 : event_trigger_value_list:
2987 : SCONST
2988 : | event_trigger_value_list ',' SCONST
2989 : ;
2990 :
2991 :
2992 : AlterEventTrigStmt:
2993 : ALTER EVENT TRIGGER name enable_trigger
2994 : ;
2995 :
2996 :
2997 : enable_trigger:
2998 : ENABLE_P
2999 : | ENABLE_P REPLICA
3000 : | ENABLE_P ALWAYS
3001 : | DISABLE_P
3002 : ;
3003 :
3004 :
3005 : CreateAssertionStmt:
3006 : CREATE ASSERTION any_name CHECK '(' a_expr ')' ConstraintAttributeSpec
3007 : {
3008 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
3009 : }
3010 : ;
3011 :
3012 :
3013 : DefineStmt:
3014 : CREATE opt_or_replace AGGREGATE func_name aggr_args definition
3015 : | CREATE opt_or_replace AGGREGATE func_name old_aggr_definition
3016 : | CREATE OPERATOR any_operator definition
3017 : | CREATE TYPE_P any_name definition
3018 : | CREATE TYPE_P any_name
3019 : | CREATE TYPE_P any_name AS '(' OptTableFuncElementList ')'
3020 : | CREATE TYPE_P any_name AS ENUM_P '(' opt_enum_val_list ')'
3021 : | CREATE TYPE_P any_name AS RANGE definition
3022 : | CREATE TEXT_P SEARCH PARSER any_name definition
3023 : | CREATE TEXT_P SEARCH DICTIONARY any_name definition
3024 : | CREATE TEXT_P SEARCH TEMPLATE any_name definition
3025 : | CREATE TEXT_P SEARCH CONFIGURATION any_name definition
3026 : | CREATE COLLATION any_name definition
3027 : | CREATE COLLATION IF_P NOT EXISTS any_name definition
3028 : | CREATE COLLATION any_name FROM any_name
3029 : | CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name
3030 : ;
3031 :
3032 :
3033 : definition:
3034 : '(' def_list ')'
3035 : ;
3036 :
3037 :
3038 : def_list:
3039 : def_elem
3040 : | def_list ',' def_elem
3041 : ;
3042 :
3043 :
3044 : def_elem:
3045 : ColLabel '=' def_arg
3046 : | ColLabel
3047 : ;
3048 :
3049 :
3050 : def_arg:
3051 : func_type
3052 : | reserved_keyword
3053 : | qual_all_Op
3054 : | NumericOnly
3055 : | ecpg_sconst
3056 : | NONE
3057 : ;
3058 :
3059 :
3060 : old_aggr_definition:
3061 : '(' old_aggr_list ')'
3062 : ;
3063 :
3064 :
3065 : old_aggr_list:
3066 : old_aggr_elem
3067 : | old_aggr_list ',' old_aggr_elem
3068 : ;
3069 :
3070 :
3071 : old_aggr_elem:
3072 : ecpg_ident '=' def_arg
3073 : ;
3074 :
3075 :
3076 : opt_enum_val_list:
3077 : enum_val_list
3078 : |
3079 : ;
3080 :
3081 :
3082 : enum_val_list:
3083 : ecpg_sconst
3084 : | enum_val_list ',' ecpg_sconst
3085 : ;
3086 :
3087 :
3088 : AlterEnumStmt:
3089 : ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst
3090 : | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst BEFORE ecpg_sconst
3091 : | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst AFTER ecpg_sconst
3092 : | ALTER TYPE_P any_name RENAME VALUE_P ecpg_sconst TO ecpg_sconst
3093 : | ALTER TYPE_P any_name DROP VALUE_P ecpg_sconst
3094 : {
3095 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
3096 : }
3097 : ;
3098 :
3099 :
3100 : opt_if_not_exists:
3101 : IF_P NOT EXISTS
3102 : |
3103 : ;
3104 :
3105 :
3106 : CreateOpClassStmt:
3107 : CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename USING name opt_opfamily AS opclass_item_list
3108 : ;
3109 :
3110 :
3111 : opclass_item_list:
3112 : opclass_item
3113 : | opclass_item_list ',' opclass_item
3114 : ;
3115 :
3116 :
3117 : opclass_item:
3118 : OPERATOR Iconst any_operator opclass_purpose
3119 : | OPERATOR Iconst operator_with_argtypes opclass_purpose
3120 : | FUNCTION Iconst function_with_argtypes
3121 : | FUNCTION Iconst '(' type_list ')' function_with_argtypes
3122 : | STORAGE Typename
3123 : ;
3124 :
3125 :
3126 : opt_default:
3127 : DEFAULT
3128 : |
3129 : ;
3130 :
3131 :
3132 : opt_opfamily:
3133 : FAMILY any_name
3134 : |
3135 : ;
3136 :
3137 :
3138 : opclass_purpose:
3139 : FOR SEARCH
3140 : | FOR ORDER BY any_name
3141 : |
3142 : ;
3143 :
3144 :
3145 : CreateOpFamilyStmt:
3146 : CREATE OPERATOR FAMILY any_name USING name
3147 : ;
3148 :
3149 :
3150 : AlterOpFamilyStmt:
3151 : ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list
3152 : | ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list
3153 : ;
3154 :
3155 :
3156 : opclass_drop_list:
3157 : opclass_drop
3158 : | opclass_drop_list ',' opclass_drop
3159 : ;
3160 :
3161 :
3162 : opclass_drop:
3163 : OPERATOR Iconst '(' type_list ')'
3164 : | FUNCTION Iconst '(' type_list ')'
3165 : ;
3166 :
3167 :
3168 : DropOpClassStmt:
3169 : DROP OPERATOR CLASS any_name USING name opt_drop_behavior
3170 : | DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior
3171 : ;
3172 :
3173 :
3174 : DropOpFamilyStmt:
3175 : DROP OPERATOR FAMILY any_name USING name opt_drop_behavior
3176 : | DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior
3177 : ;
3178 :
3179 :
3180 : DropOwnedStmt:
3181 : DROP OWNED BY role_list opt_drop_behavior
3182 : ;
3183 :
3184 :
3185 : ReassignOwnedStmt:
3186 : REASSIGN OWNED BY role_list TO RoleSpec
3187 : ;
3188 :
3189 :
3190 : DropStmt:
3191 : DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior
3192 : | DROP object_type_any_name any_name_list opt_drop_behavior
3193 : | DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior
3194 : | DROP drop_type_name name_list opt_drop_behavior
3195 : | DROP object_type_name_on_any_name name ON any_name opt_drop_behavior
3196 : | DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior
3197 : | DROP TYPE_P type_name_list opt_drop_behavior
3198 : | DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior
3199 : | DROP DOMAIN_P type_name_list opt_drop_behavior
3200 : | DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior
3201 : | DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior
3202 : | DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior
3203 : ;
3204 :
3205 :
3206 : object_type_any_name:
3207 : TABLE
3208 : | SEQUENCE
3209 : | VIEW
3210 : | MATERIALIZED VIEW
3211 : | INDEX
3212 : | FOREIGN TABLE
3213 : | COLLATION
3214 : | CONVERSION_P
3215 : | STATISTICS
3216 : | TEXT_P SEARCH PARSER
3217 : | TEXT_P SEARCH DICTIONARY
3218 : | TEXT_P SEARCH TEMPLATE
3219 : | TEXT_P SEARCH CONFIGURATION
3220 : ;
3221 :
3222 :
3223 : object_type_name:
3224 : drop_type_name
3225 : | DATABASE
3226 : | ROLE
3227 : | SUBSCRIPTION
3228 : | TABLESPACE
3229 : ;
3230 :
3231 :
3232 : drop_type_name:
3233 : ACCESS METHOD
3234 : | EVENT TRIGGER
3235 : | EXTENSION
3236 : | FOREIGN DATA_P WRAPPER
3237 : | opt_procedural LANGUAGE
3238 : | PUBLICATION
3239 : | SCHEMA
3240 : | SERVER
3241 : ;
3242 :
3243 :
3244 : object_type_name_on_any_name:
3245 : POLICY
3246 : | RULE
3247 : | TRIGGER
3248 : ;
3249 :
3250 :
3251 : any_name_list:
3252 : any_name
3253 : | any_name_list ',' any_name
3254 : ;
3255 :
3256 :
3257 : any_name:
3258 : ColId
3259 : | ColId attrs
3260 : ;
3261 :
3262 :
3263 : attrs:
3264 : '.' attr_name
3265 : | attrs '.' attr_name
3266 : ;
3267 :
3268 :
3269 : type_name_list:
3270 : Typename
3271 : | type_name_list ',' Typename
3272 : ;
3273 :
3274 :
3275 : TruncateStmt:
3276 : TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior
3277 : ;
3278 :
3279 :
3280 : opt_restart_seqs:
3281 : CONTINUE_P IDENTITY_P
3282 : | RESTART IDENTITY_P
3283 : |
3284 : ;
3285 :
3286 :
3287 : CommentStmt:
3288 : COMMENT ON object_type_any_name any_name IS comment_text
3289 : | COMMENT ON COLUMN any_name IS comment_text
3290 : | COMMENT ON object_type_name name IS comment_text
3291 : | COMMENT ON TYPE_P Typename IS comment_text
3292 : | COMMENT ON DOMAIN_P Typename IS comment_text
3293 : | COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text
3294 : | COMMENT ON FUNCTION function_with_argtypes IS comment_text
3295 : | COMMENT ON OPERATOR operator_with_argtypes IS comment_text
3296 : | COMMENT ON CONSTRAINT name ON any_name IS comment_text
3297 : | COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text
3298 : | COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text
3299 : | COMMENT ON PROCEDURE function_with_argtypes IS comment_text
3300 : | COMMENT ON ROUTINE function_with_argtypes IS comment_text
3301 : | COMMENT ON TRANSFORM FOR Typename LANGUAGE name IS comment_text
3302 : | COMMENT ON OPERATOR CLASS any_name USING name IS comment_text
3303 : | COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text
3304 : | COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
3305 : | COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
3306 : ;
3307 :
3308 :
3309 : comment_text:
3310 : ecpg_sconst
3311 : | NULL_P
3312 : ;
3313 :
3314 :
3315 : SecLabelStmt:
3316 : SECURITY LABEL opt_provider ON object_type_any_name any_name IS security_label
3317 : | SECURITY LABEL opt_provider ON COLUMN any_name IS security_label
3318 : | SECURITY LABEL opt_provider ON object_type_name name IS security_label
3319 : | SECURITY LABEL opt_provider ON TYPE_P Typename IS security_label
3320 : | SECURITY LABEL opt_provider ON DOMAIN_P Typename IS security_label
3321 : | SECURITY LABEL opt_provider ON AGGREGATE aggregate_with_argtypes IS security_label
3322 : | SECURITY LABEL opt_provider ON FUNCTION function_with_argtypes IS security_label
3323 : | SECURITY LABEL opt_provider ON LARGE_P OBJECT_P NumericOnly IS security_label
3324 : | SECURITY LABEL opt_provider ON PROCEDURE function_with_argtypes IS security_label
3325 : | SECURITY LABEL opt_provider ON ROUTINE function_with_argtypes IS security_label
3326 : ;
3327 :
3328 :
3329 : opt_provider:
3330 : FOR NonReservedWord_or_Sconst
3331 : |
3332 : ;
3333 :
3334 :
3335 : security_label:
3336 : ecpg_sconst
3337 : | NULL_P
3338 : ;
3339 :
3340 :
3341 : FetchStmt:
3342 : FETCH fetch_args
3343 : | MOVE fetch_args
3344 : | FETCH fetch_args ecpg_fetch_into
3345 : | FETCH FORWARD cursor_name opt_ecpg_fetch_into
3346 : {
3347 4 : const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
3348 4 : struct cursor *ptr = add_additional_variables(@3, false);
3349 :
3350 4 : update_connection(ptr->connection);
3351 :
3352 4 : @$ = cat_str(2, "fetch forward", cursor_marker);
3353 : }
3354 : | FETCH FORWARD from_in cursor_name opt_ecpg_fetch_into
3355 : {
3356 2 : const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
3357 2 : struct cursor *ptr = add_additional_variables(@4, false);
3358 :
3359 2 : update_connection(ptr->connection);
3360 :
3361 2 : @$ = cat_str(2, "fetch forward from", cursor_marker);
3362 : }
3363 : | FETCH BACKWARD cursor_name opt_ecpg_fetch_into
3364 : {
3365 0 : const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
3366 0 : struct cursor *ptr = add_additional_variables(@3, false);
3367 :
3368 0 : update_connection(ptr->connection);
3369 :
3370 0 : @$ = cat_str(2, "fetch backward", cursor_marker);
3371 : }
3372 : | FETCH BACKWARD from_in cursor_name opt_ecpg_fetch_into
3373 : {
3374 0 : const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
3375 0 : struct cursor *ptr = add_additional_variables(@4, false);
3376 :
3377 0 : update_connection(ptr->connection);
3378 :
3379 0 : @$ = cat_str(2, "fetch backward from", cursor_marker);
3380 : }
3381 : | MOVE FORWARD cursor_name
3382 : {
3383 0 : const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
3384 0 : struct cursor *ptr = add_additional_variables(@3, false);
3385 :
3386 0 : update_connection(ptr->connection);
3387 :
3388 0 : @$ = cat_str(2, "move forward", cursor_marker);
3389 : }
3390 : | MOVE FORWARD from_in cursor_name
3391 : {
3392 0 : const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
3393 0 : struct cursor *ptr = add_additional_variables(@4, false);
3394 :
3395 0 : update_connection(ptr->connection);
3396 :
3397 0 : @$ = cat_str(2, "move forward from", cursor_marker);
3398 : }
3399 : | MOVE BACKWARD cursor_name
3400 : {
3401 0 : const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
3402 0 : struct cursor *ptr = add_additional_variables(@3, false);
3403 :
3404 0 : update_connection(ptr->connection);
3405 :
3406 0 : @$ = cat_str(2, "move backward", cursor_marker);
3407 : }
3408 : | MOVE BACKWARD from_in cursor_name
3409 : {
3410 0 : const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
3411 0 : struct cursor *ptr = add_additional_variables(@4, false);
3412 :
3413 0 : update_connection(ptr->connection);
3414 :
3415 0 : @$ = cat_str(2, "move backward from", cursor_marker);
3416 : }
3417 : ;
3418 :
3419 :
3420 : fetch_args:
3421 : cursor_name
3422 : {
3423 32 : struct cursor *ptr = add_additional_variables(@1, false);
3424 :
3425 32 : update_connection(ptr->connection);
3426 32 : if (@1[0] == ':')
3427 6 : @$ = "$0";
3428 : }
3429 : | from_in cursor_name
3430 : {
3431 22 : struct cursor *ptr = add_additional_variables(@2, false);
3432 :
3433 22 : update_connection(ptr->connection);
3434 22 : if (@2[0] == ':')
3435 6 : @$ = cat2_str(@1, "$0");
3436 : }
3437 : | NEXT opt_from_in cursor_name
3438 : {
3439 6 : struct cursor *ptr = add_additional_variables(@3, false);
3440 :
3441 6 : update_connection(ptr->connection);
3442 6 : if (@3[0] == ':')
3443 0 : @$ = cat_str(3, @1, @2, "$0");
3444 : }
3445 : | PRIOR opt_from_in cursor_name
3446 : {
3447 0 : struct cursor *ptr = add_additional_variables(@3, false);
3448 :
3449 0 : update_connection(ptr->connection);
3450 0 : if (@3[0] == ':')
3451 0 : @$ = cat_str(3, @1, @2, "$0");
3452 : }
3453 : | FIRST_P opt_from_in cursor_name
3454 : {
3455 0 : struct cursor *ptr = add_additional_variables(@3, false);
3456 :
3457 0 : update_connection(ptr->connection);
3458 0 : if (@3[0] == ':')
3459 0 : @$ = cat_str(3, @1, @2, "$0");
3460 : }
3461 : | LAST_P opt_from_in cursor_name
3462 : {
3463 0 : struct cursor *ptr = add_additional_variables(@3, false);
3464 :
3465 0 : update_connection(ptr->connection);
3466 0 : if (@3[0] == ':')
3467 0 : @$ = cat_str(3, @1, @2, "$0");
3468 : }
3469 : | ABSOLUTE_P SignedIconst opt_from_in cursor_name
3470 : {
3471 8 : struct cursor *ptr = add_additional_variables(@4, false);
3472 8 : bool replace = false;
3473 :
3474 8 : update_connection(ptr->connection);
3475 8 : if (@4[0] == ':')
3476 : {
3477 8 : @4 = "$0";
3478 8 : replace = true;
3479 : }
3480 8 : if (@2[0] == '$')
3481 : {
3482 0 : @2 = "$0";
3483 0 : replace = true;
3484 : }
3485 8 : if (replace)
3486 8 : @$ = cat_str(4, @1, @2, @3, @4);
3487 : }
3488 : | RELATIVE_P SignedIconst opt_from_in cursor_name
3489 : {
3490 0 : struct cursor *ptr = add_additional_variables(@4, false);
3491 0 : bool replace = false;
3492 :
3493 0 : update_connection(ptr->connection);
3494 0 : if (@4[0] == ':')
3495 : {
3496 0 : @4 = "$0";
3497 0 : replace = true;
3498 : }
3499 0 : if (@2[0] == '$')
3500 : {
3501 0 : @2 = "$0";
3502 0 : replace = true;
3503 : }
3504 0 : if (replace)
3505 0 : @$ = cat_str(4, @1, @2, @3, @4);
3506 : }
3507 : | SignedIconst opt_from_in cursor_name
3508 : {
3509 48 : struct cursor *ptr = add_additional_variables(@3, false);
3510 48 : bool replace = false;
3511 :
3512 48 : update_connection(ptr->connection);
3513 48 : if (@3[0] == ':')
3514 : {
3515 32 : @3 = "$0";
3516 32 : replace = true;
3517 : }
3518 48 : if (@1[0] == '$')
3519 : {
3520 18 : @1 = "$0";
3521 18 : replace = true;
3522 : }
3523 48 : if (replace)
3524 34 : @$ = cat_str(3, @1, @2, @3);
3525 : }
3526 : | ALL opt_from_in cursor_name
3527 : {
3528 2 : struct cursor *ptr = add_additional_variables(@3, false);
3529 :
3530 2 : update_connection(ptr->connection);
3531 2 : if (@3[0] == ':')
3532 0 : @$ = cat_str(3, @1, @2, "$0");
3533 : }
3534 : | FORWARD SignedIconst opt_from_in cursor_name
3535 : {
3536 0 : struct cursor *ptr = add_additional_variables(@4, false);
3537 0 : bool replace = false;
3538 :
3539 0 : update_connection(ptr->connection);
3540 0 : if (@4[0] == ':')
3541 : {
3542 0 : @4 = "$0";
3543 0 : replace = true;
3544 : }
3545 0 : if (@2[0] == '$')
3546 : {
3547 0 : @2 = "$0";
3548 0 : replace = true;
3549 : }
3550 0 : if (replace)
3551 0 : @$ = cat_str(4, @1, @2, @3, @4);
3552 : }
3553 : | FORWARD ALL opt_from_in cursor_name
3554 : {
3555 0 : struct cursor *ptr = add_additional_variables(@4, false);
3556 :
3557 0 : update_connection(ptr->connection);
3558 0 : if (@4[0] == ':')
3559 0 : @$ = cat_str(4, @1, @2, @3, "$0");
3560 : }
3561 : | BACKWARD SignedIconst opt_from_in cursor_name
3562 : {
3563 2 : struct cursor *ptr = add_additional_variables(@4, false);
3564 2 : bool replace = false;
3565 :
3566 2 : update_connection(ptr->connection);
3567 2 : if (@4[0] == ':')
3568 : {
3569 0 : @4 = "$0";
3570 0 : replace = true;
3571 : }
3572 2 : if (@2[0] == '$')
3573 : {
3574 0 : @2 = "$0";
3575 0 : replace = true;
3576 : }
3577 2 : if (replace)
3578 0 : @$ = cat_str(4, @1, @2, @3, @4);
3579 : }
3580 : | BACKWARD ALL opt_from_in cursor_name
3581 : {
3582 0 : struct cursor *ptr = add_additional_variables(@4, false);
3583 :
3584 0 : update_connection(ptr->connection);
3585 0 : if (@4[0] == ':')
3586 0 : @$ = cat_str(4, @1, @2, @3, "$0");
3587 : }
3588 : ;
3589 :
3590 :
3591 : from_in:
3592 : FROM
3593 : | IN_P
3594 : ;
3595 :
3596 :
3597 : opt_from_in:
3598 : from_in
3599 : |
3600 : ;
3601 :
3602 :
3603 : GrantStmt:
3604 : GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option opt_granted_by
3605 : ;
3606 :
3607 :
3608 : RevokeStmt:
3609 : REVOKE privileges ON privilege_target FROM grantee_list opt_granted_by opt_drop_behavior
3610 : | REVOKE GRANT OPTION FOR privileges ON privilege_target FROM grantee_list opt_granted_by opt_drop_behavior
3611 : ;
3612 :
3613 :
3614 : privileges:
3615 : privilege_list
3616 : | ALL
3617 : | ALL PRIVILEGES
3618 : | ALL '(' columnList ')'
3619 : | ALL PRIVILEGES '(' columnList ')'
3620 : ;
3621 :
3622 :
3623 : privilege_list:
3624 : privilege
3625 : | privilege_list ',' privilege
3626 : ;
3627 :
3628 :
3629 : privilege:
3630 : SELECT opt_column_list
3631 : | REFERENCES opt_column_list
3632 : | CREATE opt_column_list
3633 : | ALTER SYSTEM_P
3634 : | ColId opt_column_list
3635 : ;
3636 :
3637 :
3638 : parameter_name_list:
3639 : parameter_name
3640 : | parameter_name_list ',' parameter_name
3641 : ;
3642 :
3643 :
3644 : parameter_name:
3645 : ColId
3646 : | parameter_name '.' ColId
3647 : ;
3648 :
3649 :
3650 : privilege_target:
3651 : qualified_name_list
3652 : | TABLE qualified_name_list
3653 : | SEQUENCE qualified_name_list
3654 : | FOREIGN DATA_P WRAPPER name_list
3655 : | FOREIGN SERVER name_list
3656 : | FUNCTION function_with_argtypes_list
3657 : | PROCEDURE function_with_argtypes_list
3658 : | ROUTINE function_with_argtypes_list
3659 : | DATABASE name_list
3660 : | DOMAIN_P any_name_list
3661 : | LANGUAGE name_list
3662 : | LARGE_P OBJECT_P NumericOnly_list
3663 : | PARAMETER parameter_name_list
3664 : | SCHEMA name_list
3665 : | TABLESPACE name_list
3666 : | TYPE_P any_name_list
3667 : | ALL TABLES IN_P SCHEMA name_list
3668 : | ALL SEQUENCES IN_P SCHEMA name_list
3669 : | ALL FUNCTIONS IN_P SCHEMA name_list
3670 : | ALL PROCEDURES IN_P SCHEMA name_list
3671 : | ALL ROUTINES IN_P SCHEMA name_list
3672 : ;
3673 :
3674 :
3675 : grantee_list:
3676 : grantee
3677 : | grantee_list ',' grantee
3678 : ;
3679 :
3680 :
3681 : grantee:
3682 : RoleSpec
3683 : | GROUP_P RoleSpec
3684 : ;
3685 :
3686 :
3687 : opt_grant_grant_option:
3688 : WITH GRANT OPTION
3689 : |
3690 : ;
3691 :
3692 :
3693 : GrantRoleStmt:
3694 : GRANT privilege_list TO role_list opt_granted_by
3695 : | GRANT privilege_list TO role_list WITH grant_role_opt_list opt_granted_by
3696 : ;
3697 :
3698 :
3699 : RevokeRoleStmt:
3700 : REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior
3701 : | REVOKE ColId OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior
3702 : ;
3703 :
3704 :
3705 : grant_role_opt_list:
3706 : grant_role_opt_list ',' grant_role_opt
3707 : | grant_role_opt
3708 : ;
3709 :
3710 :
3711 : grant_role_opt:
3712 : ColLabel grant_role_opt_value
3713 : ;
3714 :
3715 :
3716 : grant_role_opt_value:
3717 : OPTION
3718 : | TRUE_P
3719 : | FALSE_P
3720 : ;
3721 :
3722 :
3723 : opt_granted_by:
3724 : GRANTED BY RoleSpec
3725 : |
3726 : ;
3727 :
3728 :
3729 : AlterDefaultPrivilegesStmt:
3730 : ALTER DEFAULT PRIVILEGES DefACLOptionList DefACLAction
3731 : ;
3732 :
3733 :
3734 : DefACLOptionList:
3735 : DefACLOptionList DefACLOption
3736 : |
3737 : ;
3738 :
3739 :
3740 : DefACLOption:
3741 : IN_P SCHEMA name_list
3742 : | FOR ROLE role_list
3743 : | FOR USER role_list
3744 : ;
3745 :
3746 :
3747 : DefACLAction:
3748 : GRANT privileges ON defacl_privilege_target TO grantee_list opt_grant_grant_option
3749 : | REVOKE privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior
3750 : | REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior
3751 : ;
3752 :
3753 :
3754 : defacl_privilege_target:
3755 : TABLES
3756 : | FUNCTIONS
3757 : | ROUTINES
3758 : | SEQUENCES
3759 : | TYPES_P
3760 : | SCHEMAS
3761 : ;
3762 :
3763 :
3764 : IndexStmt:
3765 : CREATE opt_unique INDEX opt_concurrently opt_single_name ON relation_expr access_method_clause '(' index_params ')' opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
3766 : | CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name ON relation_expr access_method_clause '(' index_params ')' opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
3767 : ;
3768 :
3769 :
3770 : opt_unique:
3771 : UNIQUE
3772 : |
3773 : ;
3774 :
3775 :
3776 : access_method_clause:
3777 : USING name
3778 : |
3779 : ;
3780 :
3781 :
3782 : index_params:
3783 : index_elem
3784 : | index_params ',' index_elem
3785 : ;
3786 :
3787 :
3788 : index_elem_options:
3789 : opt_collate opt_qualified_name opt_asc_desc opt_nulls_order
3790 : | opt_collate any_name reloptions opt_asc_desc opt_nulls_order
3791 : ;
3792 :
3793 :
3794 : index_elem:
3795 : ColId index_elem_options
3796 : | func_expr_windowless index_elem_options
3797 : | '(' a_expr ')' index_elem_options
3798 : ;
3799 :
3800 :
3801 : opt_include:
3802 : INCLUDE '(' index_including_params ')'
3803 : |
3804 : ;
3805 :
3806 :
3807 : index_including_params:
3808 : index_elem
3809 : | index_including_params ',' index_elem
3810 : ;
3811 :
3812 :
3813 : opt_collate:
3814 : COLLATE any_name
3815 : |
3816 : ;
3817 :
3818 :
3819 : opt_asc_desc:
3820 : ASC
3821 : | DESC
3822 : |
3823 : ;
3824 :
3825 :
3826 : opt_nulls_order:
3827 : NULLS_LA FIRST_P
3828 : | NULLS_LA LAST_P
3829 : |
3830 : ;
3831 :
3832 :
3833 : CreateFunctionStmt:
3834 : CREATE opt_or_replace FUNCTION func_name func_args_with_defaults RETURNS func_return opt_createfunc_opt_list opt_routine_body
3835 : | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults RETURNS TABLE '(' table_func_column_list ')' opt_createfunc_opt_list opt_routine_body
3836 : | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults opt_createfunc_opt_list opt_routine_body
3837 : | CREATE opt_or_replace PROCEDURE func_name func_args_with_defaults opt_createfunc_opt_list opt_routine_body
3838 : ;
3839 :
3840 :
3841 : opt_or_replace:
3842 : OR REPLACE
3843 : |
3844 : ;
3845 :
3846 :
3847 : func_args:
3848 : '(' func_args_list ')'
3849 : | '(' ')'
3850 : ;
3851 :
3852 :
3853 : func_args_list:
3854 : func_arg
3855 : | func_args_list ',' func_arg
3856 : ;
3857 :
3858 :
3859 : function_with_argtypes_list:
3860 : function_with_argtypes
3861 : | function_with_argtypes_list ',' function_with_argtypes
3862 : ;
3863 :
3864 :
3865 : function_with_argtypes:
3866 : func_name func_args
3867 : | type_func_name_keyword
3868 : | ColId
3869 : | ColId indirection
3870 : ;
3871 :
3872 :
3873 : func_args_with_defaults:
3874 : '(' func_args_with_defaults_list ')'
3875 : | '(' ')'
3876 : ;
3877 :
3878 :
3879 : func_args_with_defaults_list:
3880 : func_arg_with_default
3881 : | func_args_with_defaults_list ',' func_arg_with_default
3882 : ;
3883 :
3884 :
3885 : func_arg:
3886 : arg_class param_name func_type
3887 : | param_name arg_class func_type
3888 : | param_name func_type
3889 : | arg_class func_type
3890 : | func_type
3891 : ;
3892 :
3893 :
3894 : arg_class:
3895 : IN_P
3896 : | OUT_P
3897 : | INOUT
3898 : | IN_P OUT_P
3899 : | VARIADIC
3900 : ;
3901 :
3902 :
3903 : param_name:
3904 : type_function_name
3905 : ;
3906 :
3907 :
3908 : func_return:
3909 : func_type
3910 : ;
3911 :
3912 :
3913 : func_type:
3914 : Typename
3915 : | type_function_name attrs '%' TYPE_P
3916 : | SETOF type_function_name attrs '%' TYPE_P
3917 : ;
3918 :
3919 :
3920 : func_arg_with_default:
3921 : func_arg
3922 : | func_arg DEFAULT a_expr
3923 : | func_arg '=' a_expr
3924 : ;
3925 :
3926 :
3927 : aggr_arg:
3928 : func_arg
3929 : ;
3930 :
3931 :
3932 : aggr_args:
3933 : '(' '*' ')'
3934 : | '(' aggr_args_list ')'
3935 : | '(' ORDER BY aggr_args_list ')'
3936 : | '(' aggr_args_list ORDER BY aggr_args_list ')'
3937 : ;
3938 :
3939 :
3940 : aggr_args_list:
3941 : aggr_arg
3942 : | aggr_args_list ',' aggr_arg
3943 : ;
3944 :
3945 :
3946 : aggregate_with_argtypes:
3947 : func_name aggr_args
3948 : ;
3949 :
3950 :
3951 : aggregate_with_argtypes_list:
3952 : aggregate_with_argtypes
3953 : | aggregate_with_argtypes_list ',' aggregate_with_argtypes
3954 : ;
3955 :
3956 :
3957 : opt_createfunc_opt_list:
3958 : createfunc_opt_list
3959 : |
3960 : ;
3961 :
3962 :
3963 : createfunc_opt_list:
3964 : createfunc_opt_item
3965 : | createfunc_opt_list createfunc_opt_item
3966 : ;
3967 :
3968 :
3969 : common_func_opt_item:
3970 : CALLED ON NULL_P INPUT_P
3971 : | RETURNS NULL_P ON NULL_P INPUT_P
3972 : | STRICT_P
3973 : | IMMUTABLE
3974 : | STABLE
3975 : | VOLATILE
3976 : | EXTERNAL SECURITY DEFINER
3977 : | EXTERNAL SECURITY INVOKER
3978 : | SECURITY DEFINER
3979 : | SECURITY INVOKER
3980 : | LEAKPROOF
3981 : | NOT LEAKPROOF
3982 : | COST NumericOnly
3983 : | ROWS NumericOnly
3984 : | SUPPORT any_name
3985 : | FunctionSetResetClause
3986 : | PARALLEL ColId
3987 : ;
3988 :
3989 :
3990 : createfunc_opt_item:
3991 : AS func_as
3992 : | LANGUAGE NonReservedWord_or_Sconst
3993 : | TRANSFORM transform_type_list
3994 : | WINDOW
3995 : | common_func_opt_item
3996 : ;
3997 :
3998 :
3999 : func_as:
4000 : ecpg_sconst
4001 : | ecpg_sconst ',' ecpg_sconst
4002 : ;
4003 :
4004 :
4005 : ReturnStmt:
4006 : RETURN a_expr
4007 : ;
4008 :
4009 :
4010 : opt_routine_body:
4011 : ReturnStmt
4012 : | BEGIN_P ATOMIC routine_body_stmt_list END_P
4013 : |
4014 : ;
4015 :
4016 :
4017 : routine_body_stmt_list:
4018 : routine_body_stmt_list routine_body_stmt ';'
4019 : |
4020 : ;
4021 :
4022 :
4023 : routine_body_stmt:
4024 : stmt
4025 : | ReturnStmt
4026 : ;
4027 :
4028 :
4029 : transform_type_list:
4030 : FOR TYPE_P Typename
4031 : | transform_type_list ',' FOR TYPE_P Typename
4032 : ;
4033 :
4034 :
4035 : opt_definition:
4036 : WITH definition
4037 : |
4038 : ;
4039 :
4040 :
4041 : table_func_column:
4042 : param_name func_type
4043 : ;
4044 :
4045 :
4046 : table_func_column_list:
4047 : table_func_column
4048 : | table_func_column_list ',' table_func_column
4049 : ;
4050 :
4051 :
4052 : AlterFunctionStmt:
4053 : ALTER FUNCTION function_with_argtypes alterfunc_opt_list opt_restrict
4054 : | ALTER PROCEDURE function_with_argtypes alterfunc_opt_list opt_restrict
4055 : | ALTER ROUTINE function_with_argtypes alterfunc_opt_list opt_restrict
4056 : ;
4057 :
4058 :
4059 : alterfunc_opt_list:
4060 : common_func_opt_item
4061 : | alterfunc_opt_list common_func_opt_item
4062 : ;
4063 :
4064 :
4065 : opt_restrict:
4066 : RESTRICT
4067 : |
4068 : ;
4069 :
4070 :
4071 : RemoveFuncStmt:
4072 : DROP FUNCTION function_with_argtypes_list opt_drop_behavior
4073 : | DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior
4074 : | DROP PROCEDURE function_with_argtypes_list opt_drop_behavior
4075 : | DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
4076 : | DROP ROUTINE function_with_argtypes_list opt_drop_behavior
4077 : | DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
4078 : ;
4079 :
4080 :
4081 : RemoveAggrStmt:
4082 : DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior
4083 : | DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior
4084 : ;
4085 :
4086 :
4087 : RemoveOperStmt:
4088 : DROP OPERATOR operator_with_argtypes_list opt_drop_behavior
4089 : | DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior
4090 : ;
4091 :
4092 :
4093 : oper_argtypes:
4094 : '(' Typename ')'
4095 : | '(' Typename ',' Typename ')'
4096 : | '(' NONE ',' Typename ')'
4097 : | '(' Typename ',' NONE ')'
4098 : ;
4099 :
4100 :
4101 : any_operator:
4102 : all_Op
4103 : | ColId '.' any_operator
4104 : ;
4105 :
4106 :
4107 : operator_with_argtypes_list:
4108 : operator_with_argtypes
4109 : | operator_with_argtypes_list ',' operator_with_argtypes
4110 : ;
4111 :
4112 :
4113 : operator_with_argtypes:
4114 : any_operator oper_argtypes
4115 : ;
4116 :
4117 :
4118 : DoStmt:
4119 : DO dostmt_opt_list
4120 : ;
4121 :
4122 :
4123 : dostmt_opt_list:
4124 : dostmt_opt_item
4125 : | dostmt_opt_list dostmt_opt_item
4126 : ;
4127 :
4128 :
4129 : dostmt_opt_item:
4130 : ecpg_sconst
4131 : | LANGUAGE NonReservedWord_or_Sconst
4132 : ;
4133 :
4134 :
4135 : CreateCastStmt:
4136 : CREATE CAST '(' Typename AS Typename ')' WITH FUNCTION function_with_argtypes cast_context
4137 : | CREATE CAST '(' Typename AS Typename ')' WITHOUT FUNCTION cast_context
4138 : | CREATE CAST '(' Typename AS Typename ')' WITH INOUT cast_context
4139 : ;
4140 :
4141 :
4142 : cast_context:
4143 : AS IMPLICIT_P
4144 : | AS ASSIGNMENT
4145 : |
4146 : ;
4147 :
4148 :
4149 : DropCastStmt:
4150 : DROP CAST opt_if_exists '(' Typename AS Typename ')' opt_drop_behavior
4151 : ;
4152 :
4153 :
4154 : opt_if_exists:
4155 : IF_P EXISTS
4156 : |
4157 : ;
4158 :
4159 :
4160 : CreateTransformStmt:
4161 : CREATE opt_or_replace TRANSFORM FOR Typename LANGUAGE name '(' transform_element_list ')'
4162 : ;
4163 :
4164 :
4165 : transform_element_list:
4166 : FROM SQL_P WITH FUNCTION function_with_argtypes ',' TO SQL_P WITH FUNCTION function_with_argtypes
4167 : | TO SQL_P WITH FUNCTION function_with_argtypes ',' FROM SQL_P WITH FUNCTION function_with_argtypes
4168 : | FROM SQL_P WITH FUNCTION function_with_argtypes
4169 : | TO SQL_P WITH FUNCTION function_with_argtypes
4170 : ;
4171 :
4172 :
4173 : DropTransformStmt:
4174 : DROP TRANSFORM opt_if_exists FOR Typename LANGUAGE name opt_drop_behavior
4175 : ;
4176 :
4177 :
4178 : ReindexStmt:
4179 : REINDEX opt_reindex_option_list reindex_target_relation opt_concurrently qualified_name
4180 : | REINDEX opt_reindex_option_list SCHEMA opt_concurrently name
4181 : | REINDEX opt_reindex_option_list reindex_target_all opt_concurrently opt_single_name
4182 : ;
4183 :
4184 :
4185 : reindex_target_relation:
4186 : INDEX
4187 : | TABLE
4188 : ;
4189 :
4190 :
4191 : reindex_target_all:
4192 : SYSTEM_P
4193 : | DATABASE
4194 : ;
4195 :
4196 :
4197 : opt_reindex_option_list:
4198 : '(' utility_option_list ')'
4199 : |
4200 : ;
4201 :
4202 :
4203 : AlterTblSpcStmt:
4204 : ALTER TABLESPACE name SET reloptions
4205 : | ALTER TABLESPACE name RESET reloptions
4206 : ;
4207 :
4208 :
4209 : RenameStmt:
4210 : ALTER AGGREGATE aggregate_with_argtypes RENAME TO name
4211 : | ALTER COLLATION any_name RENAME TO name
4212 : | ALTER CONVERSION_P any_name RENAME TO name
4213 : | ALTER DATABASE name RENAME TO name
4214 : | ALTER DOMAIN_P any_name RENAME TO name
4215 : | ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name
4216 : | ALTER FOREIGN DATA_P WRAPPER name RENAME TO name
4217 : | ALTER FUNCTION function_with_argtypes RENAME TO name
4218 : | ALTER GROUP_P RoleId RENAME TO RoleId
4219 : | ALTER opt_procedural LANGUAGE name RENAME TO name
4220 : | ALTER OPERATOR CLASS any_name USING name RENAME TO name
4221 : | ALTER OPERATOR FAMILY any_name USING name RENAME TO name
4222 : | ALTER POLICY name ON qualified_name RENAME TO name
4223 : | ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name
4224 : | ALTER PROCEDURE function_with_argtypes RENAME TO name
4225 : | ALTER PUBLICATION name RENAME TO name
4226 : | ALTER ROUTINE function_with_argtypes RENAME TO name
4227 : | ALTER SCHEMA name RENAME TO name
4228 : | ALTER SERVER name RENAME TO name
4229 : | ALTER SUBSCRIPTION name RENAME TO name
4230 : | ALTER TABLE relation_expr RENAME TO name
4231 : | ALTER TABLE IF_P EXISTS relation_expr RENAME TO name
4232 : | ALTER SEQUENCE qualified_name RENAME TO name
4233 : | ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name
4234 : | ALTER VIEW qualified_name RENAME TO name
4235 : | ALTER VIEW IF_P EXISTS qualified_name RENAME TO name
4236 : | ALTER MATERIALIZED VIEW qualified_name RENAME TO name
4237 : | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name
4238 : | ALTER INDEX qualified_name RENAME TO name
4239 : | ALTER INDEX IF_P EXISTS qualified_name RENAME TO name
4240 : | ALTER FOREIGN TABLE relation_expr RENAME TO name
4241 : | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name
4242 : | ALTER TABLE relation_expr RENAME opt_column name TO name
4243 : | ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
4244 : | ALTER VIEW qualified_name RENAME opt_column name TO name
4245 : | ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
4246 : | ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name
4247 : | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
4248 : | ALTER TABLE relation_expr RENAME CONSTRAINT name TO name
4249 : | ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name
4250 : | ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name
4251 : | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
4252 : | ALTER RULE name ON qualified_name RENAME TO name
4253 : | ALTER TRIGGER name ON qualified_name RENAME TO name
4254 : | ALTER EVENT TRIGGER name RENAME TO name
4255 : | ALTER ROLE RoleId RENAME TO RoleId
4256 : | ALTER USER RoleId RENAME TO RoleId
4257 : | ALTER TABLESPACE name RENAME TO name
4258 : | ALTER STATISTICS any_name RENAME TO name
4259 : | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name
4260 : | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name
4261 : | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name
4262 : | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name
4263 : | ALTER TYPE_P any_name RENAME TO name
4264 : | ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior
4265 : ;
4266 :
4267 :
4268 : opt_column:
4269 : COLUMN
4270 : |
4271 : ;
4272 :
4273 :
4274 : opt_set_data:
4275 : SET DATA_P
4276 : |
4277 : ;
4278 :
4279 :
4280 : AlterObjectDependsStmt:
4281 : ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name
4282 : | ALTER PROCEDURE function_with_argtypes opt_no DEPENDS ON EXTENSION name
4283 : | ALTER ROUTINE function_with_argtypes opt_no DEPENDS ON EXTENSION name
4284 : | ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name
4285 : | ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name
4286 : | ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name
4287 : ;
4288 :
4289 :
4290 : opt_no:
4291 : NO
4292 : |
4293 : ;
4294 :
4295 :
4296 : AlterObjectSchemaStmt:
4297 : ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name
4298 : | ALTER COLLATION any_name SET SCHEMA name
4299 : | ALTER CONVERSION_P any_name SET SCHEMA name
4300 : | ALTER DOMAIN_P any_name SET SCHEMA name
4301 : | ALTER EXTENSION name SET SCHEMA name
4302 : | ALTER FUNCTION function_with_argtypes SET SCHEMA name
4303 : | ALTER OPERATOR operator_with_argtypes SET SCHEMA name
4304 : | ALTER OPERATOR CLASS any_name USING name SET SCHEMA name
4305 : | ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name
4306 : | ALTER PROCEDURE function_with_argtypes SET SCHEMA name
4307 : | ALTER ROUTINE function_with_argtypes SET SCHEMA name
4308 : | ALTER TABLE relation_expr SET SCHEMA name
4309 : | ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name
4310 : | ALTER STATISTICS any_name SET SCHEMA name
4311 : | ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name
4312 : | ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name
4313 : | ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name
4314 : | ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name
4315 : | ALTER SEQUENCE qualified_name SET SCHEMA name
4316 : | ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name
4317 : | ALTER VIEW qualified_name SET SCHEMA name
4318 : | ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name
4319 : | ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name
4320 : | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name
4321 : | ALTER FOREIGN TABLE relation_expr SET SCHEMA name
4322 : | ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name
4323 : | ALTER TYPE_P any_name SET SCHEMA name
4324 : ;
4325 :
4326 :
4327 : AlterOperatorStmt:
4328 : ALTER OPERATOR operator_with_argtypes SET '(' operator_def_list ')'
4329 : ;
4330 :
4331 :
4332 : operator_def_list:
4333 : operator_def_elem
4334 : | operator_def_list ',' operator_def_elem
4335 : ;
4336 :
4337 :
4338 : operator_def_elem:
4339 : ColLabel '=' NONE
4340 : | ColLabel '=' operator_def_arg
4341 : | ColLabel
4342 : ;
4343 :
4344 :
4345 : operator_def_arg:
4346 : func_type
4347 : | reserved_keyword
4348 : | qual_all_Op
4349 : | NumericOnly
4350 : | ecpg_sconst
4351 : ;
4352 :
4353 :
4354 : AlterTypeStmt:
4355 : ALTER TYPE_P any_name SET '(' operator_def_list ')'
4356 : ;
4357 :
4358 :
4359 : AlterOwnerStmt:
4360 : ALTER AGGREGATE aggregate_with_argtypes OWNER TO RoleSpec
4361 : | ALTER COLLATION any_name OWNER TO RoleSpec
4362 : | ALTER CONVERSION_P any_name OWNER TO RoleSpec
4363 : | ALTER DATABASE name OWNER TO RoleSpec
4364 : | ALTER DOMAIN_P any_name OWNER TO RoleSpec
4365 : | ALTER FUNCTION function_with_argtypes OWNER TO RoleSpec
4366 : | ALTER opt_procedural LANGUAGE name OWNER TO RoleSpec
4367 : | ALTER LARGE_P OBJECT_P NumericOnly OWNER TO RoleSpec
4368 : | ALTER OPERATOR operator_with_argtypes OWNER TO RoleSpec
4369 : | ALTER OPERATOR CLASS any_name USING name OWNER TO RoleSpec
4370 : | ALTER OPERATOR FAMILY any_name USING name OWNER TO RoleSpec
4371 : | ALTER PROCEDURE function_with_argtypes OWNER TO RoleSpec
4372 : | ALTER ROUTINE function_with_argtypes OWNER TO RoleSpec
4373 : | ALTER SCHEMA name OWNER TO RoleSpec
4374 : | ALTER TYPE_P any_name OWNER TO RoleSpec
4375 : | ALTER TABLESPACE name OWNER TO RoleSpec
4376 : | ALTER STATISTICS any_name OWNER TO RoleSpec
4377 : | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO RoleSpec
4378 : | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO RoleSpec
4379 : | ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleSpec
4380 : | ALTER SERVER name OWNER TO RoleSpec
4381 : | ALTER EVENT TRIGGER name OWNER TO RoleSpec
4382 : | ALTER PUBLICATION name OWNER TO RoleSpec
4383 : | ALTER SUBSCRIPTION name OWNER TO RoleSpec
4384 : ;
4385 :
4386 :
4387 : CreatePublicationStmt:
4388 : CREATE PUBLICATION name opt_definition
4389 : | CREATE PUBLICATION name FOR ALL TABLES opt_definition
4390 : | CREATE PUBLICATION name FOR pub_obj_list opt_definition
4391 : ;
4392 :
4393 :
4394 : PublicationObjSpec:
4395 : TABLE relation_expr opt_column_list OptWhereClause
4396 : | TABLES IN_P SCHEMA ColId
4397 : | TABLES IN_P SCHEMA CURRENT_SCHEMA
4398 : | ColId opt_column_list OptWhereClause
4399 : | ColId indirection opt_column_list OptWhereClause
4400 : | extended_relation_expr opt_column_list OptWhereClause
4401 : | CURRENT_SCHEMA
4402 : ;
4403 :
4404 :
4405 : pub_obj_list:
4406 : PublicationObjSpec
4407 : | pub_obj_list ',' PublicationObjSpec
4408 : ;
4409 :
4410 :
4411 : AlterPublicationStmt:
4412 : ALTER PUBLICATION name SET definition
4413 : | ALTER PUBLICATION name ADD_P pub_obj_list
4414 : | ALTER PUBLICATION name SET pub_obj_list
4415 : | ALTER PUBLICATION name DROP pub_obj_list
4416 : ;
4417 :
4418 :
4419 : CreateSubscriptionStmt:
4420 : CREATE SUBSCRIPTION name CONNECTION ecpg_sconst PUBLICATION name_list opt_definition
4421 : ;
4422 :
4423 :
4424 : AlterSubscriptionStmt:
4425 : ALTER SUBSCRIPTION name SET definition
4426 : | ALTER SUBSCRIPTION name CONNECTION ecpg_sconst
4427 : | ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition
4428 : | ALTER SUBSCRIPTION name ADD_P PUBLICATION name_list opt_definition
4429 : | ALTER SUBSCRIPTION name DROP PUBLICATION name_list opt_definition
4430 : | ALTER SUBSCRIPTION name SET PUBLICATION name_list opt_definition
4431 : | ALTER SUBSCRIPTION name ENABLE_P
4432 : | ALTER SUBSCRIPTION name DISABLE_P
4433 : | ALTER SUBSCRIPTION name SKIP definition
4434 : ;
4435 :
4436 :
4437 : DropSubscriptionStmt:
4438 : DROP SUBSCRIPTION name opt_drop_behavior
4439 : | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior
4440 : ;
4441 :
4442 :
4443 : RuleStmt:
4444 : CREATE opt_or_replace RULE name AS ON event TO qualified_name where_clause DO opt_instead RuleActionList
4445 : ;
4446 :
4447 :
4448 : RuleActionList:
4449 : NOTHING
4450 : | RuleActionStmt
4451 : | '(' RuleActionMulti ')'
4452 : ;
4453 :
4454 :
4455 : RuleActionMulti:
4456 : RuleActionMulti ';' RuleActionStmtOrEmpty
4457 : | RuleActionStmtOrEmpty
4458 : ;
4459 :
4460 :
4461 : RuleActionStmt:
4462 : SelectStmt
4463 : | InsertStmt
4464 : | UpdateStmt
4465 : | DeleteStmt
4466 : | NotifyStmt
4467 : ;
4468 :
4469 :
4470 : RuleActionStmtOrEmpty:
4471 : RuleActionStmt
4472 : |
4473 : ;
4474 :
4475 :
4476 : event:
4477 : SELECT
4478 : | UPDATE
4479 : | DELETE_P
4480 : | INSERT
4481 : ;
4482 :
4483 :
4484 : opt_instead:
4485 : INSTEAD
4486 : | ALSO
4487 : |
4488 : ;
4489 :
4490 :
4491 : NotifyStmt:
4492 : NOTIFY ColId notify_payload
4493 : ;
4494 :
4495 :
4496 : notify_payload:
4497 : ',' ecpg_sconst
4498 : |
4499 : ;
4500 :
4501 :
4502 : ListenStmt:
4503 : LISTEN ColId
4504 : ;
4505 :
4506 :
4507 : UnlistenStmt:
4508 : UNLISTEN ColId
4509 : | UNLISTEN '*'
4510 : ;
4511 :
4512 :
4513 : TransactionStmt:
4514 : ABORT_P opt_transaction opt_transaction_chain
4515 : | START TRANSACTION transaction_mode_list_or_empty
4516 : | COMMIT opt_transaction opt_transaction_chain
4517 : | ROLLBACK opt_transaction opt_transaction_chain
4518 : | SAVEPOINT ColId
4519 : | RELEASE SAVEPOINT ColId
4520 : | RELEASE ColId
4521 : | ROLLBACK opt_transaction TO SAVEPOINT ColId
4522 : | ROLLBACK opt_transaction TO ColId
4523 : | PREPARE TRANSACTION ecpg_sconst
4524 : | COMMIT PREPARED ecpg_sconst
4525 : | ROLLBACK PREPARED ecpg_sconst
4526 : ;
4527 :
4528 :
4529 : TransactionStmtLegacy:
4530 : BEGIN_P opt_transaction transaction_mode_list_or_empty
4531 : | END_P opt_transaction opt_transaction_chain
4532 : ;
4533 :
4534 :
4535 : opt_transaction:
4536 : WORK
4537 : | TRANSACTION
4538 : |
4539 : ;
4540 :
4541 :
4542 : transaction_mode_item:
4543 : ISOLATION LEVEL iso_level
4544 : | READ ONLY
4545 : | READ WRITE
4546 : | DEFERRABLE
4547 : | NOT DEFERRABLE
4548 : ;
4549 :
4550 :
4551 : transaction_mode_list:
4552 : transaction_mode_item
4553 : | transaction_mode_list ',' transaction_mode_item
4554 : | transaction_mode_list transaction_mode_item
4555 : ;
4556 :
4557 :
4558 : transaction_mode_list_or_empty:
4559 : transaction_mode_list
4560 : |
4561 : ;
4562 :
4563 :
4564 : opt_transaction_chain:
4565 : AND CHAIN
4566 : | AND NO CHAIN
4567 : |
4568 : ;
4569 :
4570 :
4571 : ViewStmt:
4572 : CREATE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option
4573 : | CREATE OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option
4574 : | CREATE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option
4575 : | CREATE OR REPLACE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option
4576 : ;
4577 :
4578 :
4579 : opt_check_option:
4580 : WITH CHECK OPTION
4581 : | WITH CASCADED CHECK OPTION
4582 : | WITH LOCAL CHECK OPTION
4583 : |
4584 : ;
4585 :
4586 :
4587 : LoadStmt:
4588 : LOAD file_name
4589 : ;
4590 :
4591 :
4592 : CreatedbStmt:
4593 : CREATE DATABASE name opt_with createdb_opt_list
4594 : ;
4595 :
4596 :
4597 : createdb_opt_list:
4598 : createdb_opt_items
4599 : |
4600 : ;
4601 :
4602 :
4603 : createdb_opt_items:
4604 : createdb_opt_item
4605 : | createdb_opt_items createdb_opt_item
4606 : ;
4607 :
4608 :
4609 : createdb_opt_item:
4610 : createdb_opt_name opt_equal NumericOnly
4611 : | createdb_opt_name opt_equal opt_boolean_or_string
4612 : | createdb_opt_name opt_equal DEFAULT
4613 : ;
4614 :
4615 :
4616 : createdb_opt_name:
4617 : ecpg_ident
4618 : | CONNECTION LIMIT
4619 : | ENCODING
4620 : | LOCATION
4621 : | OWNER
4622 : | TABLESPACE
4623 : | TEMPLATE
4624 : ;
4625 :
4626 :
4627 : opt_equal:
4628 : '='
4629 : |
4630 : ;
4631 :
4632 :
4633 : AlterDatabaseStmt:
4634 : ALTER DATABASE name WITH createdb_opt_list
4635 : | ALTER DATABASE name createdb_opt_list
4636 : | ALTER DATABASE name SET TABLESPACE name
4637 : | ALTER DATABASE name REFRESH COLLATION VERSION_P
4638 : ;
4639 :
4640 :
4641 : AlterDatabaseSetStmt:
4642 : ALTER DATABASE name SetResetClause
4643 : ;
4644 :
4645 :
4646 : DropdbStmt:
4647 : DROP DATABASE name
4648 : | DROP DATABASE IF_P EXISTS name
4649 : | DROP DATABASE name opt_with '(' drop_option_list ')'
4650 : | DROP DATABASE IF_P EXISTS name opt_with '(' drop_option_list ')'
4651 : ;
4652 :
4653 :
4654 : drop_option_list:
4655 : drop_option
4656 : | drop_option_list ',' drop_option
4657 : ;
4658 :
4659 :
4660 : drop_option:
4661 : FORCE
4662 : ;
4663 :
4664 :
4665 : AlterCollationStmt:
4666 : ALTER COLLATION any_name REFRESH VERSION_P
4667 : ;
4668 :
4669 :
4670 : AlterSystemStmt:
4671 : ALTER SYSTEM_P SET generic_set
4672 : | ALTER SYSTEM_P RESET generic_reset
4673 : ;
4674 :
4675 :
4676 : CreateDomainStmt:
4677 : CREATE DOMAIN_P any_name opt_as Typename ColQualList
4678 : ;
4679 :
4680 :
4681 : AlterDomainStmt:
4682 : ALTER DOMAIN_P any_name alter_column_default
4683 : | ALTER DOMAIN_P any_name DROP NOT NULL_P
4684 : | ALTER DOMAIN_P any_name SET NOT NULL_P
4685 : | ALTER DOMAIN_P any_name ADD_P DomainConstraint
4686 : | ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
4687 : | ALTER DOMAIN_P any_name DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
4688 : | ALTER DOMAIN_P any_name VALIDATE CONSTRAINT name
4689 : ;
4690 :
4691 :
4692 : opt_as:
4693 : AS
4694 : |
4695 : ;
4696 :
4697 :
4698 : AlterTSDictionaryStmt:
4699 : ALTER TEXT_P SEARCH DICTIONARY any_name definition
4700 : ;
4701 :
4702 :
4703 : AlterTSConfigurationStmt:
4704 : ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list
4705 : | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list
4706 : | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name
4707 : | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name
4708 : | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
4709 : | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
4710 : ;
4711 :
4712 :
4713 : any_with:
4714 : WITH
4715 : | WITH_LA
4716 : ;
4717 :
4718 :
4719 : CreateConversionStmt:
4720 : CREATE opt_default CONVERSION_P any_name FOR ecpg_sconst TO ecpg_sconst FROM any_name
4721 : ;
4722 :
4723 :
4724 : ClusterStmt:
4725 : CLUSTER '(' utility_option_list ')' qualified_name cluster_index_specification
4726 : | CLUSTER '(' utility_option_list ')'
4727 : | CLUSTER opt_verbose qualified_name cluster_index_specification
4728 : | CLUSTER opt_verbose
4729 : | CLUSTER opt_verbose name ON qualified_name
4730 : ;
4731 :
4732 :
4733 : cluster_index_specification:
4734 : USING name
4735 : |
4736 : ;
4737 :
4738 :
4739 : VacuumStmt:
4740 : VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list
4741 : | VACUUM '(' utility_option_list ')' opt_vacuum_relation_list
4742 : ;
4743 :
4744 :
4745 : AnalyzeStmt:
4746 : analyze_keyword opt_verbose opt_vacuum_relation_list
4747 : | analyze_keyword '(' utility_option_list ')' opt_vacuum_relation_list
4748 : ;
4749 :
4750 :
4751 : utility_option_list:
4752 : utility_option_elem
4753 : | utility_option_list ',' utility_option_elem
4754 : ;
4755 :
4756 :
4757 : analyze_keyword:
4758 : ANALYZE
4759 : | ANALYSE
4760 : ;
4761 :
4762 :
4763 : utility_option_elem:
4764 : utility_option_name utility_option_arg
4765 : ;
4766 :
4767 :
4768 : utility_option_name:
4769 : NonReservedWord
4770 : | analyze_keyword
4771 : | FORMAT_LA
4772 : ;
4773 :
4774 :
4775 : utility_option_arg:
4776 : opt_boolean_or_string
4777 : | NumericOnly
4778 : |
4779 : ;
4780 :
4781 :
4782 : opt_analyze:
4783 : analyze_keyword
4784 : |
4785 : ;
4786 :
4787 :
4788 : opt_verbose:
4789 : VERBOSE
4790 : |
4791 : ;
4792 :
4793 :
4794 : opt_full:
4795 : FULL
4796 : |
4797 : ;
4798 :
4799 :
4800 : opt_freeze:
4801 : FREEZE
4802 : |
4803 : ;
4804 :
4805 :
4806 : opt_name_list:
4807 : '(' name_list ')'
4808 : |
4809 : ;
4810 :
4811 :
4812 : vacuum_relation:
4813 : relation_expr opt_name_list
4814 : ;
4815 :
4816 :
4817 : vacuum_relation_list:
4818 : vacuum_relation
4819 : | vacuum_relation_list ',' vacuum_relation
4820 : ;
4821 :
4822 :
4823 : opt_vacuum_relation_list:
4824 : vacuum_relation_list
4825 : |
4826 : ;
4827 :
4828 :
4829 : ExplainStmt:
4830 : EXPLAIN ExplainableStmt
4831 : | EXPLAIN analyze_keyword opt_verbose ExplainableStmt
4832 : | EXPLAIN VERBOSE ExplainableStmt
4833 : | EXPLAIN '(' utility_option_list ')' ExplainableStmt
4834 : ;
4835 :
4836 :
4837 : ExplainableStmt:
4838 : SelectStmt
4839 : | InsertStmt
4840 : | UpdateStmt
4841 : | DeleteStmt
4842 : | MergeStmt
4843 : | DeclareCursorStmt
4844 : | CreateAsStmt
4845 : | CreateMatViewStmt
4846 : | RefreshMatViewStmt
4847 : | ExecuteStmt
4848 : {
4849 0 : @$ = $1.name;
4850 : }
4851 : ;
4852 :
4853 :
4854 : PrepareStmt:
4855 : PREPARE prepared_name prep_type_clause AS PreparableStmt
4856 : {
4857 12 : $$.name = @2;
4858 12 : $$.type = @3;
4859 12 : $$.stmt = @5;
4860 : }
4861 : | PREPARE prepared_name FROM execstring
4862 : {
4863 94 : $$.name = @2;
4864 94 : $$.type = NULL;
4865 94 : $$.stmt = @4;
4866 : }
4867 : ;
4868 :
4869 :
4870 : prep_type_clause:
4871 : '(' type_list ')'
4872 : |
4873 : ;
4874 :
4875 :
4876 : PreparableStmt:
4877 : SelectStmt
4878 : | InsertStmt
4879 : | UpdateStmt
4880 : | DeleteStmt
4881 : | MergeStmt
4882 : ;
4883 :
4884 :
4885 : ExecuteStmt:
4886 : EXECUTE prepared_name execute_param_clause execute_rest
4887 : {
4888 66 : $$.name = @2;
4889 66 : $$.type = @3;
4890 : }
4891 : | CREATE OptTemp TABLE create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
4892 : {
4893 0 : $$.name = @$;
4894 : }
4895 : | CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
4896 : {
4897 0 : $$.name = @$;
4898 : }
4899 : ;
4900 :
4901 :
4902 : execute_param_clause:
4903 : '(' expr_list ')'
4904 : |
4905 : ;
4906 :
4907 :
4908 : InsertStmt:
4909 : opt_with_clause INSERT INTO insert_target insert_rest opt_on_conflict returning_clause
4910 : ;
4911 :
4912 :
4913 : insert_target:
4914 : qualified_name
4915 : | qualified_name AS ColId
4916 : ;
4917 :
4918 :
4919 : insert_rest:
4920 : SelectStmt
4921 : | OVERRIDING override_kind VALUE_P SelectStmt
4922 : | '(' insert_column_list ')' SelectStmt
4923 : | '(' insert_column_list ')' OVERRIDING override_kind VALUE_P SelectStmt
4924 : | DEFAULT VALUES
4925 : ;
4926 :
4927 :
4928 : override_kind:
4929 : USER
4930 : | SYSTEM_P
4931 : ;
4932 :
4933 :
4934 : insert_column_list:
4935 : insert_column_item
4936 : | insert_column_list ',' insert_column_item
4937 : ;
4938 :
4939 :
4940 : insert_column_item:
4941 : ColId opt_indirection
4942 : ;
4943 :
4944 :
4945 : opt_on_conflict:
4946 : ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list where_clause
4947 : | ON CONFLICT opt_conf_expr DO NOTHING
4948 : |
4949 : ;
4950 :
4951 :
4952 : opt_conf_expr:
4953 : '(' index_params ')' where_clause
4954 : | ON CONSTRAINT name
4955 : |
4956 : ;
4957 :
4958 :
4959 : returning_clause:
4960 : RETURNING returning_with_clause target_list opt_ecpg_into
4961 : |
4962 : ;
4963 :
4964 :
4965 : returning_with_clause:
4966 : WITH '(' returning_options ')'
4967 : |
4968 : ;
4969 :
4970 :
4971 : returning_options:
4972 : returning_option
4973 : | returning_options ',' returning_option
4974 : ;
4975 :
4976 :
4977 : returning_option:
4978 : returning_option_kind AS ColId
4979 : ;
4980 :
4981 :
4982 : returning_option_kind:
4983 : OLD
4984 : | NEW
4985 : ;
4986 :
4987 :
4988 : DeleteStmt:
4989 : opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause
4990 : ;
4991 :
4992 :
4993 : using_clause:
4994 : USING from_list
4995 : |
4996 : ;
4997 :
4998 :
4999 : LockStmt:
5000 : LOCK_P opt_table relation_expr_list opt_lock opt_nowait
5001 : ;
5002 :
5003 :
5004 : opt_lock:
5005 : IN_P lock_type MODE
5006 : |
5007 : ;
5008 :
5009 :
5010 : lock_type:
5011 : ACCESS SHARE
5012 : | ROW SHARE
5013 : | ROW EXCLUSIVE
5014 : | SHARE UPDATE EXCLUSIVE
5015 : | SHARE
5016 : | SHARE ROW EXCLUSIVE
5017 : | EXCLUSIVE
5018 : | ACCESS EXCLUSIVE
5019 : ;
5020 :
5021 :
5022 : opt_nowait:
5023 : NOWAIT
5024 : |
5025 : ;
5026 :
5027 :
5028 : opt_nowait_or_skip:
5029 : NOWAIT
5030 : | SKIP LOCKED
5031 : |
5032 : ;
5033 :
5034 :
5035 : UpdateStmt:
5036 : opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list from_clause where_or_current_clause returning_clause
5037 : ;
5038 :
5039 :
5040 : set_clause_list:
5041 : set_clause
5042 : | set_clause_list ',' set_clause
5043 : ;
5044 :
5045 :
5046 : set_clause:
5047 : set_target '=' a_expr
5048 : | '(' set_target_list ')' '=' a_expr
5049 : ;
5050 :
5051 :
5052 : set_target:
5053 : ColId opt_indirection
5054 : ;
5055 :
5056 :
5057 : set_target_list:
5058 : set_target
5059 : | set_target_list ',' set_target
5060 : ;
5061 :
5062 :
5063 : MergeStmt:
5064 : opt_with_clause MERGE INTO relation_expr_opt_alias USING table_ref ON a_expr merge_when_list returning_clause
5065 : ;
5066 :
5067 :
5068 : merge_when_list:
5069 : merge_when_clause
5070 : | merge_when_list merge_when_clause
5071 : ;
5072 :
5073 :
5074 : merge_when_clause:
5075 : merge_when_tgt_matched opt_merge_when_condition THEN merge_update
5076 : | merge_when_tgt_matched opt_merge_when_condition THEN merge_delete
5077 : | merge_when_tgt_not_matched opt_merge_when_condition THEN merge_insert
5078 : | merge_when_tgt_matched opt_merge_when_condition THEN DO NOTHING
5079 : | merge_when_tgt_not_matched opt_merge_when_condition THEN DO NOTHING
5080 : ;
5081 :
5082 :
5083 : merge_when_tgt_matched:
5084 : WHEN MATCHED
5085 : | WHEN NOT MATCHED BY SOURCE
5086 : ;
5087 :
5088 :
5089 : merge_when_tgt_not_matched:
5090 : WHEN NOT MATCHED
5091 : | WHEN NOT MATCHED BY TARGET
5092 : ;
5093 :
5094 :
5095 : opt_merge_when_condition:
5096 : AND a_expr
5097 : |
5098 : ;
5099 :
5100 :
5101 : merge_update:
5102 : UPDATE SET set_clause_list
5103 : ;
5104 :
5105 :
5106 : merge_delete:
5107 : DELETE_P
5108 : ;
5109 :
5110 :
5111 : merge_insert:
5112 : INSERT merge_values_clause
5113 : | INSERT OVERRIDING override_kind VALUE_P merge_values_clause
5114 : | INSERT '(' insert_column_list ')' merge_values_clause
5115 : | INSERT '(' insert_column_list ')' OVERRIDING override_kind VALUE_P merge_values_clause
5116 : | INSERT DEFAULT VALUES
5117 : ;
5118 :
5119 :
5120 : merge_values_clause:
5121 : VALUES '(' expr_list ')'
5122 : ;
5123 :
5124 :
5125 : DeclareCursorStmt:
5126 : DECLARE cursor_name cursor_options CURSOR opt_hold FOR SelectStmt
5127 : {
5128 : struct cursor *ptr,
5129 : *this;
5130 34 : const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
5131 : char *comment,
5132 : *c1,
5133 : *c2;
5134 34 : int (*strcmp_fn) (const char *, const char *) = ((@2[0] == ':' || @2[0] == '"') ? strcmp : pg_strcasecmp);
5135 :
5136 34 : if (INFORMIX_MODE && pg_strcasecmp(@2, "database") == 0)
5137 0 : mmfatal(PARSE_ERROR, "\"database\" cannot be used as cursor name in INFORMIX mode");
5138 :
5139 46 : for (ptr = cur; ptr != NULL; ptr = ptr->next)
5140 : {
5141 12 : if (strcmp_fn(@2, ptr->name) == 0)
5142 : {
5143 0 : if (@2[0] == ':')
5144 0 : mmerror(PARSE_ERROR, ET_ERROR, "using variable \"%s\" in different declare statements is not supported", @2 + 1);
5145 : else
5146 0 : mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", @2);
5147 : }
5148 : }
5149 :
5150 34 : this = (struct cursor *) mm_alloc(sizeof(struct cursor));
5151 :
5152 34 : this->next = cur;
5153 34 : this->name = mm_strdup(@2);
5154 34 : this->function = (current_function ? mm_strdup(current_function) : NULL);
5155 34 : this->connection = connection ? mm_strdup(connection) : NULL;
5156 34 : this->opened = false;
5157 34 : this->command = mm_strdup(cat_str(7, "declare", cursor_marker, @3, "cursor", @5, "for", @7));
5158 34 : this->argsinsert = argsinsert;
5159 34 : this->argsinsert_oos = NULL;
5160 34 : this->argsresult = argsresult;
5161 34 : this->argsresult_oos = NULL;
5162 34 : argsinsert = argsresult = NULL;
5163 34 : cur = this;
5164 :
5165 34 : c1 = loc_strdup(this->command);
5166 34 : while ((c2 = strstr(c1, "*/")) != NULL)
5167 : {
5168 : /* We put this text into a comment, so we better remove [*][/]. */
5169 0 : c2[0] = '.';
5170 0 : c2[1] = '.';
5171 : }
5172 34 : comment = cat_str(3, "/*", c1, "*/");
5173 :
5174 34 : @$ = cat2_str(adjust_outofscope_cursor_vars(this), comment);
5175 : }
5176 : ;
5177 :
5178 :
5179 : cursor_name:
5180 : name
5181 : | char_civar
5182 : {
5183 86 : char *curname = loc_alloc(strlen(@1) + 2);
5184 :
5185 86 : sprintf(curname, ":%s", @1);
5186 86 : @$ = curname;
5187 : }
5188 : ;
5189 :
5190 :
5191 : cursor_options:
5192 :
5193 : | cursor_options NO SCROLL
5194 : | cursor_options SCROLL
5195 : | cursor_options BINARY
5196 : | cursor_options ASENSITIVE
5197 : | cursor_options INSENSITIVE
5198 : ;
5199 :
5200 :
5201 : opt_hold:
5202 :
5203 : {
5204 74 : if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit)
5205 0 : @$ = "with hold";
5206 : else
5207 74 : @$ = "";
5208 : }
5209 : | WITH HOLD
5210 : | WITHOUT HOLD
5211 : ;
5212 :
5213 :
5214 : SelectStmt:
5215 : select_no_parens %prec UMINUS
5216 : | select_with_parens %prec UMINUS
5217 : ;
5218 :
5219 :
5220 : select_with_parens:
5221 : '(' select_no_parens ')'
5222 : | '(' select_with_parens ')'
5223 : ;
5224 :
5225 :
5226 : select_no_parens:
5227 : simple_select
5228 : | select_clause sort_clause
5229 : | select_clause opt_sort_clause for_locking_clause opt_select_limit
5230 : | select_clause opt_sort_clause select_limit opt_for_locking_clause
5231 : | with_clause select_clause
5232 : | with_clause select_clause sort_clause
5233 : | with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit
5234 : | with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause
5235 : ;
5236 :
5237 :
5238 : select_clause:
5239 : simple_select
5240 : | select_with_parens
5241 : ;
5242 :
5243 :
5244 : simple_select:
5245 : SELECT opt_all_clause opt_target_list into_clause from_clause where_clause group_clause having_clause window_clause
5246 : | SELECT distinct_clause target_list into_clause from_clause where_clause group_clause having_clause window_clause
5247 : | values_clause
5248 : | TABLE relation_expr
5249 : | select_clause UNION set_quantifier select_clause
5250 : | select_clause INTERSECT set_quantifier select_clause
5251 : | select_clause EXCEPT set_quantifier select_clause
5252 : ;
5253 :
5254 :
5255 : with_clause:
5256 : WITH cte_list
5257 : | WITH_LA cte_list
5258 : | WITH RECURSIVE cte_list
5259 : ;
5260 :
5261 :
5262 : cte_list:
5263 : common_table_expr
5264 : | cte_list ',' common_table_expr
5265 : ;
5266 :
5267 :
5268 : common_table_expr:
5269 : name opt_name_list AS opt_materialized '(' PreparableStmt ')' opt_search_clause opt_cycle_clause
5270 : ;
5271 :
5272 :
5273 : opt_materialized:
5274 : MATERIALIZED
5275 : | NOT MATERIALIZED
5276 : |
5277 : ;
5278 :
5279 :
5280 : opt_search_clause:
5281 : SEARCH DEPTH FIRST_P BY columnList SET ColId
5282 : | SEARCH BREADTH FIRST_P BY columnList SET ColId
5283 : |
5284 : ;
5285 :
5286 :
5287 : opt_cycle_clause:
5288 : CYCLE columnList SET ColId TO AexprConst DEFAULT AexprConst USING ColId
5289 : | CYCLE columnList SET ColId USING ColId
5290 : |
5291 : ;
5292 :
5293 :
5294 : opt_with_clause:
5295 : with_clause
5296 : |
5297 : ;
5298 :
5299 :
5300 : into_clause:
5301 : INTO OptTempTableName
5302 : {
5303 2 : FoundInto = 1;
5304 2 : @$ = cat2_str("into", @2);
5305 : }
5306 : | ecpg_into
5307 : {
5308 182 : @$ = "";
5309 : }
5310 : |
5311 : ;
5312 :
5313 :
5314 : OptTempTableName:
5315 : TEMPORARY opt_table qualified_name
5316 : | TEMP opt_table qualified_name
5317 : | LOCAL TEMPORARY opt_table qualified_name
5318 : | LOCAL TEMP opt_table qualified_name
5319 : | GLOBAL TEMPORARY opt_table qualified_name
5320 : | GLOBAL TEMP opt_table qualified_name
5321 : | UNLOGGED opt_table qualified_name
5322 : | TABLE qualified_name
5323 : | qualified_name
5324 : ;
5325 :
5326 :
5327 : opt_table:
5328 : TABLE
5329 : |
5330 : ;
5331 :
5332 :
5333 : set_quantifier:
5334 : ALL
5335 : | DISTINCT
5336 : |
5337 : ;
5338 :
5339 :
5340 : distinct_clause:
5341 : DISTINCT
5342 : | DISTINCT ON '(' expr_list ')'
5343 : ;
5344 :
5345 :
5346 : opt_all_clause:
5347 : ALL
5348 : |
5349 : ;
5350 :
5351 :
5352 : opt_sort_clause:
5353 : sort_clause
5354 : |
5355 : ;
5356 :
5357 :
5358 : sort_clause:
5359 : ORDER BY sortby_list
5360 : ;
5361 :
5362 :
5363 : sortby_list:
5364 : sortby
5365 : | sortby_list ',' sortby
5366 : ;
5367 :
5368 :
5369 : sortby:
5370 : a_expr USING qual_all_Op opt_nulls_order
5371 : | a_expr opt_asc_desc opt_nulls_order
5372 : ;
5373 :
5374 :
5375 : select_limit:
5376 : limit_clause offset_clause
5377 : | offset_clause limit_clause
5378 : | limit_clause
5379 : | offset_clause
5380 : ;
5381 :
5382 :
5383 : opt_select_limit:
5384 : select_limit
5385 : |
5386 : ;
5387 :
5388 :
5389 : limit_clause:
5390 : LIMIT select_limit_value
5391 : | LIMIT select_limit_value ',' select_offset_value
5392 : {
5393 0 : mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server");
5394 : }
5395 : | FETCH first_or_next select_fetch_first_value row_or_rows ONLY
5396 : | FETCH first_or_next select_fetch_first_value row_or_rows WITH TIES
5397 : | FETCH first_or_next row_or_rows ONLY
5398 : | FETCH first_or_next row_or_rows WITH TIES
5399 : ;
5400 :
5401 :
5402 : offset_clause:
5403 : OFFSET select_offset_value
5404 : | OFFSET select_fetch_first_value row_or_rows
5405 : ;
5406 :
5407 :
5408 : select_limit_value:
5409 : a_expr
5410 : | ALL
5411 : ;
5412 :
5413 :
5414 : select_offset_value:
5415 : a_expr
5416 : ;
5417 :
5418 :
5419 : select_fetch_first_value:
5420 : c_expr
5421 : | '+' I_or_F_const
5422 : | '-' I_or_F_const
5423 : ;
5424 :
5425 :
5426 : I_or_F_const:
5427 : Iconst
5428 : | ecpg_fconst
5429 : ;
5430 :
5431 :
5432 : row_or_rows:
5433 : ROW
5434 : | ROWS
5435 : ;
5436 :
5437 :
5438 : first_or_next:
5439 : FIRST_P
5440 : | NEXT
5441 : ;
5442 :
5443 :
5444 : group_clause:
5445 : GROUP_P BY set_quantifier group_by_list
5446 : |
5447 : ;
5448 :
5449 :
5450 : group_by_list:
5451 : group_by_item
5452 : | group_by_list ',' group_by_item
5453 : ;
5454 :
5455 :
5456 : group_by_item:
5457 : a_expr
5458 : | empty_grouping_set
5459 : | cube_clause
5460 : | rollup_clause
5461 : | grouping_sets_clause
5462 : ;
5463 :
5464 :
5465 : empty_grouping_set:
5466 : '(' ')'
5467 : ;
5468 :
5469 :
5470 : rollup_clause:
5471 : ROLLUP '(' expr_list ')'
5472 : ;
5473 :
5474 :
5475 : cube_clause:
5476 : CUBE '(' expr_list ')'
5477 : ;
5478 :
5479 :
5480 : grouping_sets_clause:
5481 : GROUPING SETS '(' group_by_list ')'
5482 : ;
5483 :
5484 :
5485 : having_clause:
5486 : HAVING a_expr
5487 : |
5488 : ;
5489 :
5490 :
5491 : for_locking_clause:
5492 : for_locking_items
5493 : | FOR READ ONLY
5494 : ;
5495 :
5496 :
5497 : opt_for_locking_clause:
5498 : for_locking_clause
5499 : |
5500 : ;
5501 :
5502 :
5503 : for_locking_items:
5504 : for_locking_item
5505 : | for_locking_items for_locking_item
5506 : ;
5507 :
5508 :
5509 : for_locking_item:
5510 : for_locking_strength locked_rels_list opt_nowait_or_skip
5511 : ;
5512 :
5513 :
5514 : for_locking_strength:
5515 : FOR UPDATE
5516 : | FOR NO KEY UPDATE
5517 : | FOR SHARE
5518 : | FOR KEY SHARE
5519 : ;
5520 :
5521 :
5522 : locked_rels_list:
5523 : OF qualified_name_list
5524 : |
5525 : ;
5526 :
5527 :
5528 : values_clause:
5529 : VALUES '(' expr_list ')'
5530 : | values_clause ',' '(' expr_list ')'
5531 : ;
5532 :
5533 :
5534 : from_clause:
5535 : FROM from_list
5536 : |
5537 : ;
5538 :
5539 :
5540 : from_list:
5541 : table_ref
5542 : | from_list ',' table_ref
5543 : ;
5544 :
5545 :
5546 : table_ref:
5547 : relation_expr opt_alias_clause
5548 : | relation_expr opt_alias_clause tablesample_clause
5549 : | func_table func_alias_clause
5550 : | LATERAL_P func_table func_alias_clause
5551 : | xmltable opt_alias_clause
5552 : | LATERAL_P xmltable opt_alias_clause
5553 : | select_with_parens opt_alias_clause
5554 : | LATERAL_P select_with_parens opt_alias_clause
5555 : | joined_table
5556 : | '(' joined_table ')' alias_clause
5557 : | json_table opt_alias_clause
5558 : | LATERAL_P json_table opt_alias_clause
5559 : ;
5560 :
5561 :
5562 : joined_table:
5563 : '(' joined_table ')'
5564 : | table_ref CROSS JOIN table_ref
5565 : | table_ref join_type JOIN table_ref join_qual
5566 : | table_ref JOIN table_ref join_qual
5567 : | table_ref NATURAL join_type JOIN table_ref
5568 : | table_ref NATURAL JOIN table_ref
5569 : ;
5570 :
5571 :
5572 : alias_clause:
5573 : AS ColId '(' name_list ')'
5574 : | AS ColId
5575 : | ColId '(' name_list ')'
5576 : | ColId
5577 : ;
5578 :
5579 :
5580 : opt_alias_clause:
5581 : alias_clause
5582 : |
5583 : ;
5584 :
5585 :
5586 : opt_alias_clause_for_join_using:
5587 : AS ColId
5588 : |
5589 : ;
5590 :
5591 :
5592 : func_alias_clause:
5593 : alias_clause
5594 : | AS '(' TableFuncElementList ')'
5595 : | AS ColId '(' TableFuncElementList ')'
5596 : | ColId '(' TableFuncElementList ')'
5597 : |
5598 : ;
5599 :
5600 :
5601 : join_type:
5602 : FULL opt_outer
5603 : | LEFT opt_outer
5604 : | RIGHT opt_outer
5605 : | INNER_P
5606 : ;
5607 :
5608 :
5609 : opt_outer:
5610 : OUTER_P
5611 : |
5612 : ;
5613 :
5614 :
5615 : join_qual:
5616 : USING '(' name_list ')' opt_alias_clause_for_join_using
5617 : | ON a_expr
5618 : ;
5619 :
5620 :
5621 : relation_expr:
5622 : qualified_name
5623 : | extended_relation_expr
5624 : ;
5625 :
5626 :
5627 : extended_relation_expr:
5628 : qualified_name '*'
5629 : | ONLY qualified_name
5630 : | ONLY '(' qualified_name ')'
5631 : ;
5632 :
5633 :
5634 : relation_expr_list:
5635 : relation_expr
5636 : | relation_expr_list ',' relation_expr
5637 : ;
5638 :
5639 :
5640 : relation_expr_opt_alias:
5641 : relation_expr %prec UMINUS
5642 : | relation_expr ColId
5643 : | relation_expr AS ColId
5644 : ;
5645 :
5646 :
5647 : tablesample_clause:
5648 : TABLESAMPLE func_name '(' expr_list ')' opt_repeatable_clause
5649 : ;
5650 :
5651 :
5652 : opt_repeatable_clause:
5653 : REPEATABLE '(' a_expr ')'
5654 : |
5655 : ;
5656 :
5657 :
5658 : func_table:
5659 : func_expr_windowless opt_ordinality
5660 : | ROWS FROM '(' rowsfrom_list ')' opt_ordinality
5661 : ;
5662 :
5663 :
5664 : rowsfrom_item:
5665 : func_expr_windowless opt_col_def_list
5666 : ;
5667 :
5668 :
5669 : rowsfrom_list:
5670 : rowsfrom_item
5671 : | rowsfrom_list ',' rowsfrom_item
5672 : ;
5673 :
5674 :
5675 : opt_col_def_list:
5676 : AS '(' TableFuncElementList ')'
5677 : |
5678 : ;
5679 :
5680 :
5681 : opt_ordinality:
5682 : WITH_LA ORDINALITY
5683 : |
5684 : ;
5685 :
5686 :
5687 : where_clause:
5688 : WHERE a_expr
5689 : |
5690 : ;
5691 :
5692 :
5693 : where_or_current_clause:
5694 : WHERE a_expr
5695 : | WHERE CURRENT_P OF cursor_name
5696 : {
5697 0 : const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
5698 :
5699 0 : @$ = cat_str(2, "where current of", cursor_marker);
5700 : }
5701 : |
5702 : ;
5703 :
5704 :
5705 : OptTableFuncElementList:
5706 : TableFuncElementList
5707 : |
5708 : ;
5709 :
5710 :
5711 : TableFuncElementList:
5712 : TableFuncElement
5713 : | TableFuncElementList ',' TableFuncElement
5714 : ;
5715 :
5716 :
5717 : TableFuncElement:
5718 : ColId Typename opt_collate_clause
5719 : ;
5720 :
5721 :
5722 : xmltable:
5723 : XMLTABLE '(' c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
5724 : | XMLTABLE '(' XMLNAMESPACES '(' xml_namespace_list ')' ',' c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
5725 : ;
5726 :
5727 :
5728 : xmltable_column_list:
5729 : xmltable_column_el
5730 : | xmltable_column_list ',' xmltable_column_el
5731 : ;
5732 :
5733 :
5734 : xmltable_column_el:
5735 : ColId Typename
5736 : | ColId Typename xmltable_column_option_list
5737 : | ColId FOR ORDINALITY
5738 : ;
5739 :
5740 :
5741 : xmltable_column_option_list:
5742 : xmltable_column_option_el
5743 : | xmltable_column_option_list xmltable_column_option_el
5744 : ;
5745 :
5746 :
5747 : xmltable_column_option_el:
5748 : ecpg_ident b_expr
5749 : | DEFAULT b_expr
5750 : | NOT NULL_P
5751 : | NULL_P
5752 : | PATH b_expr
5753 : ;
5754 :
5755 :
5756 : xml_namespace_list:
5757 : xml_namespace_el
5758 : | xml_namespace_list ',' xml_namespace_el
5759 : ;
5760 :
5761 :
5762 : xml_namespace_el:
5763 : b_expr AS ColLabel
5764 : | DEFAULT b_expr
5765 : ;
5766 :
5767 :
5768 : json_table:
5769 : JSON_TABLE '(' json_value_expr ',' a_expr json_table_path_name_opt json_passing_clause_opt COLUMNS '(' json_table_column_definition_list ')' json_on_error_clause_opt ')'
5770 : ;
5771 :
5772 :
5773 : json_table_path_name_opt:
5774 : AS name
5775 : |
5776 : ;
5777 :
5778 :
5779 : json_table_column_definition_list:
5780 : json_table_column_definition
5781 : | json_table_column_definition_list ',' json_table_column_definition
5782 : ;
5783 :
5784 :
5785 : json_table_column_definition:
5786 : ColId FOR ORDINALITY
5787 : | ColId Typename json_table_column_path_clause_opt json_wrapper_behavior json_quotes_clause_opt json_behavior_clause_opt
5788 : | ColId Typename json_format_clause json_table_column_path_clause_opt json_wrapper_behavior json_quotes_clause_opt json_behavior_clause_opt
5789 : | ColId Typename EXISTS json_table_column_path_clause_opt json_on_error_clause_opt
5790 : | NESTED path_opt ecpg_sconst COLUMNS '(' json_table_column_definition_list ')'
5791 : | NESTED path_opt ecpg_sconst AS name COLUMNS '(' json_table_column_definition_list ')'
5792 : ;
5793 :
5794 :
5795 : path_opt:
5796 : PATH
5797 : |
5798 : ;
5799 :
5800 :
5801 : json_table_column_path_clause_opt:
5802 : PATH ecpg_sconst
5803 : |
5804 : ;
5805 :
5806 :
5807 : Typename:
5808 : SimpleTypename opt_array_bounds
5809 : {
5810 378 : @$ = cat2_str(@1, $2.str);
5811 : }
5812 : | SETOF SimpleTypename opt_array_bounds
5813 : {
5814 0 : @$ = cat_str(3, "setof", @2, $3.str);
5815 : }
5816 : | SimpleTypename ARRAY '[' Iconst ']'
5817 : | SETOF SimpleTypename ARRAY '[' Iconst ']'
5818 : | SimpleTypename ARRAY
5819 : | SETOF SimpleTypename ARRAY
5820 : ;
5821 :
5822 :
5823 : opt_array_bounds:
5824 : opt_array_bounds '[' ']'
5825 : {
5826 6 : $$.index1 = $1.index1;
5827 6 : $$.index2 = $1.index2;
5828 6 : if (strcmp($$.index1, "-1") == 0)
5829 6 : $$.index1 = "0";
5830 0 : else if (strcmp($1.index2, "-1") == 0)
5831 0 : $$.index2 = "0";
5832 6 : $$.str = cat_str(2, $1.str, "[]");
5833 : }
5834 : | opt_array_bounds '[' Iresult ']'
5835 : {
5836 246 : $$.index1 = $1.index1;
5837 246 : $$.index2 = $1.index2;
5838 246 : if (strcmp($1.index1, "-1") == 0)
5839 222 : $$.index1 = @3;
5840 24 : else if (strcmp($1.index2, "-1") == 0)
5841 24 : $$.index2 = @3;
5842 246 : $$.str = cat_str(4, $1.str, "[", @3, "]");
5843 : }
5844 : |
5845 : {
5846 1126 : $$.index1 = "-1";
5847 1126 : $$.index2 = "-1";
5848 1126 : $$.str = "";
5849 : }
5850 : ;
5851 :
5852 :
5853 : SimpleTypename:
5854 : GenericType
5855 : | Numeric
5856 : | Bit
5857 : | Character
5858 : | ConstDatetime
5859 : | ConstInterval opt_interval
5860 : | ConstInterval '(' Iconst ')'
5861 : | JsonType
5862 : ;
5863 :
5864 :
5865 : ConstTypename:
5866 : Numeric
5867 : | ConstBit
5868 : | ConstCharacter
5869 : | ConstDatetime
5870 : | JsonType
5871 : ;
5872 :
5873 :
5874 : GenericType:
5875 : type_function_name opt_type_modifiers
5876 : | type_function_name attrs opt_type_modifiers
5877 : ;
5878 :
5879 :
5880 : opt_type_modifiers:
5881 : '(' expr_list ')'
5882 : |
5883 : ;
5884 :
5885 :
5886 : Numeric:
5887 : INT_P
5888 : | INTEGER
5889 : | SMALLINT
5890 : | BIGINT
5891 : | REAL
5892 : | FLOAT_P opt_float
5893 : | DOUBLE_P PRECISION
5894 : | DECIMAL_P opt_type_modifiers
5895 : | DEC opt_type_modifiers
5896 : | NUMERIC opt_type_modifiers
5897 : | BOOLEAN_P
5898 : ;
5899 :
5900 :
5901 : opt_float:
5902 : '(' Iconst ')'
5903 : |
5904 : ;
5905 :
5906 :
5907 : Bit:
5908 : BitWithLength
5909 : | BitWithoutLength
5910 : ;
5911 :
5912 :
5913 : ConstBit:
5914 : BitWithLength
5915 : | BitWithoutLength
5916 : ;
5917 :
5918 :
5919 : BitWithLength:
5920 : BIT opt_varying '(' expr_list ')'
5921 : ;
5922 :
5923 :
5924 : BitWithoutLength:
5925 : BIT opt_varying
5926 : ;
5927 :
5928 :
5929 : Character:
5930 : CharacterWithLength
5931 : | CharacterWithoutLength
5932 : ;
5933 :
5934 :
5935 : ConstCharacter:
5936 : CharacterWithLength
5937 : | CharacterWithoutLength
5938 : ;
5939 :
5940 :
5941 : CharacterWithLength:
5942 : character '(' Iconst ')'
5943 : ;
5944 :
5945 :
5946 : CharacterWithoutLength:
5947 : character
5948 : ;
5949 :
5950 :
5951 : character:
5952 : CHARACTER opt_varying
5953 : | CHAR_P opt_varying
5954 : | VARCHAR
5955 : | NATIONAL CHARACTER opt_varying
5956 : | NATIONAL CHAR_P opt_varying
5957 : | NCHAR opt_varying
5958 : ;
5959 :
5960 :
5961 : opt_varying:
5962 : VARYING
5963 : |
5964 : ;
5965 :
5966 :
5967 : ConstDatetime:
5968 : TIMESTAMP '(' Iconst ')' opt_timezone
5969 : | TIMESTAMP opt_timezone
5970 : | TIME '(' Iconst ')' opt_timezone
5971 : | TIME opt_timezone
5972 : ;
5973 :
5974 :
5975 : ConstInterval:
5976 : INTERVAL
5977 : ;
5978 :
5979 :
5980 : opt_timezone:
5981 : WITH_LA TIME ZONE
5982 : | WITHOUT_LA TIME ZONE
5983 : |
5984 : ;
5985 :
5986 :
5987 : opt_interval:
5988 : YEAR_P
5989 : | MONTH_P
5990 : | DAY_P
5991 : | HOUR_P
5992 : | MINUTE_P
5993 : | interval_second
5994 : | YEAR_P TO MONTH_P
5995 : | DAY_P TO HOUR_P
5996 : | DAY_P TO MINUTE_P
5997 : | DAY_P TO interval_second
5998 : | HOUR_P TO MINUTE_P
5999 : | HOUR_P TO interval_second
6000 : | MINUTE_P TO interval_second
6001 : |
6002 : ;
6003 :
6004 :
6005 : interval_second:
6006 : SECOND_P
6007 : | SECOND_P '(' Iconst ')'
6008 : ;
6009 :
6010 :
6011 : JsonType:
6012 : JSON
6013 : ;
6014 :
6015 :
6016 : a_expr:
6017 : c_expr
6018 : | a_expr TYPECAST Typename
6019 : | a_expr COLLATE any_name
6020 : | a_expr AT TIME ZONE a_expr %prec AT
6021 : | a_expr AT LOCAL %prec AT
6022 : | '+' a_expr %prec UMINUS
6023 : | '-' a_expr %prec UMINUS
6024 : | a_expr '+' a_expr
6025 : | a_expr '-' a_expr
6026 : | a_expr '*' a_expr
6027 : | a_expr '/' a_expr
6028 : | a_expr '%' a_expr
6029 : | a_expr '^' a_expr
6030 : | a_expr '<' a_expr
6031 : | a_expr '>' a_expr
6032 : | a_expr '=' a_expr
6033 : | a_expr LESS_EQUALS a_expr
6034 : | a_expr GREATER_EQUALS a_expr
6035 : | a_expr NOT_EQUALS a_expr
6036 : | a_expr qual_Op a_expr %prec Op
6037 : | qual_Op a_expr %prec Op
6038 : | a_expr AND a_expr
6039 : | a_expr OR a_expr
6040 : | NOT a_expr
6041 : | NOT_LA a_expr %prec NOT
6042 : | a_expr LIKE a_expr
6043 : | a_expr LIKE a_expr ESCAPE a_expr %prec LIKE
6044 : | a_expr NOT_LA LIKE a_expr %prec NOT_LA
6045 : | a_expr NOT_LA LIKE a_expr ESCAPE a_expr %prec NOT_LA
6046 : | a_expr ILIKE a_expr
6047 : | a_expr ILIKE a_expr ESCAPE a_expr %prec ILIKE
6048 : | a_expr NOT_LA ILIKE a_expr %prec NOT_LA
6049 : | a_expr NOT_LA ILIKE a_expr ESCAPE a_expr %prec NOT_LA
6050 : | a_expr SIMILAR TO a_expr %prec SIMILAR
6051 : | a_expr SIMILAR TO a_expr ESCAPE a_expr %prec SIMILAR
6052 : | a_expr NOT_LA SIMILAR TO a_expr %prec NOT_LA
6053 : | a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr %prec NOT_LA
6054 : | a_expr IS NULL_P %prec IS
6055 : | a_expr ISNULL
6056 : | a_expr IS NOT NULL_P %prec IS
6057 : | a_expr NOTNULL
6058 : | row OVERLAPS row
6059 : | a_expr IS TRUE_P %prec IS
6060 : | a_expr IS NOT TRUE_P %prec IS
6061 : | a_expr IS FALSE_P %prec IS
6062 : | a_expr IS NOT FALSE_P %prec IS
6063 : | a_expr IS UNKNOWN %prec IS
6064 : | a_expr IS NOT UNKNOWN %prec IS
6065 : | a_expr IS DISTINCT FROM a_expr %prec IS
6066 : | a_expr IS NOT DISTINCT FROM a_expr %prec IS
6067 : | a_expr BETWEEN opt_asymmetric b_expr AND a_expr %prec BETWEEN
6068 : | a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr %prec NOT_LA
6069 : | a_expr BETWEEN SYMMETRIC b_expr AND a_expr %prec BETWEEN
6070 : | a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr %prec NOT_LA
6071 : | a_expr IN_P in_expr
6072 : | a_expr NOT_LA IN_P in_expr %prec NOT_LA
6073 : | a_expr subquery_Op sub_type select_with_parens %prec Op
6074 : | a_expr subquery_Op sub_type '(' a_expr ')' %prec Op
6075 : | UNIQUE opt_unique_null_treatment select_with_parens
6076 : {
6077 0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
6078 : }
6079 : | a_expr IS DOCUMENT_P %prec IS
6080 : | a_expr IS NOT DOCUMENT_P %prec IS
6081 : | a_expr IS NORMALIZED %prec IS
6082 : | a_expr IS unicode_normal_form NORMALIZED %prec IS
6083 : | a_expr IS NOT NORMALIZED %prec IS
6084 : | a_expr IS NOT unicode_normal_form NORMALIZED %prec IS
6085 : | a_expr IS json_predicate_type_constraint json_key_uniqueness_constraint_opt %prec IS
6086 : | a_expr IS NOT json_predicate_type_constraint json_key_uniqueness_constraint_opt %prec IS
6087 : | DEFAULT
6088 : ;
6089 :
6090 :
6091 : b_expr:
6092 : c_expr
6093 : | b_expr TYPECAST Typename
6094 : | '+' b_expr %prec UMINUS
6095 : | '-' b_expr %prec UMINUS
6096 : | b_expr '+' b_expr
6097 : | b_expr '-' b_expr
6098 : | b_expr '*' b_expr
6099 : | b_expr '/' b_expr
6100 : | b_expr '%' b_expr
6101 : | b_expr '^' b_expr
6102 : | b_expr '<' b_expr
6103 : | b_expr '>' b_expr
6104 : | b_expr '=' b_expr
6105 : | b_expr LESS_EQUALS b_expr
6106 : | b_expr GREATER_EQUALS b_expr
6107 : | b_expr NOT_EQUALS b_expr
6108 : | b_expr qual_Op b_expr %prec Op
6109 : | qual_Op b_expr %prec Op
6110 : | b_expr IS DISTINCT FROM b_expr %prec IS
6111 : | b_expr IS NOT DISTINCT FROM b_expr %prec IS
6112 : | b_expr IS DOCUMENT_P %prec IS
6113 : | b_expr IS NOT DOCUMENT_P %prec IS
6114 : ;
6115 :
6116 :
6117 : c_expr:
6118 : columnref
6119 : | AexprConst
6120 : | ecpg_param opt_indirection
6121 : | '(' a_expr ')' opt_indirection
6122 : | case_expr
6123 : | func_expr
6124 : | select_with_parens %prec UMINUS
6125 : | select_with_parens indirection
6126 : | EXISTS select_with_parens
6127 : | ARRAY select_with_parens
6128 : | ARRAY array_expr
6129 : | explicit_row
6130 : | implicit_row
6131 : | GROUPING '(' expr_list ')'
6132 : ;
6133 :
6134 :
6135 : func_application:
6136 : func_name '(' ')'
6137 : | func_name '(' func_arg_list opt_sort_clause ')'
6138 : | func_name '(' VARIADIC func_arg_expr opt_sort_clause ')'
6139 : | func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause ')'
6140 : | func_name '(' ALL func_arg_list opt_sort_clause ')'
6141 : | func_name '(' DISTINCT func_arg_list opt_sort_clause ')'
6142 : | func_name '(' '*' ')'
6143 : ;
6144 :
6145 :
6146 : func_expr:
6147 : func_application within_group_clause filter_clause over_clause
6148 : | json_aggregate_func filter_clause over_clause
6149 : | func_expr_common_subexpr
6150 : ;
6151 :
6152 :
6153 : func_expr_windowless:
6154 : func_application
6155 : | func_expr_common_subexpr
6156 : | json_aggregate_func
6157 : ;
6158 :
6159 :
6160 : func_expr_common_subexpr:
6161 : COLLATION FOR '(' a_expr ')'
6162 : | CURRENT_DATE
6163 : | CURRENT_TIME
6164 : | CURRENT_TIME '(' Iconst ')'
6165 : | CURRENT_TIMESTAMP
6166 : | CURRENT_TIMESTAMP '(' Iconst ')'
6167 : | LOCALTIME
6168 : | LOCALTIME '(' Iconst ')'
6169 : | LOCALTIMESTAMP
6170 : | LOCALTIMESTAMP '(' Iconst ')'
6171 : | CURRENT_ROLE
6172 : | CURRENT_USER
6173 : | SESSION_USER
6174 : | SYSTEM_USER
6175 : | USER
6176 : | CURRENT_CATALOG
6177 : | CURRENT_SCHEMA
6178 : | CAST '(' a_expr AS Typename ')'
6179 : | EXTRACT '(' extract_list ')'
6180 : | NORMALIZE '(' a_expr ')'
6181 : | NORMALIZE '(' a_expr ',' unicode_normal_form ')'
6182 : | OVERLAY '(' overlay_list ')'
6183 : | OVERLAY '(' func_arg_list_opt ')'
6184 : | POSITION '(' position_list ')'
6185 : | SUBSTRING '(' substr_list ')'
6186 : | SUBSTRING '(' func_arg_list_opt ')'
6187 : | TREAT '(' a_expr AS Typename ')'
6188 : | TRIM '(' BOTH trim_list ')'
6189 : | TRIM '(' LEADING trim_list ')'
6190 : | TRIM '(' TRAILING trim_list ')'
6191 : | TRIM '(' trim_list ')'
6192 : | NULLIF '(' a_expr ',' a_expr ')'
6193 : | COALESCE '(' expr_list ')'
6194 : | GREATEST '(' expr_list ')'
6195 : | LEAST '(' expr_list ')'
6196 : | XMLCONCAT '(' expr_list ')'
6197 : | XMLELEMENT '(' NAME_P ColLabel ')'
6198 : | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ')'
6199 : | XMLELEMENT '(' NAME_P ColLabel ',' expr_list ')'
6200 : | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
6201 : | XMLEXISTS '(' c_expr xmlexists_argument ')'
6202 : | XMLFOREST '(' xml_attribute_list ')'
6203 : | XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
6204 : | XMLPI '(' NAME_P ColLabel ')'
6205 : | XMLPI '(' NAME_P ColLabel ',' a_expr ')'
6206 : | XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
6207 : | XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename xml_indent_option ')'
6208 : | JSON_OBJECT '(' func_arg_list ')'
6209 : | JSON_OBJECT '(' json_name_and_value_list json_object_constructor_null_clause_opt json_key_uniqueness_constraint_opt json_returning_clause_opt ')'
6210 : | JSON_OBJECT '(' json_returning_clause_opt ')'
6211 : | JSON_ARRAY '(' json_value_expr_list json_array_constructor_null_clause_opt json_returning_clause_opt ')'
6212 : | JSON_ARRAY '(' select_no_parens json_format_clause_opt json_returning_clause_opt ')'
6213 : | JSON_ARRAY '(' json_returning_clause_opt ')'
6214 : | JSON '(' json_value_expr json_key_uniqueness_constraint_opt ')'
6215 : | JSON_SCALAR '(' a_expr ')'
6216 : | JSON_SERIALIZE '(' json_value_expr json_returning_clause_opt ')'
6217 : | MERGE_ACTION '(' ')'
6218 : | JSON_QUERY '(' json_value_expr ',' a_expr json_passing_clause_opt json_returning_clause_opt json_wrapper_behavior json_quotes_clause_opt json_behavior_clause_opt ')'
6219 : | JSON_EXISTS '(' json_value_expr ',' a_expr json_passing_clause_opt json_on_error_clause_opt ')'
6220 : | JSON_VALUE '(' json_value_expr ',' a_expr json_passing_clause_opt json_returning_clause_opt json_behavior_clause_opt ')'
6221 : ;
6222 :
6223 :
6224 : xml_root_version:
6225 : VERSION_P a_expr
6226 : | VERSION_P NO VALUE_P
6227 : ;
6228 :
6229 :
6230 : opt_xml_root_standalone:
6231 : ',' STANDALONE_P YES_P
6232 : | ',' STANDALONE_P NO
6233 : | ',' STANDALONE_P NO VALUE_P
6234 : |
6235 : ;
6236 :
6237 :
6238 : xml_attributes:
6239 : XMLATTRIBUTES '(' xml_attribute_list ')'
6240 : ;
6241 :
6242 :
6243 : xml_attribute_list:
6244 : xml_attribute_el
6245 : | xml_attribute_list ',' xml_attribute_el
6246 : ;
6247 :
6248 :
6249 : xml_attribute_el:
6250 : a_expr AS ColLabel
6251 : | a_expr
6252 : ;
6253 :
6254 :
6255 : document_or_content:
6256 : DOCUMENT_P
6257 : | CONTENT_P
6258 : ;
6259 :
6260 :
6261 : xml_indent_option:
6262 : INDENT
6263 : | NO INDENT
6264 : |
6265 : ;
6266 :
6267 :
6268 : xml_whitespace_option:
6269 : PRESERVE WHITESPACE_P
6270 : | STRIP_P WHITESPACE_P
6271 : |
6272 : ;
6273 :
6274 :
6275 : xmlexists_argument:
6276 : PASSING c_expr
6277 : | PASSING c_expr xml_passing_mech
6278 : | PASSING xml_passing_mech c_expr
6279 : | PASSING xml_passing_mech c_expr xml_passing_mech
6280 : ;
6281 :
6282 :
6283 : xml_passing_mech:
6284 : BY REF_P
6285 : | BY VALUE_P
6286 : ;
6287 :
6288 :
6289 : within_group_clause:
6290 : WITHIN GROUP_P '(' sort_clause ')'
6291 : |
6292 : ;
6293 :
6294 :
6295 : filter_clause:
6296 : FILTER '(' WHERE a_expr ')'
6297 : |
6298 : ;
6299 :
6300 :
6301 : window_clause:
6302 : WINDOW window_definition_list
6303 : |
6304 : ;
6305 :
6306 :
6307 : window_definition_list:
6308 : window_definition
6309 : | window_definition_list ',' window_definition
6310 : ;
6311 :
6312 :
6313 : window_definition:
6314 : ColId AS window_specification
6315 : ;
6316 :
6317 :
6318 : over_clause:
6319 : OVER window_specification
6320 : | OVER ColId
6321 : |
6322 : ;
6323 :
6324 :
6325 : window_specification:
6326 : '(' opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause ')'
6327 : ;
6328 :
6329 :
6330 : opt_existing_window_name:
6331 : ColId
6332 : | %prec Op
6333 : ;
6334 :
6335 :
6336 : opt_partition_clause:
6337 : PARTITION BY expr_list
6338 : |
6339 : ;
6340 :
6341 :
6342 : opt_frame_clause:
6343 : RANGE frame_extent opt_window_exclusion_clause
6344 : | ROWS frame_extent opt_window_exclusion_clause
6345 : | GROUPS frame_extent opt_window_exclusion_clause
6346 : |
6347 : ;
6348 :
6349 :
6350 : frame_extent:
6351 : frame_bound
6352 : | BETWEEN frame_bound AND frame_bound
6353 : ;
6354 :
6355 :
6356 : frame_bound:
6357 : UNBOUNDED PRECEDING
6358 : | UNBOUNDED FOLLOWING
6359 : | CURRENT_P ROW
6360 : | a_expr PRECEDING
6361 : | a_expr FOLLOWING
6362 : ;
6363 :
6364 :
6365 : opt_window_exclusion_clause:
6366 : EXCLUDE CURRENT_P ROW
6367 : | EXCLUDE GROUP_P
6368 : | EXCLUDE TIES
6369 : | EXCLUDE NO OTHERS
6370 : |
6371 : ;
6372 :
6373 :
6374 : row:
6375 : ROW '(' expr_list ')'
6376 : | ROW '(' ')'
6377 : | '(' expr_list ',' a_expr ')'
6378 : ;
6379 :
6380 :
6381 : explicit_row:
6382 : ROW '(' expr_list ')'
6383 : | ROW '(' ')'
6384 : ;
6385 :
6386 :
6387 : implicit_row:
6388 : '(' expr_list ',' a_expr ')'
6389 : ;
6390 :
6391 :
6392 : sub_type:
6393 : ANY
6394 : | SOME
6395 : | ALL
6396 : ;
6397 :
6398 :
6399 : all_Op:
6400 : Op
6401 : | MathOp
6402 : ;
6403 :
6404 :
6405 : MathOp:
6406 : '+'
6407 : | '-'
6408 : | '*'
6409 : | '/'
6410 : | '%'
6411 : | '^'
6412 : | '<'
6413 : | '>'
6414 : | '='
6415 : | LESS_EQUALS
6416 : | GREATER_EQUALS
6417 : | NOT_EQUALS
6418 : ;
6419 :
6420 :
6421 : qual_Op:
6422 : Op
6423 : | OPERATOR '(' any_operator ')'
6424 : ;
6425 :
6426 :
6427 : qual_all_Op:
6428 : all_Op
6429 : | OPERATOR '(' any_operator ')'
6430 : ;
6431 :
6432 :
6433 : subquery_Op:
6434 : all_Op
6435 : | OPERATOR '(' any_operator ')'
6436 : | LIKE
6437 : | NOT_LA LIKE
6438 : | ILIKE
6439 : | NOT_LA ILIKE
6440 : ;
6441 :
6442 :
6443 : expr_list:
6444 : a_expr
6445 : | expr_list ',' a_expr
6446 : ;
6447 :
6448 :
6449 : func_arg_list:
6450 : func_arg_expr
6451 : | func_arg_list ',' func_arg_expr
6452 : ;
6453 :
6454 :
6455 : func_arg_expr:
6456 : a_expr
6457 : | param_name COLON_EQUALS a_expr
6458 : | param_name EQUALS_GREATER a_expr
6459 : ;
6460 :
6461 :
6462 : func_arg_list_opt:
6463 : func_arg_list
6464 : |
6465 : ;
6466 :
6467 :
6468 : type_list:
6469 : Typename
6470 : | type_list ',' Typename
6471 : ;
6472 :
6473 :
6474 : array_expr:
6475 : '[' expr_list ']'
6476 : | '[' array_expr_list ']'
6477 : | '[' ']'
6478 : ;
6479 :
6480 :
6481 : array_expr_list:
6482 : array_expr
6483 : | array_expr_list ',' array_expr
6484 : ;
6485 :
6486 :
6487 : extract_list:
6488 : extract_arg FROM a_expr
6489 : ;
6490 :
6491 :
6492 : extract_arg:
6493 : ecpg_ident
6494 : | YEAR_P
6495 : | MONTH_P
6496 : | DAY_P
6497 : | HOUR_P
6498 : | MINUTE_P
6499 : | SECOND_P
6500 : | ecpg_sconst
6501 : ;
6502 :
6503 :
6504 : unicode_normal_form:
6505 : NFC
6506 : | NFD
6507 : | NFKC
6508 : | NFKD
6509 : ;
6510 :
6511 :
6512 : overlay_list:
6513 : a_expr PLACING a_expr FROM a_expr FOR a_expr
6514 : | a_expr PLACING a_expr FROM a_expr
6515 : ;
6516 :
6517 :
6518 : position_list:
6519 : b_expr IN_P b_expr
6520 : ;
6521 :
6522 :
6523 : substr_list:
6524 : a_expr FROM a_expr FOR a_expr
6525 : | a_expr FOR a_expr FROM a_expr
6526 : | a_expr FROM a_expr
6527 : | a_expr FOR a_expr
6528 : | a_expr SIMILAR a_expr ESCAPE a_expr
6529 : ;
6530 :
6531 :
6532 : trim_list:
6533 : a_expr FROM expr_list
6534 : | FROM expr_list
6535 : | expr_list
6536 : ;
6537 :
6538 :
6539 : in_expr:
6540 : select_with_parens
6541 : | '(' expr_list ')'
6542 : ;
6543 :
6544 :
6545 : case_expr:
6546 : CASE case_arg when_clause_list case_default END_P
6547 : ;
6548 :
6549 :
6550 : when_clause_list:
6551 : when_clause
6552 : | when_clause_list when_clause
6553 : ;
6554 :
6555 :
6556 : when_clause:
6557 : WHEN a_expr THEN a_expr
6558 : ;
6559 :
6560 :
6561 : case_default:
6562 : ELSE a_expr
6563 : |
6564 : ;
6565 :
6566 :
6567 : case_arg:
6568 : a_expr
6569 : |
6570 : ;
6571 :
6572 :
6573 : columnref:
6574 : ColId
6575 : | ColId indirection
6576 : ;
6577 :
6578 :
6579 : indirection_el:
6580 : '.' attr_name
6581 : | '.' '*'
6582 : | '[' a_expr ']'
6583 : | '[' opt_slice_bound ':' opt_slice_bound ']'
6584 : ;
6585 :
6586 :
6587 : opt_slice_bound:
6588 : a_expr
6589 : |
6590 : ;
6591 :
6592 :
6593 : indirection:
6594 : indirection_el
6595 : | indirection indirection_el
6596 : ;
6597 :
6598 :
6599 : opt_indirection:
6600 :
6601 : | opt_indirection indirection_el
6602 : ;
6603 :
6604 :
6605 : opt_asymmetric:
6606 : ASYMMETRIC
6607 : |
6608 : ;
6609 :
6610 :
6611 : json_passing_clause_opt:
6612 : PASSING json_arguments
6613 : |
6614 : ;
6615 :
6616 :
6617 : json_arguments:
6618 : json_argument
6619 : | json_arguments ',' json_argument
6620 : ;
6621 :
6622 :
6623 : json_argument:
6624 : json_value_expr AS ColLabel
6625 : ;
6626 :
6627 :
6628 : json_wrapper_behavior:
6629 : WITHOUT WRAPPER
6630 : | WITHOUT ARRAY WRAPPER
6631 : | WITH WRAPPER
6632 : | WITH ARRAY WRAPPER
6633 : | WITH CONDITIONAL ARRAY WRAPPER
6634 : | WITH UNCONDITIONAL ARRAY WRAPPER
6635 : | WITH CONDITIONAL WRAPPER
6636 : | WITH UNCONDITIONAL WRAPPER
6637 : |
6638 : ;
6639 :
6640 :
6641 : json_behavior:
6642 : DEFAULT a_expr
6643 : | json_behavior_type
6644 : ;
6645 :
6646 :
6647 : json_behavior_type:
6648 : ERROR_P
6649 : | NULL_P
6650 : | TRUE_P
6651 : | FALSE_P
6652 : | UNKNOWN
6653 : | EMPTY_P ARRAY
6654 : | EMPTY_P OBJECT_P
6655 : | EMPTY_P
6656 : ;
6657 :
6658 :
6659 : json_behavior_clause_opt:
6660 : json_behavior ON EMPTY_P
6661 : | json_behavior ON ERROR_P
6662 : | json_behavior ON EMPTY_P json_behavior ON ERROR_P
6663 : |
6664 : ;
6665 :
6666 :
6667 : json_on_error_clause_opt:
6668 : json_behavior ON ERROR_P
6669 : |
6670 : ;
6671 :
6672 :
6673 : json_value_expr:
6674 : a_expr json_format_clause_opt
6675 : ;
6676 :
6677 :
6678 : json_format_clause:
6679 : FORMAT_LA JSON ENCODING name
6680 : | FORMAT_LA JSON
6681 : ;
6682 :
6683 :
6684 : json_format_clause_opt:
6685 : json_format_clause
6686 : |
6687 : ;
6688 :
6689 :
6690 : json_quotes_clause_opt:
6691 : KEEP QUOTES ON SCALAR STRING_P
6692 : | KEEP QUOTES
6693 : | OMIT QUOTES ON SCALAR STRING_P
6694 : | OMIT QUOTES
6695 : |
6696 : ;
6697 :
6698 :
6699 : json_returning_clause_opt:
6700 : RETURNING Typename json_format_clause_opt
6701 : |
6702 : ;
6703 :
6704 :
6705 : json_predicate_type_constraint:
6706 : JSON %prec UNBOUNDED
6707 : | JSON VALUE_P
6708 : | JSON ARRAY
6709 : | JSON OBJECT_P
6710 : | JSON SCALAR
6711 : ;
6712 :
6713 :
6714 : json_key_uniqueness_constraint_opt:
6715 : WITH UNIQUE KEYS
6716 : | WITH UNIQUE %prec UNBOUNDED
6717 : | WITHOUT UNIQUE KEYS
6718 : | WITHOUT UNIQUE %prec UNBOUNDED
6719 : | %prec UNBOUNDED
6720 : ;
6721 :
6722 :
6723 : json_name_and_value_list:
6724 : json_name_and_value
6725 : | json_name_and_value_list ',' json_name_and_value
6726 : ;
6727 :
6728 :
6729 : json_name_and_value:
6730 : c_expr VALUE_P json_value_expr
6731 : | a_expr ':' json_value_expr
6732 : ;
6733 :
6734 :
6735 : json_object_constructor_null_clause_opt:
6736 : NULL_P ON NULL_P
6737 : | ABSENT ON NULL_P
6738 : |
6739 : ;
6740 :
6741 :
6742 : json_array_constructor_null_clause_opt:
6743 : NULL_P ON NULL_P
6744 : | ABSENT ON NULL_P
6745 : |
6746 : ;
6747 :
6748 :
6749 : json_value_expr_list:
6750 : json_value_expr
6751 : | json_value_expr_list ',' json_value_expr
6752 : ;
6753 :
6754 :
6755 : json_aggregate_func:
6756 : JSON_OBJECTAGG '(' json_name_and_value json_object_constructor_null_clause_opt json_key_uniqueness_constraint_opt json_returning_clause_opt ')'
6757 : | JSON_ARRAYAGG '(' json_value_expr json_array_aggregate_order_by_clause_opt json_array_constructor_null_clause_opt json_returning_clause_opt ')'
6758 : ;
6759 :
6760 :
6761 : json_array_aggregate_order_by_clause_opt:
6762 : ORDER BY sortby_list
6763 : |
6764 : ;
6765 :
6766 :
6767 : opt_target_list:
6768 : target_list
6769 : |
6770 : ;
6771 :
6772 :
6773 : target_list:
6774 : target_el
6775 : | target_list ',' target_el
6776 : ;
6777 :
6778 :
6779 : target_el:
6780 : a_expr AS ColLabel
6781 : | a_expr BareColLabel
6782 : | a_expr
6783 : | '*'
6784 : ;
6785 :
6786 :
6787 : qualified_name_list:
6788 : qualified_name
6789 : | qualified_name_list ',' qualified_name
6790 : ;
6791 :
6792 :
6793 : qualified_name:
6794 : ColId
6795 : | ColId indirection
6796 : ;
6797 :
6798 :
6799 : name_list:
6800 : name
6801 : | name_list ',' name
6802 : ;
6803 :
6804 :
6805 : name:
6806 : ColId
6807 : ;
6808 :
6809 :
6810 : attr_name:
6811 : ColLabel
6812 : ;
6813 :
6814 :
6815 : file_name:
6816 : ecpg_sconst
6817 : ;
6818 :
6819 :
6820 : func_name:
6821 : type_function_name
6822 : | ColId indirection
6823 : ;
6824 :
6825 :
6826 : AexprConst:
6827 : Iconst
6828 : | ecpg_fconst
6829 : | ecpg_sconst
6830 : | ecpg_bconst
6831 : | ecpg_xconst
6832 : | func_name ecpg_sconst
6833 : | func_name '(' func_arg_list opt_sort_clause ')' ecpg_sconst
6834 : | ConstTypename ecpg_sconst
6835 : | ConstInterval ecpg_sconst opt_interval
6836 : | ConstInterval '(' Iconst ')' ecpg_sconst
6837 : | TRUE_P
6838 : | FALSE_P
6839 : | NULL_P
6840 : | civar
6841 : | civarind
6842 : ;
6843 :
6844 :
6845 : Iconst:
6846 : ICONST
6847 : ;
6848 :
6849 :
6850 : SignedIconst:
6851 : Iconst
6852 : | civar
6853 : | '+' Iconst
6854 : | '-' Iconst
6855 : ;
6856 :
6857 :
6858 : RoleId:
6859 : RoleSpec
6860 : ;
6861 :
6862 :
6863 : RoleSpec:
6864 : NonReservedWord
6865 : | CURRENT_ROLE
6866 : | CURRENT_USER
6867 : | SESSION_USER
6868 : ;
6869 :
6870 :
6871 : role_list:
6872 : RoleSpec
6873 : | role_list ',' RoleSpec
6874 : ;
6875 :
6876 :
6877 : NonReservedWord:
6878 : ecpg_ident
6879 : | unreserved_keyword
6880 : | col_name_keyword
6881 : | type_func_name_keyword
6882 : ;
6883 :
6884 :
6885 : BareColLabel:
6886 : ecpg_ident
6887 : | bare_label_keyword
6888 : ;
6889 :
6890 :
6891 : unreserved_keyword:
6892 : ABORT_P
6893 : | ABSENT
6894 : | ABSOLUTE_P
6895 : | ACCESS
6896 : | ACTION
6897 : | ADD_P
6898 : | ADMIN
6899 : | AFTER
6900 : | AGGREGATE
6901 : | ALSO
6902 : | ALTER
6903 : | ALWAYS
6904 : | ASENSITIVE
6905 : | ASSERTION
6906 : | ASSIGNMENT
6907 : | AT
6908 : | ATOMIC
6909 : | ATTACH
6910 : | ATTRIBUTE
6911 : | BACKWARD
6912 : | BEFORE
6913 : | BEGIN_P
6914 : | BREADTH
6915 : | BY
6916 : | CACHE
6917 : | CALL
6918 : | CALLED
6919 : | CASCADE
6920 : | CASCADED
6921 : | CATALOG_P
6922 : | CHAIN
6923 : | CHARACTERISTICS
6924 : | CHECKPOINT
6925 : | CLASS
6926 : | CLOSE
6927 : | CLUSTER
6928 : | COLUMNS
6929 : | COMMENT
6930 : | COMMENTS
6931 : | COMMIT
6932 : | COMMITTED
6933 : | COMPRESSION
6934 : | CONDITIONAL
6935 : | CONFIGURATION
6936 : | CONFLICT
6937 : | CONSTRAINTS
6938 : | CONTENT_P
6939 : | CONTINUE_P
6940 : | CONVERSION_P
6941 : | COPY
6942 : | COST
6943 : | CSV
6944 : | CUBE
6945 : | CURSOR
6946 : | CYCLE
6947 : | DATA_P
6948 : | DATABASE
6949 : | DEALLOCATE
6950 : | DECLARE
6951 : | DEFAULTS
6952 : | DEFERRED
6953 : | DEFINER
6954 : | DELETE_P
6955 : | DELIMITER
6956 : | DELIMITERS
6957 : | DEPENDS
6958 : | DEPTH
6959 : | DETACH
6960 : | DICTIONARY
6961 : | DISABLE_P
6962 : | DISCARD
6963 : | DOCUMENT_P
6964 : | DOMAIN_P
6965 : | DOUBLE_P
6966 : | DROP
6967 : | EACH
6968 : | EMPTY_P
6969 : | ENABLE_P
6970 : | ENCODING
6971 : | ENCRYPTED
6972 : | ENFORCED
6973 : | ENUM_P
6974 : | ERROR_P
6975 : | ESCAPE
6976 : | EVENT
6977 : | EXCLUDE
6978 : | EXCLUDING
6979 : | EXCLUSIVE
6980 : | EXECUTE
6981 : | EXPLAIN
6982 : | EXPRESSION
6983 : | EXTENSION
6984 : | EXTERNAL
6985 : | FAMILY
6986 : | FILTER
6987 : | FINALIZE
6988 : | FIRST_P
6989 : | FOLLOWING
6990 : | FORCE
6991 : | FORMAT
6992 : | FORWARD
6993 : | FUNCTION
6994 : | FUNCTIONS
6995 : | GENERATED
6996 : | GLOBAL
6997 : | GRANTED
6998 : | GROUPS
6999 : | HANDLER
7000 : | HEADER_P
7001 : | HOLD
7002 : | IDENTITY_P
7003 : | IF_P
7004 : | IMMEDIATE
7005 : | IMMUTABLE
7006 : | IMPLICIT_P
7007 : | IMPORT_P
7008 : | INCLUDE
7009 : | INCLUDING
7010 : | INCREMENT
7011 : | INDENT
7012 : | INDEX
7013 : | INDEXES
7014 : | INHERIT
7015 : | INHERITS
7016 : | INLINE_P
7017 : | INSENSITIVE
7018 : | INSERT
7019 : | INSTEAD
7020 : | INVOKER
7021 : | ISOLATION
7022 : | KEEP
7023 : | KEY
7024 : | KEYS
7025 : | LABEL
7026 : | LANGUAGE
7027 : | LARGE_P
7028 : | LAST_P
7029 : | LEAKPROOF
7030 : | LEVEL
7031 : | LISTEN
7032 : | LOAD
7033 : | LOCAL
7034 : | LOCATION
7035 : | LOCK_P
7036 : | LOCKED
7037 : | LOGGED
7038 : | MAPPING
7039 : | MATCH
7040 : | MATCHED
7041 : | MATERIALIZED
7042 : | MAXVALUE
7043 : | MERGE
7044 : | METHOD
7045 : | MINVALUE
7046 : | MODE
7047 : | MOVE
7048 : | NAME_P
7049 : | NAMES
7050 : | NESTED
7051 : | NEW
7052 : | NEXT
7053 : | NFC
7054 : | NFD
7055 : | NFKC
7056 : | NFKD
7057 : | NO
7058 : | NORMALIZED
7059 : | NOTHING
7060 : | NOTIFY
7061 : | NOWAIT
7062 : | NULLS_P
7063 : | OBJECT_P
7064 : | OF
7065 : | OFF
7066 : | OIDS
7067 : | OLD
7068 : | OMIT
7069 : | OPERATOR
7070 : | OPTION
7071 : | OPTIONS
7072 : | ORDINALITY
7073 : | OTHERS
7074 : | OVER
7075 : | OVERRIDING
7076 : | OWNED
7077 : | OWNER
7078 : | PARALLEL
7079 : | PARAMETER
7080 : | PARSER
7081 : | PARTIAL
7082 : | PARTITION
7083 : | PASSING
7084 : | PASSWORD
7085 : | PATH
7086 : | PERIOD
7087 : | PLAN
7088 : | PLANS
7089 : | POLICY
7090 : | PRECEDING
7091 : | PREPARE
7092 : | PREPARED
7093 : | PRESERVE
7094 : | PRIOR
7095 : | PRIVILEGES
7096 : | PROCEDURAL
7097 : | PROCEDURE
7098 : | PROCEDURES
7099 : | PROGRAM
7100 : | PUBLICATION
7101 : | QUOTE
7102 : | QUOTES
7103 : | RANGE
7104 : | READ
7105 : | REASSIGN
7106 : | RECURSIVE
7107 : | REF_P
7108 : | REFERENCING
7109 : | REFRESH
7110 : | REINDEX
7111 : | RELATIVE_P
7112 : | RELEASE
7113 : | RENAME
7114 : | REPEATABLE
7115 : | REPLACE
7116 : | REPLICA
7117 : | RESET
7118 : | RESTART
7119 : | RESTRICT
7120 : | RETURN
7121 : | RETURNS
7122 : | REVOKE
7123 : | ROLE
7124 : | ROLLBACK
7125 : | ROLLUP
7126 : | ROUTINE
7127 : | ROUTINES
7128 : | ROWS
7129 : | RULE
7130 : | SAVEPOINT
7131 : | SCALAR
7132 : | SCHEMA
7133 : | SCHEMAS
7134 : | SCROLL
7135 : | SEARCH
7136 : | SECURITY
7137 : | SEQUENCE
7138 : | SEQUENCES
7139 : | SERIALIZABLE
7140 : | SERVER
7141 : | SESSION
7142 : | SET
7143 : | SETS
7144 : | SHARE
7145 : | SHOW
7146 : | SIMPLE
7147 : | SKIP
7148 : | SNAPSHOT
7149 : | SOURCE
7150 : | SQL_P
7151 : | STABLE
7152 : | STANDALONE_P
7153 : | START
7154 : | STATEMENT
7155 : | STATISTICS
7156 : | STDIN
7157 : | STDOUT
7158 : | STORAGE
7159 : | STORED
7160 : | STRICT_P
7161 : | STRING_P
7162 : | STRIP_P
7163 : | SUBSCRIPTION
7164 : | SUPPORT
7165 : | SYSID
7166 : | SYSTEM_P
7167 : | TABLES
7168 : | TABLESPACE
7169 : | TARGET
7170 : | TEMP
7171 : | TEMPLATE
7172 : | TEMPORARY
7173 : | TEXT_P
7174 : | TIES
7175 : | TRANSACTION
7176 : | TRANSFORM
7177 : | TRIGGER
7178 : | TRUNCATE
7179 : | TRUSTED
7180 : | TYPE_P
7181 : | TYPES_P
7182 : | UESCAPE
7183 : | UNBOUNDED
7184 : | UNCOMMITTED
7185 : | UNCONDITIONAL
7186 : | UNENCRYPTED
7187 : | UNKNOWN
7188 : | UNLISTEN
7189 : | UNLOGGED
7190 : | UNTIL
7191 : | UPDATE
7192 : | VACUUM
7193 : | VALID
7194 : | VALIDATE
7195 : | VALIDATOR
7196 : | VALUE_P
7197 : | VARYING
7198 : | VERSION_P
7199 : | VIEW
7200 : | VIEWS
7201 : | VOLATILE
7202 : | WHITESPACE_P
7203 : | WITHIN
7204 : | WITHOUT
7205 : | WORK
7206 : | WRAPPER
7207 : | WRITE
7208 : | XML_P
7209 : | YES_P
7210 : | ZONE
7211 : ;
7212 :
7213 :
7214 : col_name_keyword:
7215 : BETWEEN
7216 : | BIGINT
7217 : | BIT
7218 : | BOOLEAN_P
7219 : | CHARACTER
7220 : | COALESCE
7221 : | DEC
7222 : | DECIMAL_P
7223 : | EXISTS
7224 : | EXTRACT
7225 : | FLOAT_P
7226 : | GREATEST
7227 : | GROUPING
7228 : | INOUT
7229 : | INTEGER
7230 : | INTERVAL
7231 : | JSON
7232 : | JSON_ARRAY
7233 : | JSON_ARRAYAGG
7234 : | JSON_EXISTS
7235 : | JSON_OBJECT
7236 : | JSON_OBJECTAGG
7237 : | JSON_QUERY
7238 : | JSON_SCALAR
7239 : | JSON_SERIALIZE
7240 : | JSON_TABLE
7241 : | JSON_VALUE
7242 : | LEAST
7243 : | MERGE_ACTION
7244 : | NATIONAL
7245 : | NCHAR
7246 : | NONE
7247 : | NORMALIZE
7248 : | NULLIF
7249 : | NUMERIC
7250 : | OUT_P
7251 : | OVERLAY
7252 : | POSITION
7253 : | PRECISION
7254 : | REAL
7255 : | ROW
7256 : | SETOF
7257 : | SMALLINT
7258 : | SUBSTRING
7259 : | TIME
7260 : | TIMESTAMP
7261 : | TREAT
7262 : | TRIM
7263 : | VARCHAR
7264 : | XMLATTRIBUTES
7265 : | XMLCONCAT
7266 : | XMLELEMENT
7267 : | XMLEXISTS
7268 : | XMLFOREST
7269 : | XMLNAMESPACES
7270 : | XMLPARSE
7271 : | XMLPI
7272 : | XMLROOT
7273 : | XMLSERIALIZE
7274 : | XMLTABLE
7275 : ;
7276 :
7277 :
7278 : type_func_name_keyword:
7279 : AUTHORIZATION
7280 : | BINARY
7281 : | COLLATION
7282 : | CONCURRENTLY
7283 : | CROSS
7284 : | CURRENT_SCHEMA
7285 : | FREEZE
7286 : | FULL
7287 : | ILIKE
7288 : | INNER_P
7289 : | IS
7290 : | ISNULL
7291 : | JOIN
7292 : | LEFT
7293 : | LIKE
7294 : | NATURAL
7295 : | NOTNULL
7296 : | OUTER_P
7297 : | OVERLAPS
7298 : | RIGHT
7299 : | SIMILAR
7300 : | TABLESAMPLE
7301 : | VERBOSE
7302 : ;
7303 :
7304 :
7305 : reserved_keyword:
7306 : ALL
7307 : | ANALYSE
7308 : | ANALYZE
7309 : | AND
7310 : | ANY
7311 : | ARRAY
7312 : | AS
7313 : | ASC
7314 : | ASYMMETRIC
7315 : | BOTH
7316 : | CASE
7317 : | CAST
7318 : | CHECK
7319 : | COLLATE
7320 : | COLUMN
7321 : | CONSTRAINT
7322 : | CREATE
7323 : | CURRENT_CATALOG
7324 : | CURRENT_DATE
7325 : | CURRENT_ROLE
7326 : | CURRENT_TIME
7327 : | CURRENT_TIMESTAMP
7328 : | CURRENT_USER
7329 : | DEFAULT
7330 : | DEFERRABLE
7331 : | DESC
7332 : | DISTINCT
7333 : | DO
7334 : | ELSE
7335 : | END_P
7336 : | EXCEPT
7337 : | FALSE_P
7338 : | FETCH
7339 : | FOR
7340 : | FOREIGN
7341 : | FROM
7342 : | GRANT
7343 : | GROUP_P
7344 : | HAVING
7345 : | IN_P
7346 : | INITIALLY
7347 : | INTERSECT
7348 : | INTO
7349 : | LATERAL_P
7350 : | LEADING
7351 : | LIMIT
7352 : | LOCALTIME
7353 : | LOCALTIMESTAMP
7354 : | NOT
7355 : | NULL_P
7356 : | OFFSET
7357 : | ON
7358 : | ONLY
7359 : | OR
7360 : | ORDER
7361 : | PLACING
7362 : | PRIMARY
7363 : | REFERENCES
7364 : | RETURNING
7365 : | SELECT
7366 : | SESSION_USER
7367 : | SOME
7368 : | SYMMETRIC
7369 : | SYSTEM_USER
7370 : | TABLE
7371 : | THEN
7372 : | TRAILING
7373 : | TRUE_P
7374 : | UNIQUE
7375 : | USER
7376 : | USING
7377 : | VARIADIC
7378 : | WHEN
7379 : | WHERE
7380 : | WINDOW
7381 : | WITH
7382 : ;
7383 :
7384 :
7385 : bare_label_keyword:
7386 : ABORT_P
7387 : | ABSENT
7388 : | ABSOLUTE_P
7389 : | ACCESS
7390 : | ACTION
7391 : | ADD_P
7392 : | ADMIN
7393 : | AFTER
7394 : | AGGREGATE
7395 : | ALL
7396 : | ALSO
7397 : | ALTER
7398 : | ALWAYS
7399 : | ANALYSE
7400 : | ANALYZE
7401 : | AND
7402 : | ANY
7403 : | ASC
7404 : | ASENSITIVE
7405 : | ASSERTION
7406 : | ASSIGNMENT
7407 : | ASYMMETRIC
7408 : | AT
7409 : | ATOMIC
7410 : | ATTACH
7411 : | ATTRIBUTE
7412 : | AUTHORIZATION
7413 : | BACKWARD
7414 : | BEFORE
7415 : | BEGIN_P
7416 : | BETWEEN
7417 : | BIGINT
7418 : | BINARY
7419 : | BIT
7420 : | BOOLEAN_P
7421 : | BOTH
7422 : | BREADTH
7423 : | BY
7424 : | CACHE
7425 : | CALL
7426 : | CALLED
7427 : | CASCADE
7428 : | CASCADED
7429 : | CASE
7430 : | CAST
7431 : | CATALOG_P
7432 : | CHAIN
7433 : | CHARACTERISTICS
7434 : | CHECK
7435 : | CHECKPOINT
7436 : | CLASS
7437 : | CLOSE
7438 : | CLUSTER
7439 : | COALESCE
7440 : | COLLATE
7441 : | COLLATION
7442 : | COLUMN
7443 : | COLUMNS
7444 : | COMMENT
7445 : | COMMENTS
7446 : | COMMIT
7447 : | COMMITTED
7448 : | COMPRESSION
7449 : | CONCURRENTLY
7450 : | CONDITIONAL
7451 : | CONFIGURATION
7452 : | CONFLICT
7453 : | CONNECTION
7454 : | CONSTRAINT
7455 : | CONSTRAINTS
7456 : | CONTENT_P
7457 : | CONTINUE_P
7458 : | CONVERSION_P
7459 : | COPY
7460 : | COST
7461 : | CROSS
7462 : | CSV
7463 : | CUBE
7464 : | CURRENT_P
7465 : | CURRENT_CATALOG
7466 : | CURRENT_DATE
7467 : | CURRENT_ROLE
7468 : | CURRENT_SCHEMA
7469 : | CURRENT_TIME
7470 : | CURRENT_TIMESTAMP
7471 : | CURRENT_USER
7472 : | CURSOR
7473 : | CYCLE
7474 : | DATA_P
7475 : | DATABASE
7476 : | DEALLOCATE
7477 : | DEC
7478 : | DECIMAL_P
7479 : | DECLARE
7480 : | DEFAULT
7481 : | DEFAULTS
7482 : | DEFERRABLE
7483 : | DEFERRED
7484 : | DEFINER
7485 : | DELETE_P
7486 : | DELIMITER
7487 : | DELIMITERS
7488 : | DEPENDS
7489 : | DEPTH
7490 : | DESC
7491 : | DETACH
7492 : | DICTIONARY
7493 : | DISABLE_P
7494 : | DISCARD
7495 : | DISTINCT
7496 : | DO
7497 : | DOCUMENT_P
7498 : | DOMAIN_P
7499 : | DOUBLE_P
7500 : | DROP
7501 : | EACH
7502 : | ELSE
7503 : | EMPTY_P
7504 : | ENABLE_P
7505 : | ENCODING
7506 : | ENCRYPTED
7507 : | END_P
7508 : | ENFORCED
7509 : | ENUM_P
7510 : | ERROR_P
7511 : | ESCAPE
7512 : | EVENT
7513 : | EXCLUDE
7514 : | EXCLUDING
7515 : | EXCLUSIVE
7516 : | EXECUTE
7517 : | EXISTS
7518 : | EXPLAIN
7519 : | EXPRESSION
7520 : | EXTENSION
7521 : | EXTERNAL
7522 : | EXTRACT
7523 : | FALSE_P
7524 : | FAMILY
7525 : | FINALIZE
7526 : | FIRST_P
7527 : | FLOAT_P
7528 : | FOLLOWING
7529 : | FORCE
7530 : | FOREIGN
7531 : | FORMAT
7532 : | FORWARD
7533 : | FREEZE
7534 : | FULL
7535 : | FUNCTION
7536 : | FUNCTIONS
7537 : | GENERATED
7538 : | GLOBAL
7539 : | GRANTED
7540 : | GREATEST
7541 : | GROUPING
7542 : | GROUPS
7543 : | HANDLER
7544 : | HEADER_P
7545 : | HOLD
7546 : | IDENTITY_P
7547 : | IF_P
7548 : | ILIKE
7549 : | IMMEDIATE
7550 : | IMMUTABLE
7551 : | IMPLICIT_P
7552 : | IMPORT_P
7553 : | IN_P
7554 : | INCLUDE
7555 : | INCLUDING
7556 : | INCREMENT
7557 : | INDENT
7558 : | INDEX
7559 : | INDEXES
7560 : | INHERIT
7561 : | INHERITS
7562 : | INITIALLY
7563 : | INLINE_P
7564 : | INNER_P
7565 : | INOUT
7566 : | INPUT_P
7567 : | INSENSITIVE
7568 : | INSERT
7569 : | INSTEAD
7570 : | INT_P
7571 : | INTEGER
7572 : | INTERVAL
7573 : | INVOKER
7574 : | IS
7575 : | ISOLATION
7576 : | JOIN
7577 : | JSON
7578 : | JSON_ARRAY
7579 : | JSON_ARRAYAGG
7580 : | JSON_EXISTS
7581 : | JSON_OBJECT
7582 : | JSON_OBJECTAGG
7583 : | JSON_QUERY
7584 : | JSON_SCALAR
7585 : | JSON_SERIALIZE
7586 : | JSON_TABLE
7587 : | JSON_VALUE
7588 : | KEEP
7589 : | KEY
7590 : | KEYS
7591 : | LABEL
7592 : | LANGUAGE
7593 : | LARGE_P
7594 : | LAST_P
7595 : | LATERAL_P
7596 : | LEADING
7597 : | LEAKPROOF
7598 : | LEAST
7599 : | LEFT
7600 : | LEVEL
7601 : | LIKE
7602 : | LISTEN
7603 : | LOAD
7604 : | LOCAL
7605 : | LOCALTIME
7606 : | LOCALTIMESTAMP
7607 : | LOCATION
7608 : | LOCK_P
7609 : | LOCKED
7610 : | LOGGED
7611 : | MAPPING
7612 : | MATCH
7613 : | MATCHED
7614 : | MATERIALIZED
7615 : | MAXVALUE
7616 : | MERGE
7617 : | MERGE_ACTION
7618 : | METHOD
7619 : | MINVALUE
7620 : | MODE
7621 : | MOVE
7622 : | NAME_P
7623 : | NAMES
7624 : | NATIONAL
7625 : | NATURAL
7626 : | NCHAR
7627 : | NESTED
7628 : | NEW
7629 : | NEXT
7630 : | NFC
7631 : | NFD
7632 : | NFKC
7633 : | NFKD
7634 : | NO
7635 : | NONE
7636 : | NORMALIZE
7637 : | NORMALIZED
7638 : | NOT
7639 : | NOTHING
7640 : | NOTIFY
7641 : | NOWAIT
7642 : | NULL_P
7643 : | NULLIF
7644 : | NULLS_P
7645 : | NUMERIC
7646 : | OBJECT_P
7647 : | OF
7648 : | OFF
7649 : | OIDS
7650 : | OLD
7651 : | OMIT
7652 : | ONLY
7653 : | OPERATOR
7654 : | OPTION
7655 : | OPTIONS
7656 : | OR
7657 : | ORDINALITY
7658 : | OTHERS
7659 : | OUT_P
7660 : | OUTER_P
7661 : | OVERLAY
7662 : | OVERRIDING
7663 : | OWNED
7664 : | OWNER
7665 : | PARALLEL
7666 : | PARAMETER
7667 : | PARSER
7668 : | PARTIAL
7669 : | PARTITION
7670 : | PASSING
7671 : | PASSWORD
7672 : | PATH
7673 : | PERIOD
7674 : | PLACING
7675 : | PLAN
7676 : | PLANS
7677 : | POLICY
7678 : | POSITION
7679 : | PRECEDING
7680 : | PREPARE
7681 : | PREPARED
7682 : | PRESERVE
7683 : | PRIMARY
7684 : | PRIOR
7685 : | PRIVILEGES
7686 : | PROCEDURAL
7687 : | PROCEDURE
7688 : | PROCEDURES
7689 : | PROGRAM
7690 : | PUBLICATION
7691 : | QUOTE
7692 : | QUOTES
7693 : | RANGE
7694 : | READ
7695 : | REAL
7696 : | REASSIGN
7697 : | RECURSIVE
7698 : | REF_P
7699 : | REFERENCES
7700 : | REFERENCING
7701 : | REFRESH
7702 : | REINDEX
7703 : | RELATIVE_P
7704 : | RELEASE
7705 : | RENAME
7706 : | REPEATABLE
7707 : | REPLACE
7708 : | REPLICA
7709 : | RESET
7710 : | RESTART
7711 : | RESTRICT
7712 : | RETURN
7713 : | RETURNS
7714 : | REVOKE
7715 : | RIGHT
7716 : | ROLE
7717 : | ROLLBACK
7718 : | ROLLUP
7719 : | ROUTINE
7720 : | ROUTINES
7721 : | ROW
7722 : | ROWS
7723 : | RULE
7724 : | SAVEPOINT
7725 : | SCALAR
7726 : | SCHEMA
7727 : | SCHEMAS
7728 : | SCROLL
7729 : | SEARCH
7730 : | SECURITY
7731 : | SELECT
7732 : | SEQUENCE
7733 : | SEQUENCES
7734 : | SERIALIZABLE
7735 : | SERVER
7736 : | SESSION
7737 : | SESSION_USER
7738 : | SET
7739 : | SETOF
7740 : | SETS
7741 : | SHARE
7742 : | SHOW
7743 : | SIMILAR
7744 : | SIMPLE
7745 : | SKIP
7746 : | SMALLINT
7747 : | SNAPSHOT
7748 : | SOME
7749 : | SOURCE
7750 : | SQL_P
7751 : | STABLE
7752 : | STANDALONE_P
7753 : | START
7754 : | STATEMENT
7755 : | STATISTICS
7756 : | STDIN
7757 : | STDOUT
7758 : | STORAGE
7759 : | STORED
7760 : | STRICT_P
7761 : | STRING_P
7762 : | STRIP_P
7763 : | SUBSCRIPTION
7764 : | SUBSTRING
7765 : | SUPPORT
7766 : | SYMMETRIC
7767 : | SYSID
7768 : | SYSTEM_P
7769 : | SYSTEM_USER
7770 : | TABLE
7771 : | TABLES
7772 : | TABLESAMPLE
7773 : | TABLESPACE
7774 : | TARGET
7775 : | TEMP
7776 : | TEMPLATE
7777 : | TEMPORARY
7778 : | TEXT_P
7779 : | THEN
7780 : | TIES
7781 : | TIME
7782 : | TIMESTAMP
7783 : | TRAILING
7784 : | TRANSACTION
7785 : | TRANSFORM
7786 : | TREAT
7787 : | TRIGGER
7788 : | TRIM
7789 : | TRUE_P
7790 : | TRUNCATE
7791 : | TRUSTED
7792 : | TYPE_P
7793 : | TYPES_P
7794 : | UESCAPE
7795 : | UNBOUNDED
7796 : | UNCOMMITTED
7797 : | UNCONDITIONAL
7798 : | UNENCRYPTED
7799 : | UNIQUE
7800 : | UNKNOWN
7801 : | UNLISTEN
7802 : | UNLOGGED
7803 : | UNTIL
7804 : | UPDATE
7805 : | USER
7806 : | USING
7807 : | VACUUM
7808 : | VALID
7809 : | VALIDATE
7810 : | VALIDATOR
7811 : | VALUE_P
7812 : | VALUES
7813 : | VARCHAR
7814 : | VARIADIC
7815 : | VERBOSE
7816 : | VERSION_P
7817 : | VIEW
7818 : | VIEWS
7819 : | VOLATILE
7820 : | WHEN
7821 : | WHITESPACE_P
7822 : | WORK
7823 : | WRAPPER
7824 : | WRITE
7825 : | XML_P
7826 : | XMLATTRIBUTES
7827 : | XMLCONCAT
7828 : | XMLELEMENT
7829 : | XMLEXISTS
7830 : | XMLFOREST
7831 : | XMLNAMESPACES
7832 : | XMLPARSE
7833 : | XMLPI
7834 : | XMLROOT
7835 : | XMLSERIALIZE
7836 : | XMLTABLE
7837 : | YES_P
7838 : | ZONE
7839 : ;
7840 :
7841 :
7842 : /* trailer */
7843 : /* src/interfaces/ecpg/preproc/ecpg.trailer */
7844 :
7845 : statements: /* EMPTY */
7846 : | statements statement
7847 : {
7848 : /* Reclaim local storage used while processing statement */
7849 47742 : reclaim_local_storage();
7850 : /* Clean up now-dangling location pointer */
7851 47742 : @$ = "";
7852 : }
7853 : ;
7854 :
7855 : statement: ecpgstart at toplevel_stmt ';'
7856 : {
7857 196 : if (connection)
7858 196 : free(connection);
7859 196 : connection = NULL;
7860 : }
7861 : | ecpgstart toplevel_stmt ';'
7862 : {
7863 2182 : if (connection)
7864 26 : free(connection);
7865 2182 : connection = NULL;
7866 : }
7867 : | ecpgstart ECPGVarDeclaration
7868 : {
7869 48 : fprintf(base_yyout, "%s", @$);
7870 48 : output_line_number();
7871 : }
7872 : | ECPGDeclaration
7873 : | c_thing
7874 : {
7875 42422 : fprintf(base_yyout, "%s", @$);
7876 : }
7877 : | CPP_LINE
7878 : {
7879 1446 : fprintf(base_yyout, "%s", @$);
7880 : }
7881 : | '{'
7882 : {
7883 660 : braces_open++;
7884 660 : fputs("{", base_yyout);
7885 : }
7886 : | '}'
7887 : {
7888 660 : if (braces_open > 0)
7889 : {
7890 660 : remove_typedefs(braces_open);
7891 660 : remove_variables(braces_open);
7892 660 : if (--braces_open == 0)
7893 : {
7894 290 : free(current_function);
7895 290 : current_function = NULL;
7896 : }
7897 : }
7898 660 : fputs("}", base_yyout);
7899 : }
7900 : ;
7901 :
7902 : CreateAsStmt: CREATE OptTemp TABLE create_as_target AS
7903 : {
7904 2 : FoundInto = 0;
7905 : } SelectStmt opt_with_data
7906 : {
7907 2 : if (FoundInto == 1)
7908 0 : mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
7909 : }
7910 : | CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS
7911 : {
7912 2 : FoundInto = 0;
7913 : } SelectStmt opt_with_data
7914 : {
7915 2 : if (FoundInto == 1)
7916 0 : mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
7917 : }
7918 : ;
7919 :
7920 : at: AT connection_object
7921 : {
7922 196 : if (connection)
7923 0 : free(connection);
7924 196 : connection = mm_strdup(@2);
7925 :
7926 : /*
7927 : * Do we have a variable as connection target? Remove the variable
7928 : * from the variable list or else it will be used twice.
7929 : */
7930 196 : if (argsinsert != NULL)
7931 0 : argsinsert = NULL;
7932 : }
7933 : ;
7934 :
7935 : /*
7936 : * the exec sql connect statement: connect to the given database
7937 : */
7938 : ECPGConnect: SQL_CONNECT TO connection_target opt_connection_name opt_user
7939 : {
7940 186 : @$ = cat_str(5, @3, ",", @5, ",", @4);
7941 : }
7942 : | SQL_CONNECT TO DEFAULT
7943 : {
7944 0 : @$ = "NULL, NULL, NULL, \"DEFAULT\"";
7945 : }
7946 : /* also allow ORACLE syntax */
7947 : | SQL_CONNECT ora_user
7948 : {
7949 0 : @$ = cat_str(3, "NULL,", @2, ", NULL");
7950 : }
7951 : | DATABASE connection_target
7952 : {
7953 0 : @$ = cat2_str(@2, ", NULL, NULL, NULL");
7954 : }
7955 : ;
7956 :
7957 : connection_target: opt_database_name opt_server opt_port
7958 : {
7959 : /* old style: dbname[@server][:port] */
7960 158 : if (strlen(@2) > 0 && *(@2) != '@')
7961 0 : mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\", found \"%s\"", @2);
7962 :
7963 : /* C strings need to be handled differently */
7964 158 : if (@1[0] == '\"')
7965 10 : @$ = @1;
7966 : else
7967 148 : @$ = make3_str("\"", make3_str(@1, @2, @3), "\"");
7968 : }
7969 : | db_prefix ':' server opt_port '/' opt_database_name opt_options
7970 : {
7971 : /* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
7972 18 : if (strncmp(@1, "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp(@1, "tcp:postgresql", strlen("tcp:postgresql")) != 0)
7973 0 : mmerror(PARSE_ERROR, ET_ERROR, "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported");
7974 :
7975 18 : if (strncmp(@3, "//", strlen("//")) != 0)
7976 0 : mmerror(PARSE_ERROR, ET_ERROR, "expected \"://\", found \"%s\"", @3);
7977 :
7978 18 : if (strncmp(@1, "unix", strlen("unix")) == 0 &&
7979 10 : strncmp(@3 + strlen("//"), "localhost", strlen("localhost")) != 0 &&
7980 0 : strncmp(@3 + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
7981 0 : mmerror(PARSE_ERROR, ET_ERROR, "Unix-domain sockets only work on \"localhost\" but not on \"%s\"", @3 + strlen("//"));
7982 :
7983 18 : @$ = make3_str(make3_str("\"", @1, ":"), @3, make3_str(make3_str(@4, "/", @6), @7, "\""));
7984 : }
7985 : | char_variable
7986 : | ecpg_sconst
7987 : {
7988 : /*
7989 : * We can only process double quoted strings not single quoted ones,
7990 : * so we change the quotes. Note that the rule for ecpg_sconst adds
7991 : * these single quotes.
7992 : */
7993 4 : char *str = loc_strdup(@1);
7994 :
7995 4 : str[0] = '\"';
7996 4 : str[strlen(str) - 1] = '\"';
7997 4 : @$ = str;
7998 : }
7999 : ;
8000 :
8001 : opt_database_name: name
8002 : | /* EMPTY */
8003 : ;
8004 :
8005 : db_prefix: ecpg_ident cvariable
8006 : {
8007 18 : if (strcmp(@2, "postgresql") != 0 && strcmp(@2, "postgres") != 0)
8008 0 : mmerror(PARSE_ERROR, ET_ERROR, "expected \"postgresql\", found \"%s\"", @2);
8009 :
8010 18 : if (strcmp(@1, "tcp") != 0 && strcmp(@1, "unix") != 0)
8011 0 : mmerror(PARSE_ERROR, ET_ERROR, "invalid connection type: %s", @1);
8012 :
8013 18 : @$ = make3_str(@1, ":", @2);
8014 : }
8015 : ;
8016 :
8017 : server: Op server_name
8018 : {
8019 22 : if (strcmp(@1, "@") != 0 && strcmp(@1, "//") != 0)
8020 0 : mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\" or \"://\", found \"%s\"", @1);
8021 :
8022 22 : @$ = make2_str(@1, @2);
8023 : }
8024 : ;
8025 :
8026 : opt_server: server
8027 : | /* EMPTY */
8028 : ;
8029 :
8030 : server_name: ColId
8031 : | ColId '.' server_name
8032 : | IP
8033 : ;
8034 :
8035 : opt_port: ':' Iconst
8036 : {
8037 2 : @$ = make2_str(":", @2);
8038 : }
8039 : | /* EMPTY */
8040 : ;
8041 :
8042 : opt_connection_name: AS connection_object
8043 : {
8044 76 : @$ = @2;
8045 : }
8046 : | /* EMPTY */
8047 : {
8048 110 : @$ = "NULL";
8049 : }
8050 : ;
8051 :
8052 : opt_user: USER ora_user
8053 : {
8054 32 : @$ = @2;
8055 : }
8056 : | /* EMPTY */
8057 : {
8058 154 : @$ = "NULL, NULL";
8059 : }
8060 : ;
8061 :
8062 : ora_user: user_name
8063 : {
8064 6 : @$ = cat2_str(@1, ", NULL");
8065 : }
8066 : | user_name '/' user_name
8067 : {
8068 10 : @$ = cat_str(3, @1, ",", @3);
8069 : }
8070 : | user_name SQL_IDENTIFIED BY user_name
8071 : {
8072 10 : @$ = cat_str(3, @1, ",", @4);
8073 : }
8074 : | user_name USING user_name
8075 : {
8076 6 : @$ = cat_str(3, @1, ",", @3);
8077 : }
8078 : ;
8079 :
8080 : user_name: RoleId
8081 : {
8082 54 : if (@1[0] == '\"')
8083 6 : @$ = @1;
8084 : else
8085 48 : @$ = make3_str("\"", @1, "\"");
8086 : }
8087 : | ecpg_sconst
8088 : {
8089 0 : if (@1[0] == '\"')
8090 0 : @$ = @1;
8091 : else
8092 0 : @$ = make3_str("\"", @1, "\"");
8093 : }
8094 : | civar
8095 : {
8096 4 : enum ECPGttype type = argsinsert->variable->type->type;
8097 :
8098 : /* if array see what's inside */
8099 4 : if (type == ECPGt_array)
8100 0 : type = argsinsert->variable->type->u.element->type;
8101 :
8102 : /* handle varchars */
8103 4 : if (type == ECPGt_varchar)
8104 0 : @$ = make2_str(argsinsert->variable->name, ".arr");
8105 : else
8106 4 : @$ = argsinsert->variable->name;
8107 : }
8108 : ;
8109 :
8110 : char_variable: cvariable
8111 : {
8112 : /* check if we have a string variable */
8113 256 : struct variable *p = find_variable(@1);
8114 256 : enum ECPGttype type = p->type->type;
8115 :
8116 : /* If we have just one character this is not a string */
8117 256 : if (atol(p->type->size) == 1)
8118 0 : mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
8119 : else
8120 : {
8121 : /* if array see what's inside */
8122 256 : if (type == ECPGt_array)
8123 0 : type = p->type->u.element->type;
8124 :
8125 : switch (type)
8126 : {
8127 236 : case ECPGt_char:
8128 : case ECPGt_unsigned_char:
8129 : case ECPGt_string:
8130 236 : @$ = @1;
8131 236 : break;
8132 20 : case ECPGt_varchar:
8133 20 : @$ = make2_str(@1, ".arr");
8134 20 : break;
8135 0 : default:
8136 0 : mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
8137 0 : @$ = @1;
8138 0 : break;
8139 : }
8140 : }
8141 : }
8142 : ;
8143 :
8144 : opt_options: Op connect_options
8145 : {
8146 4 : if (strlen(@1) == 0)
8147 0 : mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
8148 :
8149 4 : if (strcmp(@1, "?") != 0)
8150 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", @1);
8151 :
8152 4 : @$ = make2_str("?", @2);
8153 : }
8154 : | /* EMPTY */
8155 : ;
8156 :
8157 : connect_options: ColId opt_opt_value
8158 : {
8159 4 : @$ = make2_str(@1, @2);
8160 : }
8161 : | ColId opt_opt_value Op connect_options
8162 : {
8163 2 : if (strlen(@3) == 0)
8164 0 : mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
8165 :
8166 2 : if (strcmp(@3, "&") != 0)
8167 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", @3);
8168 :
8169 2 : @$ = make3_str(make2_str(@1, @2), @3, @4);
8170 : }
8171 : ;
8172 :
8173 : opt_opt_value: /* EMPTY */
8174 : | '=' Iconst
8175 : {
8176 4 : @$ = make2_str("=", @2);
8177 : }
8178 : | '=' ecpg_ident
8179 : {
8180 2 : @$ = make2_str("=", @2);
8181 : }
8182 : | '=' civar
8183 : {
8184 0 : @$ = make2_str("=", @2);
8185 : }
8186 : ;
8187 :
8188 : prepared_name: name
8189 : {
8190 310 : size_t slen = strlen(@1);
8191 :
8192 310 : if (@1[0] == '\"' && @1[slen - 1] == '\"') /* already quoted? */
8193 50 : @$ = @1;
8194 : else /* not quoted => convert to lowercase */
8195 : {
8196 260 : char *str = loc_alloc(slen + 3);
8197 :
8198 260 : str[0] = '\"';
8199 1666 : for (size_t i = 0; i < slen; i++)
8200 1406 : str[i + 1] = tolower((unsigned char) @1[i]);
8201 260 : str[slen + 1] = '\"';
8202 260 : str[slen + 2] = '\0';
8203 260 : @$ = str;
8204 : }
8205 : }
8206 : | char_variable
8207 : ;
8208 :
8209 : /*
8210 : * Declare Statement
8211 : */
8212 : ECPGDeclareStmt: DECLARE prepared_name STATEMENT
8213 : {
8214 : struct declared_list *ptr;
8215 :
8216 : /* Check whether the declared name has been defined or not */
8217 30 : for (ptr = g_declared_list; ptr != NULL; ptr = ptr->next)
8218 : {
8219 20 : if (strcmp(@2, ptr->name) == 0)
8220 : {
8221 : /* re-definition is not allowed */
8222 0 : mmerror(PARSE_ERROR, ET_ERROR, "name \"%s\" is already declared", ptr->name);
8223 : }
8224 : }
8225 :
8226 : /* Add a new declared name into the g_declared_list */
8227 10 : ptr = (struct declared_list *) mm_alloc(sizeof(struct declared_list));
8228 10 : if (ptr)
8229 : {
8230 : /* initial definition */
8231 10 : ptr->name = mm_strdup(@2);
8232 10 : if (connection)
8233 4 : ptr->connection = mm_strdup(connection);
8234 : else
8235 6 : ptr->connection = NULL;
8236 :
8237 10 : ptr->next = g_declared_list;
8238 10 : g_declared_list = ptr;
8239 : }
8240 :
8241 10 : @$ = cat_str(3, "/* declare ", @2, " as an SQL identifier */");
8242 : }
8243 : ;
8244 :
8245 : /*
8246 : * Declare a prepared cursor. The syntax is different from the standard
8247 : * declare statement, so we create a new rule.
8248 : */
8249 : ECPGCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR prepared_name
8250 : {
8251 : struct cursor *ptr,
8252 : *this;
8253 40 : const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
8254 40 : int (*strcmp_fn) (const char *, const char *) = ((@2[0] == ':' || @2[0] == '"') ? strcmp : pg_strcasecmp);
8255 40 : struct variable *thisquery = (struct variable *) mm_alloc(sizeof(struct variable));
8256 : char *comment;
8257 : char *con;
8258 :
8259 40 : if (INFORMIX_MODE && pg_strcasecmp(@2, "database") == 0)
8260 0 : mmfatal(PARSE_ERROR, "\"database\" cannot be used as cursor name in INFORMIX mode");
8261 :
8262 40 : check_declared_list(@7);
8263 40 : con = connection ? connection : "NULL";
8264 84 : for (ptr = cur; ptr != NULL; ptr = ptr->next)
8265 : {
8266 44 : if (strcmp_fn(@2, ptr->name) == 0)
8267 : {
8268 : /* re-definition is a bug */
8269 0 : if (@2[0] == ':')
8270 0 : mmerror(PARSE_ERROR, ET_ERROR, "using variable \"%s\" in different declare statements is not supported", @2 + 1);
8271 : else
8272 0 : mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", @2);
8273 : }
8274 : }
8275 :
8276 40 : this = (struct cursor *) mm_alloc(sizeof(struct cursor));
8277 :
8278 : /* initial definition */
8279 40 : this->next = cur;
8280 40 : this->name = mm_strdup(@2);
8281 40 : this->function = (current_function ? mm_strdup(current_function) : NULL);
8282 40 : this->connection = connection ? mm_strdup(connection) : NULL;
8283 40 : this->opened = false;
8284 40 : this->command = mm_strdup(cat_str(6, "declare", cursor_marker, @3, "cursor", @5, "for $1"));
8285 40 : this->argsresult = NULL;
8286 40 : this->argsresult_oos = NULL;
8287 :
8288 40 : thisquery->type = &ecpg_query;
8289 40 : thisquery->brace_level = 0;
8290 40 : thisquery->next = NULL;
8291 40 : thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(, , __LINE__)") + strlen(con) + strlen(@7));
8292 40 : sprintf(thisquery->name, "ECPGprepared_statement(%s, %s, __LINE__)", con, @7);
8293 :
8294 40 : this->argsinsert = NULL;
8295 40 : this->argsinsert_oos = NULL;
8296 40 : if (@2[0] == ':')
8297 : {
8298 6 : struct variable *var = find_variable(@2 + 1);
8299 :
8300 6 : remove_variable_from_list(&argsinsert, var);
8301 6 : add_variable_to_head(&(this->argsinsert), var, &no_indicator);
8302 : }
8303 40 : add_variable_to_head(&(this->argsinsert), thisquery, &no_indicator);
8304 :
8305 40 : cur = this;
8306 :
8307 40 : comment = cat_str(3, "/*", this->command, "*/");
8308 :
8309 40 : @$ = cat_str(2, adjust_outofscope_cursor_vars(this),
8310 : comment);
8311 : }
8312 : ;
8313 :
8314 : ECPGExecuteImmediateStmt: EXECUTE IMMEDIATE execstring
8315 : {
8316 : /*
8317 : * execute immediate means prepare the statement and immediately
8318 : * execute it
8319 : */
8320 14 : @$ = @3;
8321 : }
8322 : ;
8323 :
8324 : /*
8325 : * variable declaration outside exec sql declare block
8326 : */
8327 : ECPGVarDeclaration: single_vt_declaration;
8328 :
8329 : single_vt_declaration: type_declaration
8330 : | var_declaration
8331 : ;
8332 :
8333 : precision: NumericOnly
8334 : ;
8335 :
8336 : opt_scale: ',' NumericOnly
8337 : {
8338 2 : @$ = @2;
8339 : }
8340 : | /* EMPTY */
8341 : ;
8342 :
8343 : ecpg_interval: opt_interval
8344 : | YEAR_P TO MINUTE_P
8345 : | YEAR_P TO SECOND_P
8346 : | DAY_P TO DAY_P
8347 : | MONTH_P TO MONTH_P
8348 : ;
8349 :
8350 : /*
8351 : * variable declaration inside exec sql declare block
8352 : */
8353 : ECPGDeclaration: sql_startdeclare
8354 : {
8355 128 : fputs("/* exec sql begin declare section */", base_yyout);
8356 : }
8357 : var_type_declarations sql_enddeclare
8358 : {
8359 128 : fprintf(base_yyout, "%s/* exec sql end declare section */", @3);
8360 128 : output_line_number();
8361 : }
8362 : ;
8363 :
8364 : sql_startdeclare: ecpgstart BEGIN_P DECLARE SQL_SECTION ';'
8365 : {
8366 : }
8367 : ;
8368 :
8369 : sql_enddeclare: ecpgstart END_P DECLARE SQL_SECTION ';'
8370 : {
8371 : }
8372 : ;
8373 :
8374 : var_type_declarations: /* EMPTY */
8375 : | vt_declarations
8376 : ;
8377 :
8378 : vt_declarations: single_vt_declaration
8379 : | CPP_LINE
8380 : | vt_declarations single_vt_declaration
8381 : | vt_declarations CPP_LINE
8382 : ;
8383 :
8384 : variable_declarations: var_declaration
8385 : | variable_declarations var_declaration
8386 : ;
8387 :
8388 : type_declaration: S_TYPEDEF
8389 : {
8390 : /* reset this variable so we see if there was */
8391 : /* an initializer specified */
8392 18 : initializer = 0;
8393 : }
8394 : var_type opt_pointer ECPGColLabel opt_array_bounds ';'
8395 : {
8396 18 : add_typedef(@5, $6.index1, $6.index2, $3.type_enum, $3.type_dimension, $3.type_index, initializer, *@4 ? 1 : 0);
8397 :
8398 18 : fprintf(base_yyout, "typedef %s %s %s %s;\n", $3.type_str, *@4 ? "*" : "", @5, $6.str);
8399 18 : output_line_number();
8400 18 : @$ = "";
8401 : }
8402 : ;
8403 :
8404 : var_declaration:
8405 : storage_declaration var_type
8406 : {
8407 4 : actual_type[struct_level].type_storage = loc_strdup(@1);
8408 4 : actual_type[struct_level].type_enum = $2.type_enum;
8409 4 : actual_type[struct_level].type_str = $2.type_str;
8410 4 : actual_type[struct_level].type_dimension = $2.type_dimension;
8411 4 : actual_type[struct_level].type_index = $2.type_index;
8412 4 : actual_type[struct_level].type_sizeof = $2.type_sizeof;
8413 :
8414 4 : actual_startline[struct_level] = hashline_number();
8415 : }
8416 : variable_list ';'
8417 : {
8418 4 : @$ = cat_str(5, actual_startline[struct_level], @1, $2.type_str, @4, ";\n");
8419 : }
8420 : | var_type
8421 : {
8422 588 : actual_type[struct_level].type_storage = loc_strdup("");
8423 588 : actual_type[struct_level].type_enum = $1.type_enum;
8424 588 : actual_type[struct_level].type_str = $1.type_str;
8425 588 : actual_type[struct_level].type_dimension = $1.type_dimension;
8426 588 : actual_type[struct_level].type_index = $1.type_index;
8427 588 : actual_type[struct_level].type_sizeof = $1.type_sizeof;
8428 :
8429 588 : actual_startline[struct_level] = hashline_number();
8430 : }
8431 : variable_list ';'
8432 : {
8433 588 : @$ = cat_str(4, actual_startline[struct_level], $1.type_str, @3, ";\n");
8434 : }
8435 : | struct_union_type_with_symbol ';'
8436 : ;
8437 :
8438 : opt_bit_field: ':' Iconst
8439 : | /* EMPTY */
8440 : ;
8441 :
8442 : storage_declaration: storage_clause storage_modifier
8443 : | storage_clause
8444 : | storage_modifier
8445 : ;
8446 :
8447 : storage_clause: S_EXTERN
8448 : | S_STATIC
8449 : | S_REGISTER
8450 : | S_AUTO
8451 : ;
8452 :
8453 : storage_modifier: S_CONST
8454 : | S_VOLATILE
8455 : ;
8456 :
8457 : var_type: simple_type
8458 : {
8459 454 : $$.type_enum = $1;
8460 454 : $$.type_str = loc_strdup(ecpg_type_name($1));
8461 454 : $$.type_dimension = "-1";
8462 454 : $$.type_index = "-1";
8463 454 : $$.type_sizeof = NULL;
8464 : }
8465 : | struct_union_type
8466 : {
8467 32 : $$.type_str = loc_strdup(@1);
8468 32 : $$.type_dimension = "-1";
8469 32 : $$.type_index = "-1";
8470 :
8471 32 : if (strncmp(@1, "struct", sizeof("struct") - 1) == 0)
8472 : {
8473 28 : $$.type_enum = ECPGt_struct;
8474 28 : $$.type_sizeof = ECPGstruct_sizeof;
8475 : }
8476 : else
8477 : {
8478 4 : $$.type_enum = ECPGt_union;
8479 4 : $$.type_sizeof = NULL;
8480 : }
8481 : }
8482 : | enum_type
8483 : {
8484 0 : $$.type_str = loc_strdup(@1);
8485 0 : $$.type_enum = ECPGt_int;
8486 0 : $$.type_dimension = "-1";
8487 0 : $$.type_index = "-1";
8488 0 : $$.type_sizeof = NULL;
8489 : }
8490 : | NUMERIC '(' precision opt_scale ')'
8491 : {
8492 0 : $$.type_enum = ECPGt_numeric;
8493 0 : $$.type_str = "numeric";
8494 0 : $$.type_dimension = "-1";
8495 0 : $$.type_index = "-1";
8496 0 : $$.type_sizeof = NULL;
8497 : }
8498 : | DECIMAL_P '(' precision opt_scale ')'
8499 : {
8500 0 : $$.type_enum = ECPGt_decimal;
8501 0 : $$.type_str = "decimal";
8502 0 : $$.type_dimension = "-1";
8503 0 : $$.type_index = "-1";
8504 0 : $$.type_sizeof = NULL;
8505 : }
8506 : | IDENT '(' precision opt_scale ')'
8507 : {
8508 : /*
8509 : * In C parsing mode, NUMERIC and DECIMAL are not keywords, so they
8510 : * will show up here as a plain identifier, and we need this duplicate
8511 : * code to recognize them.
8512 : */
8513 2 : if (strcmp(@1, "numeric") == 0)
8514 : {
8515 2 : $$.type_enum = ECPGt_numeric;
8516 2 : $$.type_str = "numeric";
8517 : }
8518 0 : else if (strcmp(@1, "decimal") == 0)
8519 : {
8520 0 : $$.type_enum = ECPGt_decimal;
8521 0 : $$.type_str = "decimal";
8522 : }
8523 : else
8524 : {
8525 0 : mmerror(PARSE_ERROR, ET_ERROR, "only data types numeric and decimal have precision/scale argument");
8526 0 : $$.type_enum = ECPGt_numeric;
8527 0 : $$.type_str = "numeric";
8528 : }
8529 :
8530 2 : $$.type_dimension = "-1";
8531 2 : $$.type_index = "-1";
8532 2 : $$.type_sizeof = NULL;
8533 : }
8534 : | VARCHAR
8535 : {
8536 28 : $$.type_enum = ECPGt_varchar;
8537 28 : $$.type_str = ""; /* "varchar"; */
8538 28 : $$.type_dimension = "-1";
8539 28 : $$.type_index = "-1";
8540 28 : $$.type_sizeof = NULL;
8541 : }
8542 : | FLOAT_P
8543 : {
8544 : /* Note: DOUBLE is handled in simple_type */
8545 6 : $$.type_enum = ECPGt_float;
8546 6 : $$.type_str = "float";
8547 6 : $$.type_dimension = "-1";
8548 6 : $$.type_index = "-1";
8549 6 : $$.type_sizeof = NULL;
8550 : }
8551 : | NUMERIC
8552 : {
8553 0 : $$.type_enum = ECPGt_numeric;
8554 0 : $$.type_str = "numeric";
8555 0 : $$.type_dimension = "-1";
8556 0 : $$.type_index = "-1";
8557 0 : $$.type_sizeof = NULL;
8558 : }
8559 : | DECIMAL_P
8560 : {
8561 4 : $$.type_enum = ECPGt_decimal;
8562 4 : $$.type_str = "decimal";
8563 4 : $$.type_dimension = "-1";
8564 4 : $$.type_index = "-1";
8565 4 : $$.type_sizeof = NULL;
8566 : }
8567 : | TIMESTAMP
8568 : {
8569 2 : $$.type_enum = ECPGt_timestamp;
8570 2 : $$.type_str = "timestamp";
8571 2 : $$.type_dimension = "-1";
8572 2 : $$.type_index = "-1";
8573 2 : $$.type_sizeof = NULL;
8574 : }
8575 : | STRING_P
8576 : {
8577 2 : if (INFORMIX_MODE)
8578 : {
8579 : /* In Informix mode, "string" is automatically a typedef */
8580 2 : $$.type_enum = ECPGt_string;
8581 2 : $$.type_str = "char";
8582 2 : $$.type_dimension = "-1";
8583 2 : $$.type_index = "-1";
8584 2 : $$.type_sizeof = NULL;
8585 : }
8586 : else
8587 : {
8588 : /* Otherwise, legal only if user typedef'ed it */
8589 0 : struct typedefs *this = get_typedef("string", false);
8590 :
8591 0 : $$.type_str = (this->type->type_enum == ECPGt_varchar || this->type->type_enum == ECPGt_bytea) ? mm_strdup("") : mm_strdup(this->name);
8592 0 : $$.type_enum = this->type->type_enum;
8593 0 : $$.type_dimension = this->type->type_dimension;
8594 0 : $$.type_index = this->type->type_index;
8595 0 : if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
8596 0 : $$.type_sizeof = this->type->type_sizeof;
8597 : else
8598 0 : $$.type_sizeof = cat_str(3, "sizeof(", this->name, ")");
8599 :
8600 0 : ECPGfree_struct_member(struct_member_list[struct_level]);
8601 0 : struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
8602 : }
8603 : }
8604 : | INTERVAL ecpg_interval
8605 : {
8606 0 : $$.type_enum = ECPGt_interval;
8607 0 : $$.type_str = "interval";
8608 0 : $$.type_dimension = "-1";
8609 0 : $$.type_index = "-1";
8610 0 : $$.type_sizeof = NULL;
8611 : }
8612 : | IDENT ecpg_interval
8613 : {
8614 : /*
8615 : * In C parsing mode, the above SQL type names are not keywords, so
8616 : * they will show up here as a plain identifier, and we need this
8617 : * duplicate code to recognize them.
8618 : *
8619 : * Note that we also handle the type names bytea, date, and datetime
8620 : * here, but not above because those are not currently SQL keywords.
8621 : * If they ever become so, they must gain duplicate productions above.
8622 : */
8623 98 : if (strlen(@2) != 0 && strcmp(@1, "datetime") != 0 && strcmp(@1, "interval") != 0)
8624 0 : mmerror(PARSE_ERROR, ET_ERROR, "interval specification not allowed here");
8625 :
8626 98 : if (strcmp(@1, "varchar") == 0)
8627 : {
8628 0 : $$.type_enum = ECPGt_varchar;
8629 0 : $$.type_str = ""; /* "varchar"; */
8630 0 : $$.type_dimension = "-1";
8631 0 : $$.type_index = "-1";
8632 0 : $$.type_sizeof = NULL;
8633 : }
8634 98 : else if (strcmp(@1, "bytea") == 0)
8635 : {
8636 8 : $$.type_enum = ECPGt_bytea;
8637 8 : $$.type_str = "";
8638 8 : $$.type_dimension = "-1";
8639 8 : $$.type_index = "-1";
8640 8 : $$.type_sizeof = NULL;
8641 : }
8642 90 : else if (strcmp(@1, "float") == 0)
8643 : {
8644 0 : $$.type_enum = ECPGt_float;
8645 0 : $$.type_str = "float";
8646 0 : $$.type_dimension = "-1";
8647 0 : $$.type_index = "-1";
8648 0 : $$.type_sizeof = NULL;
8649 : }
8650 90 : else if (strcmp(@1, "double") == 0)
8651 : {
8652 12 : $$.type_enum = ECPGt_double;
8653 12 : $$.type_str = "double";
8654 12 : $$.type_dimension = "-1";
8655 12 : $$.type_index = "-1";
8656 12 : $$.type_sizeof = NULL;
8657 : }
8658 78 : else if (strcmp(@1, "numeric") == 0)
8659 : {
8660 4 : $$.type_enum = ECPGt_numeric;
8661 4 : $$.type_str = "numeric";
8662 4 : $$.type_dimension = "-1";
8663 4 : $$.type_index = "-1";
8664 4 : $$.type_sizeof = NULL;
8665 : }
8666 74 : else if (strcmp(@1, "decimal") == 0)
8667 : {
8668 0 : $$.type_enum = ECPGt_decimal;
8669 0 : $$.type_str = "decimal";
8670 0 : $$.type_dimension = "-1";
8671 0 : $$.type_index = "-1";
8672 0 : $$.type_sizeof = NULL;
8673 : }
8674 74 : else if (strcmp(@1, "date") == 0)
8675 : {
8676 10 : $$.type_enum = ECPGt_date;
8677 10 : $$.type_str = "date";
8678 10 : $$.type_dimension = "-1";
8679 10 : $$.type_index = "-1";
8680 10 : $$.type_sizeof = NULL;
8681 : }
8682 64 : else if (strcmp(@1, "timestamp") == 0)
8683 : {
8684 12 : $$.type_enum = ECPGt_timestamp;
8685 12 : $$.type_str = "timestamp";
8686 12 : $$.type_dimension = "-1";
8687 12 : $$.type_index = "-1";
8688 12 : $$.type_sizeof = NULL;
8689 : }
8690 52 : else if (strcmp(@1, "interval") == 0)
8691 : {
8692 8 : $$.type_enum = ECPGt_interval;
8693 8 : $$.type_str = "interval";
8694 8 : $$.type_dimension = "-1";
8695 8 : $$.type_index = "-1";
8696 8 : $$.type_sizeof = NULL;
8697 : }
8698 44 : else if (strcmp(@1, "datetime") == 0)
8699 : {
8700 0 : $$.type_enum = ECPGt_timestamp;
8701 0 : $$.type_str = "timestamp";
8702 0 : $$.type_dimension = "-1";
8703 0 : $$.type_index = "-1";
8704 0 : $$.type_sizeof = NULL;
8705 : }
8706 44 : else if ((strcmp(@1, "string") == 0) && INFORMIX_MODE)
8707 : {
8708 0 : $$.type_enum = ECPGt_string;
8709 0 : $$.type_str = "char";
8710 0 : $$.type_dimension = "-1";
8711 0 : $$.type_index = "-1";
8712 0 : $$.type_sizeof = NULL;
8713 : }
8714 : else
8715 : {
8716 : /* Otherwise, it must be a user-defined typedef name */
8717 44 : struct typedefs *this = get_typedef(@1, false);
8718 :
8719 44 : $$.type_str = (this->type->type_enum == ECPGt_varchar || this->type->type_enum == ECPGt_bytea) ? "" : this->name;
8720 44 : $$.type_enum = this->type->type_enum;
8721 44 : $$.type_dimension = this->type->type_dimension;
8722 44 : $$.type_index = this->type->type_index;
8723 44 : if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
8724 8 : $$.type_sizeof = this->type->type_sizeof;
8725 : else
8726 36 : $$.type_sizeof = cat_str(3, "sizeof(", this->name, ")");
8727 :
8728 44 : ECPGfree_struct_member(struct_member_list[struct_level]);
8729 44 : struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
8730 : }
8731 : }
8732 : | s_struct_union_symbol
8733 : {
8734 : /* this is for named structs/unions */
8735 : char *name;
8736 : struct typedefs *this;
8737 12 : bool forward = (forward_name != NULL && strcmp($1.symbol, forward_name) == 0 && strcmp($1.su, "struct") == 0);
8738 :
8739 12 : name = cat2_str($1.su, $1.symbol);
8740 : /* Do we have a forward definition? */
8741 12 : if (!forward)
8742 : {
8743 : /* No */
8744 :
8745 12 : this = get_typedef(name, false);
8746 12 : $$.type_str = this->name;
8747 12 : $$.type_enum = this->type->type_enum;
8748 12 : $$.type_dimension = this->type->type_dimension;
8749 12 : $$.type_index = this->type->type_index;
8750 12 : $$.type_sizeof = this->type->type_sizeof;
8751 12 : ECPGfree_struct_member(struct_member_list[struct_level]);
8752 12 : struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
8753 : }
8754 : else
8755 : {
8756 0 : $$.type_str = name;
8757 0 : $$.type_enum = ECPGt_long;
8758 0 : $$.type_dimension = "-1";
8759 0 : $$.type_index = "-1";
8760 0 : $$.type_sizeof = "";
8761 0 : ECPGfree_struct_member(struct_member_list[struct_level]);
8762 0 : struct_member_list[struct_level] = NULL;
8763 : }
8764 : }
8765 : ;
8766 :
8767 : enum_type: ENUM_P symbol enum_definition
8768 : | ENUM_P enum_definition
8769 : | ENUM_P symbol
8770 : ;
8771 :
8772 : enum_definition: '{' c_list '}'
8773 : ;
8774 :
8775 : struct_union_type_with_symbol: s_struct_union_symbol
8776 : {
8777 32 : ECPGfree_struct_member(struct_member_list[struct_level]);
8778 32 : struct_member_list[struct_level++] = NULL;
8779 32 : if (struct_level >= STRUCT_DEPTH)
8780 0 : mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
8781 32 : forward_name = mm_strdup($1.symbol);
8782 : }
8783 : '{' variable_declarations '}'
8784 : {
8785 : struct typedefs *ptr,
8786 : *this;
8787 : struct this_type su_type;
8788 :
8789 32 : ECPGfree_struct_member(struct_member_list[struct_level]);
8790 32 : struct_member_list[struct_level] = NULL;
8791 32 : struct_level--;
8792 32 : if (strcmp($1.su, "struct") == 0)
8793 32 : su_type.type_enum = ECPGt_struct;
8794 : else
8795 0 : su_type.type_enum = ECPGt_union;
8796 32 : su_type.type_str = cat2_str($1.su, $1.symbol);
8797 32 : free(forward_name);
8798 32 : forward_name = NULL;
8799 :
8800 : /*
8801 : * This is essentially a typedef but needs the keyword struct/union as
8802 : * well. So we create the typedef for each struct definition with
8803 : * symbol
8804 : */
8805 152 : for (ptr = types; ptr != NULL; ptr = ptr->next)
8806 : {
8807 120 : if (strcmp(su_type.type_str, ptr->name) == 0)
8808 : /* re-definition is a bug */
8809 0 : mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", su_type.type_str);
8810 : }
8811 :
8812 32 : this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
8813 :
8814 : /* initial definition */
8815 32 : this->next = types;
8816 32 : this->name = mm_strdup(su_type.type_str);
8817 32 : this->brace_level = braces_open;
8818 32 : this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
8819 32 : this->type->type_storage = NULL;
8820 32 : this->type->type_enum = su_type.type_enum;
8821 32 : this->type->type_str = mm_strdup(su_type.type_str);
8822 32 : this->type->type_dimension = mm_strdup("-1"); /* dimension of array */
8823 32 : this->type->type_index = mm_strdup("-1"); /* length of string */
8824 32 : this->type->type_sizeof = ECPGstruct_sizeof ? mm_strdup(ECPGstruct_sizeof) : NULL;
8825 32 : this->struct_member_list = ECPGstruct_member_dup(struct_member_list[struct_level]);
8826 :
8827 32 : types = this;
8828 32 : @$ = cat_str(4, su_type.type_str, "{", @4, "}");
8829 : }
8830 : ;
8831 :
8832 : struct_union_type: struct_union_type_with_symbol
8833 : | s_struct_union
8834 : {
8835 14 : ECPGfree_struct_member(struct_member_list[struct_level]);
8836 14 : struct_member_list[struct_level++] = NULL;
8837 14 : if (struct_level >= STRUCT_DEPTH)
8838 0 : mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
8839 : }
8840 : '{' variable_declarations '}'
8841 : {
8842 14 : ECPGfree_struct_member(struct_member_list[struct_level]);
8843 14 : struct_member_list[struct_level] = NULL;
8844 14 : struct_level--;
8845 14 : @$ = cat_str(4, @1, "{", @4, "}");
8846 : }
8847 : ;
8848 :
8849 : s_struct_union_symbol: SQL_STRUCT symbol
8850 : {
8851 44 : $$.su = "struct";
8852 44 : $$.symbol = @2;
8853 44 : free(ECPGstruct_sizeof);
8854 44 : ECPGstruct_sizeof = mm_strdup(cat_str(3, "sizeof(",
8855 : cat2_str($$.su, $$.symbol),
8856 : ")"));
8857 : }
8858 : | UNION symbol
8859 : {
8860 0 : $$.su = "union";
8861 0 : $$.symbol = @2;
8862 : }
8863 : ;
8864 :
8865 : s_struct_union: SQL_STRUCT
8866 : {
8867 10 : free(ECPGstruct_sizeof);
8868 10 : ECPGstruct_sizeof = mm_strdup(""); /* This must not be NULL to
8869 : * distinguish from simple types. */
8870 10 : @$ = "struct";
8871 : }
8872 : | UNION
8873 : {
8874 4 : @$ = "union";
8875 : }
8876 : ;
8877 :
8878 : simple_type: unsigned_type
8879 454 : | opt_signed signed_type { $$ = $2; }
8880 : ;
8881 :
8882 0 : unsigned_type: SQL_UNSIGNED SQL_SHORT { $$ = ECPGt_unsigned_short; }
8883 0 : | SQL_UNSIGNED SQL_SHORT INT_P { $$ = ECPGt_unsigned_short; }
8884 0 : | SQL_UNSIGNED { $$ = ECPGt_unsigned_int; }
8885 0 : | SQL_UNSIGNED INT_P { $$ = ECPGt_unsigned_int; }
8886 0 : | SQL_UNSIGNED SQL_LONG { $$ = ECPGt_unsigned_long; }
8887 0 : | SQL_UNSIGNED SQL_LONG INT_P { $$ = ECPGt_unsigned_long; }
8888 0 : | SQL_UNSIGNED SQL_LONG SQL_LONG { $$ = ECPGt_unsigned_long_long; }
8889 0 : | SQL_UNSIGNED SQL_LONG SQL_LONG INT_P { $$ = ECPGt_unsigned_long_long; }
8890 0 : | SQL_UNSIGNED CHAR_P { $$ = ECPGt_unsigned_char; }
8891 : ;
8892 :
8893 26 : signed_type: SQL_SHORT { $$ = ECPGt_short; }
8894 0 : | SQL_SHORT INT_P { $$ = ECPGt_short; }
8895 208 : | INT_P { $$ = ECPGt_int; }
8896 12 : | SQL_LONG { $$ = ECPGt_long; }
8897 0 : | SQL_LONG INT_P { $$ = ECPGt_long; }
8898 0 : | SQL_LONG SQL_LONG { $$ = ECPGt_long_long; }
8899 0 : | SQL_LONG SQL_LONG INT_P { $$ = ECPGt_long_long; }
8900 8 : | SQL_BOOL { $$ = ECPGt_bool; }
8901 198 : | CHAR_P { $$ = ECPGt_char; }
8902 2 : | DOUBLE_P { $$ = ECPGt_double; }
8903 : ;
8904 :
8905 : opt_signed: SQL_SIGNED
8906 : | /* EMPTY */
8907 : ;
8908 :
8909 : variable_list: variable
8910 : | variable_list ',' variable
8911 : {
8912 108 : if (actual_type[struct_level].type_enum == ECPGt_varchar || actual_type[struct_level].type_enum == ECPGt_bytea)
8913 4 : @$ = cat_str(4, @1, ";", actual_type[struct_level].type_storage, @3);
8914 : else
8915 104 : @$ = cat_str(3, @1, ",", @3);
8916 : }
8917 : ;
8918 :
8919 : variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initializer
8920 : {
8921 : struct ECPGtype *type;
8922 700 : const char *dimension = $3.index1; /* dimension of array */
8923 700 : const char *length = $3.index2; /* length of string */
8924 : char *dim_str;
8925 : char vcn[32];
8926 : int *varlen_type_counter;
8927 : char *struct_name;
8928 :
8929 700 : adjust_array(actual_type[struct_level].type_enum,
8930 : &dimension, &length,
8931 700 : actual_type[struct_level].type_dimension,
8932 700 : actual_type[struct_level].type_index,
8933 700 : strlen(@1), false);
8934 700 : switch (actual_type[struct_level].type_enum)
8935 : {
8936 48 : case ECPGt_struct:
8937 : case ECPGt_union:
8938 48 : if (atoi(dimension) < 0)
8939 22 : type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_str, actual_type[struct_level].type_sizeof);
8940 : else
8941 26 : type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_str, actual_type[struct_level].type_sizeof), dimension);
8942 :
8943 48 : @$ = cat_str(5, @1, @2, $3.str, @4, @5);
8944 48 : break;
8945 :
8946 40 : case ECPGt_varchar:
8947 : case ECPGt_bytea:
8948 40 : if (actual_type[struct_level].type_enum == ECPGt_varchar)
8949 : {
8950 32 : varlen_type_counter = &varchar_counter;
8951 32 : struct_name = " struct varchar_";
8952 : }
8953 : else
8954 : {
8955 8 : varlen_type_counter = &bytea_counter;
8956 8 : struct_name = " struct bytea_";
8957 : }
8958 40 : if (atoi(dimension) < 0)
8959 30 : type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length, *varlen_type_counter);
8960 : else
8961 10 : type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, *varlen_type_counter), dimension);
8962 :
8963 40 : if (strcmp(dimension, "0") == 0 || abs(atoi(dimension)) == 1)
8964 32 : dim_str = "";
8965 : else
8966 8 : dim_str = cat_str(3, "[", dimension, "]");
8967 :
8968 : /*
8969 : * cannot check for atoi <= 0 because a defined constant will
8970 : * yield 0 here as well
8971 : */
8972 40 : if (atoi(length) < 0 || strcmp(length, "0") == 0)
8973 0 : mmerror(PARSE_ERROR, ET_ERROR, "pointers to varchar are not implemented");
8974 :
8975 : /*
8976 : * make sure varchar struct name is unique by adding a unique
8977 : * counter to its definition
8978 : */
8979 40 : snprintf(vcn, sizeof(vcn), "%d", *varlen_type_counter);
8980 40 : if (strcmp(dimension, "0") == 0)
8981 2 : @$ = cat_str(7, make2_str(struct_name, vcn), " { int len; char arr[", length, "]; } *", @2, @4, @5);
8982 : else
8983 38 : @$ = cat_str(8, make2_str(struct_name, vcn), " { int len; char arr[", length, "]; } ", @2, dim_str, @4, @5);
8984 40 : (*varlen_type_counter)++;
8985 40 : break;
8986 :
8987 226 : case ECPGt_char:
8988 : case ECPGt_unsigned_char:
8989 : case ECPGt_string:
8990 226 : if (atoi(dimension) == -1)
8991 : {
8992 196 : int i = strlen(@5);
8993 :
8994 196 : if (atoi(length) == -1 && i > 0) /* char <var>[] =
8995 : * "string" */
8996 : {
8997 : /*
8998 : * if we have an initializer but no string size set,
8999 : * let's use the initializer's length
9000 : */
9001 4 : char *buf = loc_alloc(32);
9002 :
9003 4 : snprintf(buf, 32, "sizeof(%s)", @5 + 2);
9004 4 : length = buf;
9005 : }
9006 196 : type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0);
9007 : }
9008 : else
9009 30 : type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0), dimension);
9010 :
9011 226 : @$ = cat_str(5, @1, @2, $3.str, @4, @5);
9012 226 : break;
9013 :
9014 386 : default:
9015 386 : if (atoi(dimension) < 0)
9016 308 : type = ECPGmake_simple_type(actual_type[struct_level].type_enum, "1", 0);
9017 : else
9018 78 : type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, "1", 0), dimension);
9019 :
9020 386 : @$ = cat_str(5, @1, @2, $3.str, @4, @5);
9021 386 : break;
9022 : }
9023 :
9024 700 : if (struct_level == 0)
9025 592 : new_variable(@2, type, braces_open);
9026 : else
9027 108 : ECPGmake_struct_member(@2, type, &(struct_member_list[struct_level - 1]));
9028 : }
9029 : ;
9030 :
9031 : opt_initializer: /* EMPTY */
9032 : | '=' c_term
9033 : {
9034 220 : initializer = 1;
9035 : }
9036 : ;
9037 :
9038 : opt_pointer: /* EMPTY */
9039 : | '*'
9040 : | '*' '*'
9041 : {
9042 16 : @$ = "**";
9043 : }
9044 : ;
9045 :
9046 : /*
9047 : * We try to simulate the correct DECLARE syntax here so we get dynamic SQL
9048 : */
9049 : ECPGDeclare: DECLARE STATEMENT ecpg_ident
9050 : {
9051 : /* this is only supported for compatibility */
9052 0 : @$ = cat_str(3, "/* declare statement", @3, "*/");
9053 : }
9054 : ;
9055 : /*
9056 : * the exec sql disconnect statement: disconnect from the given database
9057 : */
9058 : ECPGDisconnect: SQL_DISCONNECT dis_name
9059 : {
9060 172 : @$ = @2;
9061 : }
9062 : ;
9063 :
9064 : dis_name: connection_object
9065 : | CURRENT_P
9066 : {
9067 6 : @$ = "\"CURRENT\"";
9068 : }
9069 : | ALL
9070 : {
9071 30 : @$ = "\"ALL\"";
9072 : }
9073 : | /* EMPTY */
9074 : {
9075 86 : @$ = "\"CURRENT\"";
9076 : }
9077 : ;
9078 :
9079 : connection_object: name
9080 : {
9081 288 : @$ = make3_str("\"", @1, "\"");
9082 : }
9083 : | DEFAULT
9084 : {
9085 6 : @$ = "\"DEFAULT\"";
9086 : }
9087 : | char_variable
9088 : ;
9089 :
9090 : execstring: char_variable
9091 : | CSTRING
9092 : {
9093 12 : @$ = make3_str("\"", @1, "\"");
9094 : }
9095 : ;
9096 :
9097 : /*
9098 : * the exec sql free command to deallocate a previously
9099 : * prepared statement
9100 : */
9101 : ECPGFree: SQL_FREE cursor_name
9102 : {
9103 2 : @$ = @2;
9104 : }
9105 : | SQL_FREE ALL
9106 : {
9107 0 : @$ = "all";
9108 : }
9109 : ;
9110 :
9111 : /*
9112 : * open is an open cursor, at the moment this has to be removed
9113 : */
9114 : ECPGOpen: SQL_OPEN cursor_name opt_ecpg_using
9115 : {
9116 76 : if (@2[0] == ':')
9117 10 : remove_variable_from_list(&argsinsert, find_variable(@2 + 1));
9118 76 : @$ = @2;
9119 : }
9120 : ;
9121 :
9122 : opt_ecpg_using: /* EMPTY */
9123 : | ecpg_using
9124 : ;
9125 :
9126 : ecpg_using: USING using_list
9127 : {
9128 28 : @$ = "";
9129 : }
9130 : | using_descriptor
9131 : ;
9132 :
9133 : using_descriptor: USING SQL_P SQL_DESCRIPTOR quoted_ident_stringvar
9134 : {
9135 22 : add_variable_to_head(&argsinsert, descriptor_variable(@4, 0), &no_indicator);
9136 22 : @$ = "";
9137 : }
9138 : | USING SQL_DESCRIPTOR name
9139 : {
9140 18 : add_variable_to_head(&argsinsert, sqlda_variable(@3), &no_indicator);
9141 18 : @$ = "";
9142 : }
9143 : ;
9144 :
9145 : into_descriptor: INTO SQL_P SQL_DESCRIPTOR quoted_ident_stringvar
9146 : {
9147 22 : add_variable_to_head(&argsresult, descriptor_variable(@4, 1), &no_indicator);
9148 22 : @$ = "";
9149 : }
9150 : | INTO SQL_DESCRIPTOR name
9151 : {
9152 24 : add_variable_to_head(&argsresult, sqlda_variable(@3), &no_indicator);
9153 24 : @$ = "";
9154 : }
9155 : ;
9156 :
9157 : into_sqlda: INTO name
9158 : {
9159 8 : add_variable_to_head(&argsresult, sqlda_variable(@2), &no_indicator);
9160 8 : @$ = "";
9161 : }
9162 : ;
9163 :
9164 : using_list: UsingValue | UsingValue ',' using_list
9165 : ;
9166 :
9167 : UsingValue: UsingConst
9168 : {
9169 : char length[32];
9170 :
9171 8 : snprintf(length, sizeof(length), "%zu", strlen(@1));
9172 8 : add_variable_to_head(&argsinsert, new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
9173 : }
9174 : | civar
9175 : {
9176 34 : @$ = "";
9177 : }
9178 : | civarind
9179 : {
9180 0 : @$ = "";
9181 : }
9182 : ;
9183 :
9184 : UsingConst: Iconst
9185 : | '+' Iconst
9186 : | '-' Iconst
9187 : | ecpg_fconst
9188 : | '+' ecpg_fconst
9189 : | '-' ecpg_fconst
9190 : | ecpg_sconst
9191 : | ecpg_bconst
9192 : | ecpg_xconst
9193 : ;
9194 :
9195 : /*
9196 : * We accept DESCRIBE [OUTPUT] but do nothing with DESCRIBE INPUT so far.
9197 : */
9198 : ECPGDescribe: SQL_DESCRIBE INPUT_P prepared_name using_descriptor
9199 : {
9200 0 : $$.input = 1;
9201 0 : $$.stmt_name = @3;
9202 : }
9203 : | SQL_DESCRIBE opt_output prepared_name using_descriptor
9204 : {
9205 : struct variable *var;
9206 :
9207 16 : var = argsinsert->variable;
9208 16 : remove_variable_from_list(&argsinsert, var);
9209 16 : add_variable_to_head(&argsresult, var, &no_indicator);
9210 :
9211 16 : $$.input = 0;
9212 16 : $$.stmt_name = @3;
9213 : }
9214 : | SQL_DESCRIBE opt_output prepared_name into_descriptor
9215 : {
9216 18 : $$.input = 0;
9217 18 : $$.stmt_name = @3;
9218 : }
9219 : | SQL_DESCRIBE INPUT_P prepared_name into_sqlda
9220 : {
9221 0 : $$.input = 1;
9222 0 : $$.stmt_name = @3;
9223 : }
9224 : | SQL_DESCRIBE opt_output prepared_name into_sqlda
9225 : {
9226 8 : $$.input = 0;
9227 8 : $$.stmt_name = @3;
9228 : }
9229 : ;
9230 :
9231 : opt_output: SQL_OUTPUT
9232 : | /* EMPTY */
9233 : ;
9234 :
9235 : /*
9236 : * dynamic SQL: descriptor based access
9237 : * originally written by Christof Petig <christof.petig@wtal.de>
9238 : * and Peter Eisentraut <peter.eisentraut@credativ.de>
9239 : */
9240 :
9241 : /*
9242 : * allocate a descriptor
9243 : */
9244 : ECPGAllocateDescr: SQL_ALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
9245 : {
9246 36 : add_descriptor(@3, connection);
9247 36 : @$ = @3;
9248 : }
9249 : ;
9250 :
9251 :
9252 : /*
9253 : * deallocate a descriptor
9254 : */
9255 : ECPGDeallocateDescr: DEALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
9256 : {
9257 32 : drop_descriptor(@3, connection);
9258 32 : @$ = @3;
9259 : }
9260 : ;
9261 :
9262 : /*
9263 : * manipulate a descriptor header
9264 : */
9265 :
9266 : ECPGGetDescriptorHeader: SQL_GET SQL_DESCRIPTOR quoted_ident_stringvar ECPGGetDescHeaderItems
9267 : {
9268 22 : @$ = @3;
9269 : }
9270 : ;
9271 :
9272 : ECPGGetDescHeaderItems: ECPGGetDescHeaderItem
9273 : | ECPGGetDescHeaderItems ',' ECPGGetDescHeaderItem
9274 : ;
9275 :
9276 : ECPGGetDescHeaderItem: cvariable '=' desc_header_item
9277 : {
9278 22 : push_assignment(@1, $3);
9279 : }
9280 : ;
9281 :
9282 : ECPGSetDescriptorHeader: SET SQL_DESCRIPTOR quoted_ident_stringvar ECPGSetDescHeaderItems
9283 : {
9284 2 : @$ = @3;
9285 : }
9286 : ;
9287 :
9288 : ECPGSetDescHeaderItems: ECPGSetDescHeaderItem
9289 : | ECPGSetDescHeaderItems ',' ECPGSetDescHeaderItem
9290 : ;
9291 :
9292 : ECPGSetDescHeaderItem: desc_header_item '=' IntConstVar
9293 : {
9294 2 : push_assignment(@3, $1);
9295 : }
9296 : ;
9297 :
9298 : IntConstVar: Iconst
9299 : {
9300 : char length[32];
9301 :
9302 60 : snprintf(length, sizeof(length), "%zu", strlen(@1));
9303 60 : new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
9304 : }
9305 : | cvariable
9306 : ;
9307 :
9308 : desc_header_item: SQL_COUNT
9309 : {
9310 24 : $$ = ECPGd_count;
9311 : }
9312 : ;
9313 :
9314 : /*
9315 : * manipulate a descriptor
9316 : */
9317 :
9318 : ECPGGetDescriptor: SQL_GET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGGetDescItems
9319 : {
9320 62 : $$.str = @5;
9321 62 : $$.name = @3;
9322 : }
9323 : ;
9324 :
9325 : ECPGGetDescItems: ECPGGetDescItem
9326 : | ECPGGetDescItems ',' ECPGGetDescItem
9327 : ;
9328 :
9329 : ECPGGetDescItem: cvariable '=' descriptor_item
9330 : {
9331 102 : push_assignment(@1, $3);
9332 : }
9333 : ;
9334 :
9335 : ECPGSetDescriptor: SET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGSetDescItems
9336 : {
9337 22 : $$.str = @5;
9338 22 : $$.name = @3;
9339 : }
9340 : ;
9341 :
9342 : ECPGSetDescItems: ECPGSetDescItem
9343 : | ECPGSetDescItems ',' ECPGSetDescItem
9344 : ;
9345 :
9346 : ECPGSetDescItem: descriptor_item '=' AllConstVar
9347 : {
9348 30 : push_assignment(@3, $1);
9349 : }
9350 : ;
9351 :
9352 : AllConstVar: ecpg_fconst
9353 : {
9354 : char length[32];
9355 :
9356 0 : snprintf(length, sizeof(length), "%zu", strlen(@1));
9357 0 : new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
9358 : }
9359 : | IntConstVar
9360 : | '-' ecpg_fconst
9361 : {
9362 : char length[32];
9363 0 : char *var = cat2_str("-", @2);
9364 :
9365 0 : snprintf(length, sizeof(length), "%zu", strlen(var));
9366 0 : new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
9367 0 : @$ = var;
9368 : }
9369 : | '-' Iconst
9370 : {
9371 : char length[32];
9372 0 : char *var = cat2_str("-", @2);
9373 :
9374 0 : snprintf(length, sizeof(length), "%zu", strlen(var));
9375 0 : new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
9376 0 : @$ = var;
9377 : }
9378 : | ecpg_sconst
9379 : {
9380 : char length[32];
9381 : char *var;
9382 :
9383 : /* Strip single quotes from ecpg_sconst */
9384 2 : var = loc_strdup(@1 + 1);
9385 2 : var[strlen(var) - 1] = '\0';
9386 2 : snprintf(length, sizeof(length), "%zu", strlen(var));
9387 2 : new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
9388 2 : @$ = var;
9389 : }
9390 : ;
9391 :
9392 0 : descriptor_item: SQL_CARDINALITY { $$ = ECPGd_cardinality; }
9393 62 : | DATA_P { $$ = ECPGd_data; }
9394 4 : | SQL_DATETIME_INTERVAL_CODE { $$ = ECPGd_di_code; }
9395 0 : | SQL_DATETIME_INTERVAL_PRECISION { $$ = ECPGd_di_precision; }
9396 34 : | SQL_INDICATOR { $$ = ECPGd_indicator; }
9397 0 : | SQL_KEY_MEMBER { $$ = ECPGd_key_member; }
9398 4 : | SQL_LENGTH { $$ = ECPGd_length; }
9399 18 : | NAME_P { $$ = ECPGd_name; }
9400 0 : | SQL_NULLABLE { $$ = ECPGd_nullable; }
9401 2 : | SQL_OCTET_LENGTH { $$ = ECPGd_octet; }
9402 2 : | PRECISION { $$ = ECPGd_precision; }
9403 0 : | SQL_RETURNED_LENGTH { $$ = ECPGd_length; }
9404 2 : | SQL_RETURNED_OCTET_LENGTH { $$ = ECPGd_ret_octet; }
9405 2 : | SQL_SCALE { $$ = ECPGd_scale; }
9406 2 : | TYPE_P { $$ = ECPGd_type; }
9407 : ;
9408 :
9409 : /*
9410 : * set/reset the automatic transaction mode, this needs a different handling
9411 : * as the other set commands
9412 : */
9413 : ECPGSetAutocommit: SET SQL_AUTOCOMMIT '=' on_off
9414 : {
9415 8 : @$ = @4;
9416 : }
9417 : | SET SQL_AUTOCOMMIT TO on_off
9418 : {
9419 18 : @$ = @4;
9420 : }
9421 : ;
9422 :
9423 : on_off: ON
9424 : | OFF
9425 : ;
9426 :
9427 : /*
9428 : * set the actual connection, this needs a different handling as the other
9429 : * set commands
9430 : */
9431 : ECPGSetConnection: SET CONNECTION TO connection_object
9432 : {
9433 2 : @$ = @4;
9434 : }
9435 : | SET CONNECTION '=' connection_object
9436 : {
9437 0 : @$ = @4;
9438 : }
9439 : | SET CONNECTION connection_object
9440 : {
9441 2 : @$ = @3;
9442 : }
9443 : ;
9444 :
9445 : /*
9446 : * define a new type for embedded SQL
9447 : */
9448 : ECPGTypedef: TYPE_P
9449 : {
9450 : /* reset this variable so we see if there was */
9451 : /* an initializer specified */
9452 26 : initializer = 0;
9453 : }
9454 : ECPGColLabel IS var_type opt_array_bounds opt_reference
9455 : {
9456 26 : add_typedef(@3, $6.index1, $6.index2, $5.type_enum, $5.type_dimension, $5.type_index, initializer, *@7 ? 1 : 0);
9457 :
9458 26 : if (auto_create_c == false)
9459 18 : @$ = cat_str(7, "/* exec sql type", @3, "is", $5.type_str, $6.str, @7, "*/");
9460 : else
9461 8 : @$ = cat_str(6, "typedef ", $5.type_str, *@7 ? "*" : "", @3, $6.str, ";");
9462 : }
9463 : ;
9464 :
9465 : opt_reference: SQL_REFERENCE
9466 : | /* EMPTY */
9467 : ;
9468 :
9469 : /*
9470 : * define the type of one variable for embedded SQL
9471 : */
9472 : ECPGVar: SQL_VAR
9473 : {
9474 : /* reset this variable so we see if there was */
9475 : /* an initializer specified */
9476 4 : initializer = 0;
9477 : }
9478 : ColLabel IS var_type opt_array_bounds opt_reference
9479 : {
9480 4 : struct variable *p = find_variable(@3);
9481 4 : const char *dimension = $6.index1;
9482 4 : const char *length = $6.index2;
9483 : struct ECPGtype *type;
9484 :
9485 4 : if (($5.type_enum == ECPGt_struct ||
9486 4 : $5.type_enum == ECPGt_union) &&
9487 0 : initializer == 1)
9488 0 : mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in EXEC SQL VAR command");
9489 : else
9490 : {
9491 4 : adjust_array($5.type_enum, &dimension, &length,
9492 4 : $5.type_dimension, $5.type_index, *@7 ? 1 : 0, false);
9493 :
9494 4 : switch ($5.type_enum)
9495 : {
9496 0 : case ECPGt_struct:
9497 : case ECPGt_union:
9498 0 : if (atoi(dimension) < 0)
9499 0 : type = ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, $5.type_str, $5.type_sizeof);
9500 : else
9501 0 : type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, $5.type_str, $5.type_sizeof), dimension);
9502 0 : break;
9503 :
9504 2 : case ECPGt_varchar:
9505 : case ECPGt_bytea:
9506 2 : if (atoi(dimension) == -1)
9507 2 : type = ECPGmake_simple_type($5.type_enum, length, 0);
9508 : else
9509 0 : type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length, 0), dimension);
9510 2 : break;
9511 :
9512 0 : case ECPGt_char:
9513 : case ECPGt_unsigned_char:
9514 : case ECPGt_string:
9515 0 : if (atoi(dimension) == -1)
9516 0 : type = ECPGmake_simple_type($5.type_enum, length, 0);
9517 : else
9518 0 : type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length, 0), dimension);
9519 0 : break;
9520 :
9521 2 : default:
9522 2 : if (atoi(length) >= 0)
9523 0 : mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
9524 :
9525 2 : if (atoi(dimension) < 0)
9526 2 : type = ECPGmake_simple_type($5.type_enum, "1", 0);
9527 : else
9528 0 : type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, "1", 0), dimension);
9529 2 : break;
9530 : }
9531 :
9532 4 : ECPGfree_type(p->type);
9533 4 : p->type = type;
9534 : }
9535 :
9536 4 : @$ = cat_str(7, "/* exec sql var", @3, "is", $5.type_str, $6.str, @7, "*/");
9537 : }
9538 : ;
9539 :
9540 : /*
9541 : * whenever statement: decide what to do in case of error/no data found
9542 : * according to SQL standards we lack: SQLSTATE, CONSTRAINT and SQLEXCEPTION
9543 : */
9544 : ECPGWhenever: SQL_WHENEVER SQL_SQLERROR action
9545 : {
9546 124 : when_error.code = $3.code;
9547 124 : free(when_error.command);
9548 124 : when_error.command = $3.command ? mm_strdup($3.command) : NULL;
9549 124 : @$ = cat_str(3, "/* exec sql whenever sqlerror ", $3.str, "; */");
9550 : }
9551 : | SQL_WHENEVER NOT SQL_FOUND action
9552 : {
9553 50 : when_nf.code = $4.code;
9554 50 : free(when_nf.command);
9555 50 : when_nf.command = $4.command ? mm_strdup($4.command) : NULL;
9556 50 : @$ = cat_str(3, "/* exec sql whenever not found ", $4.str, "; */");
9557 : }
9558 : | SQL_WHENEVER SQL_SQLWARNING action
9559 : {
9560 26 : when_warn.code = $3.code;
9561 26 : free(when_warn.command);
9562 26 : when_warn.command = $3.command ? mm_strdup($3.command) : NULL;
9563 26 : @$ = cat_str(3, "/* exec sql whenever sql_warning ", $3.str, "; */");
9564 : }
9565 : ;
9566 :
9567 : action: CONTINUE_P
9568 : {
9569 18 : $$.code = W_NOTHING;
9570 18 : $$.command = NULL;
9571 18 : $$.str = "continue";
9572 : }
9573 : | SQL_SQLPRINT
9574 : {
9575 86 : $$.code = W_SQLPRINT;
9576 86 : $$.command = NULL;
9577 86 : $$.str = "sqlprint";
9578 : }
9579 : | SQL_STOP
9580 : {
9581 30 : $$.code = W_STOP;
9582 30 : $$.command = NULL;
9583 30 : $$.str = "stop";
9584 : }
9585 : | SQL_GOTO name
9586 : {
9587 2 : $$.code = W_GOTO;
9588 2 : $$.command = loc_strdup(@2);
9589 2 : $$.str = cat2_str("goto ", @2);
9590 : }
9591 : | SQL_GO TO name
9592 : {
9593 0 : $$.code = W_GOTO;
9594 0 : $$.command = loc_strdup(@3);
9595 0 : $$.str = cat2_str("goto ", @3);
9596 : }
9597 : | DO name '(' c_args ')'
9598 : {
9599 36 : $$.code = W_DO;
9600 36 : $$.command = cat_str(4, @2, "(", @4, ")");
9601 36 : $$.str = cat2_str("do", $$.command);
9602 : }
9603 : | DO SQL_BREAK
9604 : {
9605 24 : $$.code = W_BREAK;
9606 24 : $$.command = NULL;
9607 24 : $$.str = "break";
9608 : }
9609 : | DO CONTINUE_P
9610 : {
9611 2 : $$.code = W_CONTINUE;
9612 2 : $$.command = NULL;
9613 2 : $$.str = "continue";
9614 : }
9615 : | CALL name '(' c_args ')'
9616 : {
9617 2 : $$.code = W_DO;
9618 2 : $$.command = cat_str(4, @2, "(", @4, ")");
9619 2 : $$.str = cat2_str("call", $$.command);
9620 : }
9621 : | CALL name
9622 : {
9623 0 : $$.code = W_DO;
9624 0 : $$.command = cat2_str(@2, "()");
9625 0 : $$.str = cat2_str("call", $$.command);
9626 : }
9627 : ;
9628 :
9629 : /* some other stuff for ecpg */
9630 :
9631 : /* additional unreserved keywords */
9632 : ECPGKeywords: ECPGKeywords_vanames
9633 : | ECPGKeywords_rest
9634 : ;
9635 :
9636 : ECPGKeywords_vanames: SQL_BREAK
9637 : | SQL_CARDINALITY
9638 : | SQL_COUNT
9639 : | SQL_DATETIME_INTERVAL_CODE
9640 : | SQL_DATETIME_INTERVAL_PRECISION
9641 : | SQL_FOUND
9642 : | SQL_GO
9643 : | SQL_GOTO
9644 : | SQL_IDENTIFIED
9645 : | SQL_INDICATOR
9646 : | SQL_KEY_MEMBER
9647 : | SQL_LENGTH
9648 : | SQL_NULLABLE
9649 : | SQL_OCTET_LENGTH
9650 : | SQL_RETURNED_LENGTH
9651 : | SQL_RETURNED_OCTET_LENGTH
9652 : | SQL_SCALE
9653 : | SQL_SECTION
9654 : | SQL_SQLERROR
9655 : | SQL_SQLPRINT
9656 : | SQL_SQLWARNING
9657 : | SQL_STOP
9658 : ;
9659 :
9660 : ECPGKeywords_rest: SQL_CONNECT
9661 : | SQL_DESCRIBE
9662 : | SQL_DISCONNECT
9663 : | SQL_OPEN
9664 : | SQL_VAR
9665 : | SQL_WHENEVER
9666 : ;
9667 :
9668 : /* additional keywords that can be SQL type names (but not ECPGColLabels) */
9669 : ECPGTypeName: SQL_BOOL
9670 : | SQL_LONG
9671 : | SQL_OUTPUT
9672 : | SQL_SHORT
9673 : | SQL_STRUCT
9674 : | SQL_SIGNED
9675 : | SQL_UNSIGNED
9676 : ;
9677 :
9678 : symbol: ColLabel
9679 : ;
9680 :
9681 : ECPGColId: ecpg_ident
9682 : | unreserved_keyword
9683 : | col_name_keyword
9684 : | ECPGunreserved_interval
9685 : | ECPGKeywords
9686 : | ECPGCKeywords
9687 : | CHAR_P
9688 : | VALUES
9689 : ;
9690 :
9691 : /*
9692 : * Name classification hierarchy.
9693 : *
9694 : * These productions should match those in the core grammar, except that
9695 : * we use all_unreserved_keyword instead of unreserved_keyword, and
9696 : * where possible include ECPG keywords as well as core keywords.
9697 : */
9698 :
9699 : /* Column identifier --- names that can be column, table, etc names.
9700 : */
9701 : ColId: ecpg_ident
9702 : | all_unreserved_keyword
9703 : | col_name_keyword
9704 : | ECPGKeywords
9705 : | ECPGCKeywords
9706 : | CHAR_P
9707 : | VALUES
9708 : ;
9709 :
9710 : /* Type/function identifier --- names that can be type or function names.
9711 : */
9712 : type_function_name: ecpg_ident
9713 : | all_unreserved_keyword
9714 : | type_func_name_keyword
9715 : | ECPGKeywords
9716 : | ECPGCKeywords
9717 : | ECPGTypeName
9718 : ;
9719 :
9720 : /* Column label --- allowed labels in "AS" clauses.
9721 : * This presently includes *all* Postgres keywords.
9722 : */
9723 : ColLabel: ECPGColLabel
9724 : | ECPGTypeName
9725 : | CHAR_P
9726 : | CURRENT_P
9727 : | INPUT_P
9728 : | INT_P
9729 : | TO
9730 : | UNION
9731 : | VALUES
9732 : | ECPGCKeywords
9733 : | ECPGunreserved_interval
9734 : ;
9735 :
9736 : ECPGColLabel: ecpg_ident
9737 : | unreserved_keyword
9738 : | col_name_keyword
9739 : | type_func_name_keyword
9740 : | reserved_keyword
9741 : | ECPGKeywords_vanames
9742 : | ECPGKeywords_rest
9743 : | CONNECTION
9744 : ;
9745 :
9746 : ECPGCKeywords: S_AUTO
9747 : | S_CONST
9748 : | S_EXTERN
9749 : | S_REGISTER
9750 : | S_STATIC
9751 : | S_TYPEDEF
9752 : | S_VOLATILE
9753 : ;
9754 :
9755 : /* "Unreserved" keywords --- available for use as any kind of name.
9756 : */
9757 :
9758 : /*
9759 : * The following symbols must be excluded from ECPGColLabel and directly
9760 : * included into ColLabel to enable C variables to get names from ECPGColLabel:
9761 : * DAY_P, HOUR_P, MINUTE_P, MONTH_P, SECOND_P, YEAR_P.
9762 : *
9763 : * We also have to exclude CONNECTION, CURRENT, and INPUT for various reasons.
9764 : * CONNECTION can be added back in all_unreserved_keyword, but CURRENT and
9765 : * INPUT are reserved for ecpg purposes.
9766 : *
9767 : * The mentioned exclusions are done by $replace_line settings in parse.pl.
9768 : */
9769 : all_unreserved_keyword: unreserved_keyword
9770 : | ECPGunreserved_interval
9771 : | CONNECTION
9772 : ;
9773 :
9774 : ECPGunreserved_interval: DAY_P
9775 : | HOUR_P
9776 : | MINUTE_P
9777 : | MONTH_P
9778 : | SECOND_P
9779 : | YEAR_P
9780 : ;
9781 :
9782 : into_list: coutputvariable | into_list ',' coutputvariable
9783 : ;
9784 :
9785 : ecpgstart: SQL_START
9786 : {
9787 2682 : reset_variables();
9788 2682 : pacounter = 1;
9789 2682 : @$ = "";
9790 : }
9791 : ;
9792 :
9793 : c_args: /* EMPTY */
9794 : | c_list
9795 : ;
9796 :
9797 : coutputvariable: cvariable indicator
9798 : {
9799 56 : add_variable_to_head(&argsresult, find_variable(@1), find_variable(@2));
9800 : }
9801 : | cvariable
9802 : {
9803 456 : add_variable_to_head(&argsresult, find_variable(@1), &no_indicator);
9804 : }
9805 : ;
9806 :
9807 :
9808 : civarind: cvariable indicator
9809 : {
9810 6 : if (find_variable(@2)->type->type == ECPGt_array)
9811 0 : mmerror(PARSE_ERROR, ET_ERROR, "arrays of indicators are not allowed on input");
9812 :
9813 6 : add_variable_to_head(&argsinsert, find_variable(@1), find_variable(@2));
9814 6 : @$ = create_questionmarks(@1, false);
9815 : }
9816 : ;
9817 :
9818 : char_civar: char_variable
9819 : {
9820 86 : char *ptr = strstr(@1, ".arr");
9821 :
9822 86 : if (ptr) /* varchar, we need the struct name here, not
9823 : * the struct element */
9824 20 : *ptr = '\0';
9825 86 : add_variable_to_head(&argsinsert, find_variable(@1), &no_indicator);
9826 : }
9827 : ;
9828 :
9829 : civar: cvariable
9830 : {
9831 240 : add_variable_to_head(&argsinsert, find_variable(@1), &no_indicator);
9832 240 : @$ = create_questionmarks(@1, false);
9833 : }
9834 : ;
9835 :
9836 : indicator: cvariable
9837 : {
9838 62 : check_indicator((find_variable(@1))->type);
9839 : }
9840 : | SQL_INDICATOR cvariable
9841 : {
9842 0 : check_indicator((find_variable(@2))->type);
9843 0 : @$ = @2;
9844 : }
9845 : | SQL_INDICATOR name
9846 : {
9847 0 : check_indicator((find_variable(@2))->type);
9848 0 : @$ = @2;
9849 : }
9850 : ;
9851 :
9852 : cvariable: CVARIABLE
9853 : {
9854 : /*
9855 : * As long as multidimensional arrays are not implemented we have to
9856 : * check for those here
9857 : */
9858 1272 : const char *ptr = @1;
9859 1272 : int brace_open = 0,
9860 1272 : brace = false;
9861 :
9862 7958 : for (; *ptr; ptr++)
9863 : {
9864 6686 : switch (*ptr)
9865 : {
9866 84 : case '[':
9867 84 : if (brace)
9868 0 : mmfatal(PARSE_ERROR, "multidimensional arrays for simple data types are not supported");
9869 84 : brace_open++;
9870 84 : break;
9871 84 : case ']':
9872 84 : brace_open--;
9873 84 : if (brace_open == 0)
9874 84 : brace = true;
9875 84 : break;
9876 0 : case '\t':
9877 : case ' ':
9878 0 : break;
9879 6518 : default:
9880 6518 : if (brace_open == 0)
9881 6434 : brace = false;
9882 6518 : break;
9883 : }
9884 : }
9885 : }
9886 : ;
9887 :
9888 : ecpg_param: PARAM
9889 : ;
9890 :
9891 : ecpg_bconst: BCONST
9892 : ;
9893 :
9894 : ecpg_fconst: FCONST
9895 : ;
9896 :
9897 : ecpg_sconst: SCONST
9898 : ;
9899 :
9900 : ecpg_xconst: XCONST
9901 : ;
9902 :
9903 : ecpg_ident: IDENT
9904 : | CSTRING
9905 : {
9906 2338 : @$ = make3_str("\"", @1, "\"");
9907 : }
9908 : ;
9909 :
9910 : quoted_ident_stringvar: name
9911 : {
9912 212 : @$ = make3_str("\"", @1, "\"");
9913 : }
9914 : | char_variable
9915 : {
9916 8 : @$ = make3_str("(", @1, ")");
9917 : }
9918 : ;
9919 :
9920 : /*
9921 : * C stuff
9922 : */
9923 :
9924 : c_stuff_item: c_anything
9925 : | '(' ')'
9926 : {
9927 0 : @$ = "()";
9928 : }
9929 : | '(' c_stuff ')'
9930 : ;
9931 :
9932 : c_stuff: c_stuff_item
9933 : | c_stuff c_stuff_item
9934 : ;
9935 :
9936 : c_list: c_term
9937 : | c_list ',' c_term
9938 : ;
9939 :
9940 : c_term: c_stuff
9941 : | '{' c_list '}'
9942 : ;
9943 :
9944 : c_thing: c_anything
9945 : | '('
9946 : | ')'
9947 : | ','
9948 : | ';'
9949 : ;
9950 :
9951 : /*
9952 : * Note: NULL_P is treated specially to force it to be output in upper case,
9953 : * since it's likely meant as a reference to the standard C macro NULL.
9954 : */
9955 : c_anything: ecpg_ident
9956 : | Iconst
9957 : | ecpg_fconst
9958 : | ecpg_sconst
9959 : | '*'
9960 : | '+'
9961 : | '-'
9962 : | '/'
9963 : | '%'
9964 4 : | NULL_P { @$ = "NULL"; }
9965 : | S_ADD
9966 : | S_AND
9967 : | S_ANYTHING
9968 : | S_AUTO
9969 : | S_CONST
9970 : | S_DEC
9971 : | S_DIV
9972 : | S_DOTPOINT
9973 : | S_EQUAL
9974 : | S_EXTERN
9975 : | S_INC
9976 : | S_LSHIFT
9977 : | S_MEMBER
9978 : | S_MEMPOINT
9979 : | S_MOD
9980 : | S_MUL
9981 : | S_NEQUAL
9982 : | S_OR
9983 : | S_REGISTER
9984 : | S_RSHIFT
9985 : | S_STATIC
9986 : | S_SUB
9987 : | S_TYPEDEF
9988 : | S_VOLATILE
9989 : | SQL_BOOL
9990 : | ENUM_P
9991 : | HOUR_P
9992 : | INT_P
9993 : | SQL_LONG
9994 : | MINUTE_P
9995 : | MONTH_P
9996 : | SECOND_P
9997 : | SQL_SHORT
9998 : | SQL_SIGNED
9999 : | SQL_STRUCT
10000 : | SQL_UNSIGNED
10001 : | YEAR_P
10002 : | CHAR_P
10003 : | FLOAT_P
10004 : | TO
10005 : | UNION
10006 : | VARCHAR
10007 : | '['
10008 : | ']'
10009 : | '='
10010 : | ':'
10011 : ;
10012 :
10013 : DeallocateStmt: DEALLOCATE prepared_name
10014 : {
10015 36 : check_declared_list(@2);
10016 36 : @$ = @2;
10017 : }
10018 : | DEALLOCATE PREPARE prepared_name
10019 : {
10020 38 : check_declared_list(@3);
10021 38 : @$ = @3;
10022 : }
10023 : | DEALLOCATE ALL
10024 : {
10025 2 : @$ = "all";
10026 : }
10027 : | DEALLOCATE PREPARE ALL
10028 : {
10029 0 : @$ = "all";
10030 : }
10031 : ;
10032 :
10033 : Iresult: Iconst
10034 : | '(' Iresult ')'
10035 : | Iresult '+' Iresult
10036 : | Iresult '-' Iresult
10037 : | Iresult '*' Iresult
10038 : | Iresult '/' Iresult
10039 : | Iresult '%' Iresult
10040 : | ecpg_sconst
10041 : | ColId
10042 : | ColId '(' var_type ')'
10043 : {
10044 0 : if (pg_strcasecmp(@1, "sizeof") != 0)
10045 0 : mmerror(PARSE_ERROR, ET_ERROR, "operator not allowed in variable definition");
10046 : else
10047 0 : @$ = cat_str(4, @1, "(", $3.type_str, ")");
10048 : }
10049 : ;
10050 :
10051 : execute_rest: /* EMPTY */
10052 : | ecpg_using opt_ecpg_into
10053 : | ecpg_into ecpg_using
10054 : | ecpg_into
10055 : ;
10056 :
10057 : ecpg_into: INTO into_list
10058 : {
10059 : /* always suppress this from the constructed string */
10060 290 : @$ = "";
10061 : }
10062 : | into_descriptor
10063 : ;
10064 :
10065 : opt_ecpg_into: /* EMPTY */
10066 : | ecpg_into
10067 : ;
10068 :
10069 : ecpg_fetch_into: ecpg_into
10070 : | using_descriptor
10071 : {
10072 : struct variable *var;
10073 :
10074 2 : var = argsinsert->variable;
10075 2 : remove_variable_from_list(&argsinsert, var);
10076 2 : add_variable_to_head(&argsresult, var, &no_indicator);
10077 : }
10078 : ;
10079 :
10080 : opt_ecpg_fetch_into: /* EMPTY */
10081 : | ecpg_fetch_into
10082 : ;
10083 :
10084 : %%
10085 :
10086 : void
10087 0 : base_yyerror(const char *error)
10088 : {
10089 : /* translator: %s is typically the translation of "syntax error" */
10090 0 : mmerror(PARSE_ERROR, ET_ERROR, "%s at or near \"%s\"",
10091 0 : _(error), token_start ? token_start : base_yytext);
10092 0 : }
10093 :
10094 : void
10095 0 : parser_init(void)
10096 : {
10097 : /*
10098 : * This function is empty. It only exists for compatibility with the
10099 : * backend parser right now.
10100 : */
10101 0 : }
|
