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