LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/preproc - preproc.y (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 948 1400 67.7 %
Date: 2025-04-24 12:15:10 Functions: 7 9 77.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14