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