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