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