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