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