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