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