LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/preproc - preproc.y (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 1339 4540 29.5 %
Date: 2020-11-27 12:05:55 Functions: 9 15 60.0 %
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             : /*
      69             :  * Handle parsing errors and warnings
      70             :  */
      71             : static void
      72           0 : vmmerror(int error_code, enum errortype type, const char *error, va_list ap)
      73             : {
      74             :     /* localize the error message string */
      75           0 :     error = _(error);
      76             : 
      77           0 :     fprintf(stderr, "%s:%d: ", input_filename, base_yylineno);
      78             : 
      79           0 :     switch(type)
      80             :     {
      81           0 :         case ET_WARNING:
      82           0 :             fprintf(stderr, _("WARNING: "));
      83           0 :             break;
      84           0 :         case ET_ERROR:
      85           0 :             fprintf(stderr, _("ERROR: "));
      86           0 :             break;
      87             :     }
      88             : 
      89           0 :     vfprintf(stderr, error, ap);
      90             : 
      91           0 :     fprintf(stderr, "\n");
      92             : 
      93           0 :     switch(type)
      94             :     {
      95           0 :         case ET_WARNING:
      96           0 :             break;
      97           0 :         case ET_ERROR:
      98           0 :             ret_value = error_code;
      99           0 :             break;
     100             :     }
     101           0 : }
     102             : 
     103             : void
     104           0 : mmerror(int error_code, enum errortype type, const char *error, ...)
     105             : {
     106             :     va_list     ap;
     107             : 
     108           0 :     va_start(ap, error);
     109           0 :     vmmerror(error_code, type, error, ap);
     110           0 :     va_end(ap);
     111           0 : }
     112             : 
     113             : void
     114           0 : mmfatal(int error_code, const char *error, ...)
     115             : {
     116             :     va_list     ap;
     117             : 
     118           0 :     va_start(ap, error);
     119           0 :     vmmerror(error_code, ET_ERROR, error, ap);
     120           0 :     va_end(ap);
     121             : 
     122           0 :     if (base_yyin)
     123           0 :         fclose(base_yyin);
     124           0 :     if (base_yyout)
     125           0 :         fclose(base_yyout);
     126             : 
     127           0 :     if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0)
     128           0 :         fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);
     129           0 :     exit(error_code);
     130             : }
     131             : 
     132             : /*
     133             :  * string concatenation
     134             :  */
     135             : 
     136             : static char *
     137       20806 : cat2_str(char *str1, char *str2)
     138             : {
     139       20806 :     char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2);
     140             : 
     141       20806 :     strcpy(res_str, str1);
     142       20806 :     if (strlen(str1) != 0 && strlen(str2) != 0)
     143       13004 :         strcat(res_str, " ");
     144       20806 :     strcat(res_str, str2);
     145       20806 :     free(str1);
     146       20806 :     free(str2);
     147       20806 :     return res_str;
     148             : }
     149             : 
     150             : static char *
     151        6902 : cat_str(int count, ...)
     152             : {
     153             :     va_list     args;
     154             :     int         i;
     155             :     char        *res_str;
     156             : 
     157        6902 :     va_start(args, count);
     158             : 
     159        6902 :     res_str = va_arg(args, char *);
     160             : 
     161             :     /* now add all other strings */
     162       26228 :     for (i = 1; i < count; i++)
     163       19326 :         res_str = cat2_str(res_str, va_arg(args, char *));
     164             : 
     165        6902 :     va_end(args);
     166             : 
     167        6902 :     return res_str;
     168             : }
     169             : 
     170             : static char *
     171          96 : make2_str(char *str1, char *str2)
     172             : {
     173          96 :     char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1);
     174             : 
     175          96 :     strcpy(res_str, str1);
     176          96 :     strcat(res_str, str2);
     177          96 :     free(str1);
     178          96 :     free(str2);
     179          96 :     return res_str;
     180             : }
     181             : 
     182             : static char *
     183        3304 : make3_str(char *str1, char *str2, char *str3)
     184             : {
     185        3304 :     char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1);
     186             : 
     187        3304 :     strcpy(res_str, str1);
     188        3304 :     strcat(res_str, str2);
     189        3304 :     strcat(res_str, str3);
     190        3304 :     free(str1);
     191        3304 :     free(str2);
     192        3304 :     free(str3);
     193        3304 :     return res_str;
     194             : }
     195             : 
     196             : /* and the rest */
     197             : static char *
     198        4466 : make_name(void)
     199             : {
     200        4466 :     return mm_strdup(base_yytext);
     201             : }
     202             : 
     203             : static char *
     204         244 : create_questionmarks(char *name, bool array)
     205             : {
     206         244 :     struct variable *p = find_variable(name);
     207             :     int count;
     208         244 :     char *result = EMPTY;
     209             : 
     210             :     /* In case we have a struct, we have to print as many "?" as there are attributes in the struct
     211             :      * An array is only allowed together with an element argument
     212             :      * This is essentially only used for inserts, but using a struct as input parameter is an error anywhere else
     213             :      * so we don't have to worry here. */
     214             : 
     215         244 :     if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct))
     216           0 :     {
     217             :         struct ECPGstruct_member *m;
     218             : 
     219           0 :         if (p->type->type == ECPGt_struct)
     220           0 :             m = p->type->u.members;
     221             :         else
     222           0 :             m = p->type->u.element->u.members;
     223             : 
     224           0 :         for (count = 0; m != NULL; m=m->next, count++);
     225             :     }
     226             :     else
     227         244 :         count = 1;
     228             : 
     229         488 :     for (; count > 0; count --)
     230             :     {
     231         244 :         sprintf(pacounter_buffer, "$%d", pacounter++);
     232         244 :         result = cat_str(3, result, mm_strdup(pacounter_buffer), mm_strdup(" , "));
     233             :     }
     234             : 
     235             :     /* removed the trailing " ," */
     236             : 
     237         244 :     result[strlen(result)-3] = '\0';
     238         244 :     return result;
     239             : }
     240             : 
     241             : static char *
     242          64 : adjust_outofscope_cursor_vars(struct cursor *cur)
     243             : {
     244             :     /* Informix accepts DECLARE with variables that are out of scope when OPEN is called.
     245             :      * For instance you can DECLARE a cursor in one function, and OPEN/FETCH/CLOSE
     246             :      * it in another functions. This is very useful for e.g. event-driver programming,
     247             :      * but may also lead to dangerous programming. The limitation when this is allowed
     248             :      * and doesn't cause problems have to be documented, like the allocated variables
     249             :      * must not be realloc()'ed.
     250             :      *
     251             :      * We have to change the variables to our own struct and just store the pointer
     252             :      * instead of the variable. Do it only for local variables, not for globals.
     253             :      */
     254             : 
     255          64 :     char *result = EMPTY;
     256             :     int insert;
     257             : 
     258         192 :     for (insert = 1; insert >= 0; insert--)
     259             :     {
     260             :         struct arguments *list;
     261             :         struct arguments *ptr;
     262         128 :         struct arguments *newlist = NULL;
     263             :         struct variable *newvar, *newind;
     264             : 
     265         128 :         list = (insert ? cur->argsinsert : cur->argsresult);
     266             : 
     267         184 :         for (ptr = list; ptr != NULL; ptr = ptr->next)
     268             :         {
     269             :             char var_text[20];
     270             :             char *original_var;
     271          56 :             bool skip_set_var = false;
     272          56 :             bool var_ptr = false;
     273             : 
     274             :             /* change variable name to "ECPGget_var(<counter>)" */
     275          56 :             original_var = ptr->variable->name;
     276          56 :             sprintf(var_text, "%d))", ecpg_internal_var);
     277             : 
     278             :             /* Don't emit ECPGset_var() calls for global variables */
     279          56 :             if (ptr->variable->brace_level == 0)
     280             :             {
     281          30 :                 newvar = ptr->variable;
     282          30 :                 skip_set_var = true;
     283             :             }
     284          26 :             else if ((ptr->variable->type->type == ECPGt_char_variable)
     285           0 :                      && (strncmp(ptr->variable->name, "ECPGprepared_statement", strlen("ECPGprepared_statement")) == 0))
     286             :             {
     287           0 :                 newvar = ptr->variable;
     288           0 :                 skip_set_var = true;
     289             :             }
     290          26 :             else if ((ptr->variable->type->type != ECPGt_varchar
     291          24 :                       && ptr->variable->type->type != ECPGt_char
     292          14 :                       && ptr->variable->type->type != ECPGt_unsigned_char
     293          14 :                       && ptr->variable->type->type != ECPGt_string
     294          14 :                       && ptr->variable->type->type != ECPGt_bytea)
     295          12 :                      && atoi(ptr->variable->type->size) > 1)
     296             :             {
     297           0 :                 newvar = new_variable(cat_str(4, mm_strdup("("),
     298           0 :                                               mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)),
     299             :                                               mm_strdup(" *)(ECPGget_var("),
     300             :                                               mm_strdup(var_text)),
     301           0 :                                       ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,
     302             :                                                                                mm_strdup("1"),
     303           0 :                                                                                ptr->variable->type->u.element->counter),
     304           0 :                                                           ptr->variable->type->size),
     305             :                                       0);
     306             :             }
     307          26 :             else if ((ptr->variable->type->type == ECPGt_varchar
     308          24 :                       || ptr->variable->type->type == ECPGt_char
     309          14 :                       || ptr->variable->type->type == ECPGt_unsigned_char
     310          14 :                       || ptr->variable->type->type == ECPGt_string
     311          14 :                       || ptr->variable->type->type == ECPGt_bytea)
     312          14 :                      && atoi(ptr->variable->type->size) > 1)
     313             :             {
     314          12 :                 newvar = new_variable(cat_str(4, mm_strdup("("),
     315           6 :                                               mm_strdup(ecpg_type_name(ptr->variable->type->type)),
     316             :                                               mm_strdup(" *)(ECPGget_var("),
     317             :                                               mm_strdup(var_text)),
     318           6 :                                       ECPGmake_simple_type(ptr->variable->type->type,
     319           6 :                                                            ptr->variable->type->size,
     320           6 :                                                            ptr->variable->type->counter),
     321             :                                       0);
     322          12 :                 if (ptr->variable->type->type == ECPGt_varchar ||
     323           4 :                     ptr->variable->type->type == ECPGt_bytea)
     324           4 :                     var_ptr = true;
     325             :             }
     326          20 :             else if (ptr->variable->type->type == ECPGt_struct
     327          20 :                      || ptr->variable->type->type == ECPGt_union)
     328             :             {
     329           0 :                 newvar = new_variable(cat_str(5, mm_strdup("(*("),
     330           0 :                                               mm_strdup(ptr->variable->type->type_name),
     331             :                                               mm_strdup(" *)(ECPGget_var("),
     332             :                                               mm_strdup(var_text),
     333             :                                               mm_strdup(")")),
     334           0 :                                       ECPGmake_struct_type(ptr->variable->type->u.members,
     335           0 :                                                            ptr->variable->type->type,
     336           0 :                                                            ptr->variable->type->type_name,
     337           0 :                                                            ptr->variable->type->struct_sizeof),
     338             :                                       0);
     339           0 :                 var_ptr = true;
     340             :             }
     341          20 :             else if (ptr->variable->type->type == ECPGt_array)
     342             :             {
     343           2 :                 if (ptr->variable->type->u.element->type == ECPGt_struct
     344           0 :                     || ptr->variable->type->u.element->type == ECPGt_union)
     345             :                 {
     346           4 :                     newvar = new_variable(cat_str(5, mm_strdup("(*("),
     347           2 :                                               mm_strdup(ptr->variable->type->u.element->type_name),
     348             :                                               mm_strdup(" *)(ECPGget_var("),
     349             :                                               mm_strdup(var_text),
     350             :                                               mm_strdup(")")),
     351           2 :                                           ECPGmake_struct_type(ptr->variable->type->u.element->u.members,
     352           2 :                                                                ptr->variable->type->u.element->type,
     353           2 :                                                                ptr->variable->type->u.element->type_name,
     354           2 :                                                                ptr->variable->type->u.element->struct_sizeof),
     355             :                                           0);
     356             :                 }
     357             :                 else
     358             :                 {
     359           0 :                     newvar = new_variable(cat_str(4, mm_strdup("("),
     360           0 :                                                   mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)),
     361             :                                                   mm_strdup(" *)(ECPGget_var("),
     362             :                                                   mm_strdup(var_text)),
     363           0 :                                           ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,
     364           0 :                                                                                    ptr->variable->type->u.element->size,
     365           0 :                                                                                    ptr->variable->type->u.element->counter),
     366           0 :                                                               ptr->variable->type->size),
     367             :                                           0);
     368           0 :                     var_ptr = true;
     369             :                 }
     370             :             }
     371             :             else
     372             :             {
     373          36 :                 newvar = new_variable(cat_str(4, mm_strdup("*("),
     374          18 :                                               mm_strdup(ecpg_type_name(ptr->variable->type->type)),
     375             :                                               mm_strdup(" *)(ECPGget_var("),
     376             :                                               mm_strdup(var_text)),
     377          18 :                                       ECPGmake_simple_type(ptr->variable->type->type,
     378          18 :                                                            ptr->variable->type->size,
     379          18 :                                                            ptr->variable->type->counter),
     380             :                                       0);
     381          18 :                 var_ptr = true;
     382             :             }
     383             : 
     384             :             /* create call to "ECPGset_var(<counter>, <connection>, <pointer>. <line number>)" */
     385          56 :             if (!skip_set_var)
     386             :             {
     387          26 :                 sprintf(var_text, "%d, %s", ecpg_internal_var++, var_ptr ? "&(" : "(");
     388          26 :                 result = cat_str(5, result, mm_strdup("ECPGset_var("),
     389             :                                  mm_strdup(var_text), mm_strdup(original_var),
     390             :                                  mm_strdup("), __LINE__);\n"));
     391             :             }
     392             : 
     393             :             /* now the indicator if there is one and it's not a global variable */
     394          56 :             if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0))
     395             :             {
     396          54 :                 newind = ptr->indicator;
     397             :             }
     398             :             else
     399             :             {
     400             :                 /* change variable name to "ECPGget_var(<counter>)" */
     401           2 :                 original_var = ptr->indicator->name;
     402           2 :                 sprintf(var_text, "%d))", ecpg_internal_var);
     403           2 :                 var_ptr = false;
     404             : 
     405           2 :                 if (ptr->indicator->type->type == ECPGt_struct
     406           2 :                     || ptr->indicator->type->type == ECPGt_union)
     407             :                 {
     408           0 :                     newind = new_variable(cat_str(5, mm_strdup("(*("),
     409           0 :                                               mm_strdup(ptr->indicator->type->type_name),
     410             :                                               mm_strdup(" *)(ECPGget_var("),
     411             :                                               mm_strdup(var_text),
     412             :                                               mm_strdup(")")),
     413           0 :                                           ECPGmake_struct_type(ptr->indicator->type->u.members,
     414           0 :                                                                ptr->indicator->type->type,
     415           0 :                                                                ptr->indicator->type->type_name,
     416           0 :                                                                ptr->indicator->type->struct_sizeof),
     417             :                                           0);
     418           0 :                     var_ptr = true;
     419             :                 }
     420           2 :                 else if (ptr->indicator->type->type == ECPGt_array)
     421             :                 {
     422           2 :                     if (ptr->indicator->type->u.element->type == ECPGt_struct
     423           0 :                         || ptr->indicator->type->u.element->type == ECPGt_union)
     424             :                     {
     425           4 :                         newind = new_variable(cat_str(5, mm_strdup("(*("),
     426           2 :                                               mm_strdup(ptr->indicator->type->u.element->type_name),
     427             :                                               mm_strdup(" *)(ECPGget_var("),
     428             :                                               mm_strdup(var_text),
     429             :                                               mm_strdup(")")),
     430           2 :                                               ECPGmake_struct_type(ptr->indicator->type->u.element->u.members,
     431           2 :                                                                    ptr->indicator->type->u.element->type,
     432           2 :                                                                    ptr->indicator->type->u.element->type_name,
     433           2 :                                                                    ptr->indicator->type->u.element->struct_sizeof),
     434             :                                               0);
     435             :                     }
     436             :                     else
     437             :                     {
     438           0 :                         newind = new_variable(cat_str(4, mm_strdup("("),
     439           0 :                                                       mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)),
     440             :                                                       mm_strdup(" *)(ECPGget_var("), mm_strdup(var_text)),
     441           0 :                                               ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type,
     442           0 :                                                                                        ptr->indicator->type->u.element->size,
     443           0 :                                                                                        ptr->indicator->type->u.element->counter),
     444           0 :                                                                   ptr->indicator->type->size),
     445             :                                               0);
     446           0 :                         var_ptr = true;
     447             :                     }
     448             :                 }
     449           0 :                 else if (atoi(ptr->indicator->type->size) > 1)
     450             :                 {
     451           0 :                     newind = new_variable(cat_str(4, mm_strdup("("),
     452           0 :                                                   mm_strdup(ecpg_type_name(ptr->indicator->type->type)),
     453             :                                                   mm_strdup(" *)(ECPGget_var("),
     454             :                                                   mm_strdup(var_text)),
     455           0 :                                           ECPGmake_simple_type(ptr->indicator->type->type,
     456           0 :                                                                ptr->indicator->type->size,
     457           0 :                                                                ptr->variable->type->counter),
     458             :                                           0);
     459             :                 }
     460             :                 else
     461             :                 {
     462           0 :                     newind = new_variable(cat_str(4, mm_strdup("*("),
     463           0 :                                                   mm_strdup(ecpg_type_name(ptr->indicator->type->type)),
     464             :                                                   mm_strdup(" *)(ECPGget_var("),
     465             :                                                   mm_strdup(var_text)),
     466           0 :                                           ECPGmake_simple_type(ptr->indicator->type->type,
     467           0 :                                                                ptr->indicator->type->size,
     468           0 :                                                                ptr->variable->type->counter),
     469             :                                           0);
     470           0 :                     var_ptr = true;
     471             :                 }
     472             : 
     473             :                 /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */
     474           2 :                 sprintf(var_text, "%d, %s", ecpg_internal_var++, var_ptr ? "&(" : "(");
     475           2 :                 result = cat_str(5, result, mm_strdup("ECPGset_var("),
     476             :                                  mm_strdup(var_text), mm_strdup(original_var),
     477             :                                  mm_strdup("), __LINE__);\n"));
     478             :             }
     479             : 
     480          56 :             add_variable_to_tail(&newlist, newvar, newind);
     481             :         }
     482             : 
     483         128 :         if (insert)
     484          64 :             cur->argsinsert_oos = newlist;
     485             :         else
     486          64 :             cur->argsresult_oos = newlist;
     487             :     }
     488             : 
     489          64 :     return result;
     490             : }
     491             : 
     492             : /* This tests whether the cursor was declared and opened in the same function. */
     493             : #define SAMEFUNC(cur)   \
     494             :     ((cur->function == NULL) ||      \
     495             :      (cur->function != NULL && strcmp(cur->function, current_function) == 0))
     496             : 
     497             : static struct cursor *
     498         182 : add_additional_variables(char *name, bool insert)
     499             : {
     500             :     struct cursor *ptr;
     501             :     struct arguments *p;
     502         182 :     int (* strcmp_fn)(const char *, const char *) = ((name[0] == ':' || name[0] == '"') ? strcmp : pg_strcasecmp);
     503             : 
     504         196 :     for (ptr = cur; ptr != NULL; ptr=ptr->next)
     505             :     {
     506         196 :         if (strcmp_fn(ptr->name, name) == 0)
     507         182 :             break;
     508             :     }
     509             : 
     510         182 :     if (ptr == NULL)
     511             :     {
     512           0 :         mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name);
     513           0 :         return NULL;
     514             :     }
     515             : 
     516         182 :     if (insert)
     517             :     {
     518             :         /* add all those input variables that were given earlier
     519             :          * note that we have to append here but have to keep the existing order */
     520         116 :         for (p = (SAMEFUNC(ptr) ? ptr->argsinsert : ptr->argsinsert_oos); p; p = p->next)
     521          50 :             add_variable_to_tail(&argsinsert, p->variable, p->indicator);
     522             :     }
     523             : 
     524             :     /* add all those output variables that were given earlier */
     525         218 :     for (p = (SAMEFUNC(ptr) ? ptr->argsresult : ptr->argsresult_oos); p; p = p->next)
     526          36 :         add_variable_to_tail(&argsresult, p->variable, p->indicator);
     527             : 
     528         182 :     return ptr;
     529             : }
     530             : 
     531             : static void
     532          42 : add_typedef(char *name, char *dimension, char *length, enum ECPGttype type_enum,
     533             :             char *type_dimension, char *type_index, int initializer, int array)
     534             : {
     535             :     /* add entry to list */
     536             :     struct typedefs *ptr, *this;
     537             : 
     538          42 :     if ((type_enum == ECPGt_struct ||
     539          20 :          type_enum == ECPGt_union) &&
     540             :         initializer == 1)
     541           0 :         mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition");
     542          42 :     else if (INFORMIX_MODE && strcmp(name, "string") == 0)
     543           0 :         mmerror(PARSE_ERROR, ET_ERROR, "type name \"string\" is reserved in Informix mode");
     544             :     else
     545             :     {
     546         104 :         for (ptr = types; ptr != NULL; ptr = ptr->next)
     547             :         {
     548          62 :             if (strcmp(name, ptr->name) == 0)
     549             :                 /* re-definition is a bug */
     550           0 :                 mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name);
     551             :         }
     552          42 :         adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true);
     553             : 
     554          42 :         this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
     555             : 
     556             :         /* initial definition */
     557          42 :         this->next = types;
     558          42 :         this->name = name;
     559          42 :         this->brace_level = braces_open;
     560          42 :         this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
     561          42 :         this->type->type_enum = type_enum;
     562          42 :         this->type->type_str = mm_strdup(name);
     563          42 :         this->type->type_dimension = dimension; /* dimension of array */
     564          42 :         this->type->type_index = length;  /* length of string */
     565          42 :         this->type->type_sizeof = ECPGstruct_sizeof;
     566          26 :         this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ?
     567          68 :         ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL;
     568             : 
     569          42 :         if (type_enum != ECPGt_varchar &&
     570          38 :             type_enum != ECPGt_bytea &&
     571          26 :             type_enum != ECPGt_char &&
     572          26 :             type_enum != ECPGt_unsigned_char &&
     573          26 :             type_enum != ECPGt_string &&
     574          26 :             atoi(this->type->type_index) >= 0)
     575           0 :             mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
     576             : 
     577          42 :         types = this;
     578             :     }
     579          42 : }
     580             : %}
     581             : 
     582             : %expect 0
     583             : %name-prefix="base_yy"
     584             : %locations
     585             : 
     586             : %union {
     587             :     double  dval;
     588             :     char    *str;
     589             :     int     ival;
     590             :     struct  when        action;
     591             :     struct  index       index;
     592             :     int     tagname;
     593             :     struct  this_type   type;
     594             :     enum    ECPGttype   type_enum;
     595             :     enum    ECPGdtype   dtype_enum;
     596             :     struct  fetch_desc  descriptor;
     597             :     struct  su_symbol   struct_union;
     598             :     struct  prep        prep;
     599             :     struct  exec        exec;
     600             : }
     601             : /* tokens */
     602             : /* src/interfaces/ecpg/preproc/ecpg.tokens */
     603             : 
     604             : /* special embedded SQL tokens */
     605             : %token  SQL_ALLOCATE SQL_AUTOCOMMIT SQL_BOOL SQL_BREAK
     606             :                 SQL_CARDINALITY SQL_CONNECT
     607             :                 SQL_COUNT
     608             :                 SQL_DATETIME_INTERVAL_CODE
     609             :                 SQL_DATETIME_INTERVAL_PRECISION SQL_DESCRIBE
     610             :                 SQL_DESCRIPTOR SQL_DISCONNECT SQL_FOUND
     611             :                 SQL_FREE SQL_GET SQL_GO SQL_GOTO SQL_IDENTIFIED
     612             :                 SQL_INDICATOR SQL_KEY_MEMBER SQL_LENGTH
     613             :                 SQL_LONG SQL_NULLABLE SQL_OCTET_LENGTH
     614             :                 SQL_OPEN SQL_OUTPUT SQL_REFERENCE
     615             :                 SQL_RETURNED_LENGTH SQL_RETURNED_OCTET_LENGTH SQL_SCALE
     616             :                 SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQLERROR
     617             :                 SQL_SQLPRINT SQL_SQLWARNING SQL_START SQL_STOP
     618             :                 SQL_STRUCT SQL_UNSIGNED SQL_VAR SQL_WHENEVER
     619             : 
     620             : /* C tokens */
     621             : %token  S_ADD S_AND S_ANYTHING S_AUTO S_CONST S_DEC S_DIV
     622             :                 S_DOTPOINT S_EQUAL S_EXTERN S_INC S_LSHIFT S_MEMPOINT
     623             :                 S_MEMBER S_MOD S_MUL S_NEQUAL S_OR S_REGISTER S_RSHIFT
     624             :                 S_STATIC S_SUB S_VOLATILE
     625             :                 S_TYPEDEF
     626             : 
     627             : %token CSTRING CVARIABLE CPP_LINE IP
     628             : /* types */
     629             : %type <str> stmt
     630             : %type <str> CallStmt
     631             : %type <str> CreateRoleStmt
     632             : %type <str> opt_with
     633             : %type <str> OptRoleList
     634             : %type <str> AlterOptRoleList
     635             : %type <str> AlterOptRoleElem
     636             : %type <str> CreateOptRoleElem
     637             : %type <str> CreateUserStmt
     638             : %type <str> AlterRoleStmt
     639             : %type <str> opt_in_database
     640             : %type <str> AlterRoleSetStmt
     641             : %type <str> DropRoleStmt
     642             : %type <str> CreateGroupStmt
     643             : %type <str> AlterGroupStmt
     644             : %type <str> add_drop
     645             : %type <str> CreateSchemaStmt
     646             : %type <str> OptSchemaName
     647             : %type <str> OptSchemaEltList
     648             : %type <str> schema_stmt
     649             : %type <str> VariableSetStmt
     650             : %type <str> set_rest
     651             : %type <str> generic_set
     652             : %type <str> set_rest_more
     653             : %type <str> var_name
     654             : %type <str> var_list
     655             : %type <str> var_value
     656             : %type <str> iso_level
     657             : %type <str> opt_boolean_or_string
     658             : %type <str> zone_value
     659             : %type <str> opt_encoding
     660             : %type <str> NonReservedWord_or_Sconst
     661             : %type <str> VariableResetStmt
     662             : %type <str> reset_rest
     663             : %type <str> generic_reset
     664             : %type <str> SetResetClause
     665             : %type <str> FunctionSetResetClause
     666             : %type <str> VariableShowStmt
     667             : %type <str> ConstraintsSetStmt
     668             : %type <str> constraints_set_list
     669             : %type <str> constraints_set_mode
     670             : %type <str> CheckPointStmt
     671             : %type <str> DiscardStmt
     672             : %type <str> AlterTableStmt
     673             : %type <str> alter_table_cmds
     674             : %type <str> partition_cmd
     675             : %type <str> index_partition_cmd
     676             : %type <str> alter_table_cmd
     677             : %type <str> alter_column_default
     678             : %type <str> opt_drop_behavior
     679             : %type <str> opt_collate_clause
     680             : %type <str> alter_using
     681             : %type <str> replica_identity
     682             : %type <str> reloptions
     683             : %type <str> opt_reloptions
     684             : %type <str> reloption_list
     685             : %type <str> reloption_elem
     686             : %type <str> alter_identity_column_option_list
     687             : %type <str> alter_identity_column_option
     688             : %type <str> PartitionBoundSpec
     689             : %type <str> hash_partbound_elem
     690             : %type <str> hash_partbound
     691             : %type <str> AlterCompositeTypeStmt
     692             : %type <str> alter_type_cmds
     693             : %type <str> alter_type_cmd
     694             : %type <str> ClosePortalStmt
     695             : %type <str> CopyStmt
     696             : %type <str> copy_from
     697             : %type <str> opt_program
     698             : %type <str> copy_file_name
     699             : %type <str> copy_options
     700             : %type <str> copy_opt_list
     701             : %type <str> copy_opt_item
     702             : %type <str> opt_binary
     703             : %type <str> copy_delimiter
     704             : %type <str> opt_using
     705             : %type <str> copy_generic_opt_list
     706             : %type <str> copy_generic_opt_elem
     707             : %type <str> copy_generic_opt_arg
     708             : %type <str> copy_generic_opt_arg_list
     709             : %type <str> copy_generic_opt_arg_list_item
     710             : %type <str> CreateStmt
     711             : %type <str> OptTemp
     712             : %type <str> OptTableElementList
     713             : %type <str> OptTypedTableElementList
     714             : %type <str> TableElementList
     715             : %type <str> TypedTableElementList
     716             : %type <str> TableElement
     717             : %type <str> TypedTableElement
     718             : %type <str> columnDef
     719             : %type <str> columnOptions
     720             : %type <str> ColQualList
     721             : %type <str> ColConstraint
     722             : %type <str> ColConstraintElem
     723             : %type <str> generated_when
     724             : %type <str> ConstraintAttr
     725             : %type <str> TableLikeClause
     726             : %type <str> TableLikeOptionList
     727             : %type <str> TableLikeOption
     728             : %type <str> TableConstraint
     729             : %type <str> ConstraintElem
     730             : %type <str> opt_no_inherit
     731             : %type <str> opt_column_list
     732             : %type <str> columnList
     733             : %type <str> columnElem
     734             : %type <str> opt_c_include
     735             : %type <str> key_match
     736             : %type <str> ExclusionConstraintList
     737             : %type <str> ExclusionConstraintElem
     738             : %type <str> ExclusionWhereClause
     739             : %type <str> key_actions
     740             : %type <str> key_update
     741             : %type <str> key_delete
     742             : %type <str> key_action
     743             : %type <str> OptInherit
     744             : %type <str> OptPartitionSpec
     745             : %type <str> PartitionSpec
     746             : %type <str> part_params
     747             : %type <str> part_elem
     748             : %type <str> table_access_method_clause
     749             : %type <str> OptWith
     750             : %type <str> OnCommitOption
     751             : %type <str> OptTableSpace
     752             : %type <str> OptConsTableSpace
     753             : %type <str> ExistingIndex
     754             : %type <str> CreateStatsStmt
     755             : %type <str> AlterStatsStmt
     756             : %type <str> create_as_target
     757             : %type <str> opt_with_data
     758             : %type <str> CreateMatViewStmt
     759             : %type <str> create_mv_target
     760             : %type <str> OptNoLog
     761             : %type <str> RefreshMatViewStmt
     762             : %type <str> CreateSeqStmt
     763             : %type <str> AlterSeqStmt
     764             : %type <str> OptSeqOptList
     765             : %type <str> OptParenthesizedSeqOptList
     766             : %type <str> SeqOptList
     767             : %type <str> SeqOptElem
     768             : %type <str> opt_by
     769             : %type <str> NumericOnly
     770             : %type <str> NumericOnly_list
     771             : %type <str> CreatePLangStmt
     772             : %type <str> opt_trusted
     773             : %type <str> handler_name
     774             : %type <str> opt_inline_handler
     775             : %type <str> validator_clause
     776             : %type <str> opt_validator
     777             : %type <str> opt_procedural
     778             : %type <str> CreateTableSpaceStmt
     779             : %type <str> OptTableSpaceOwner
     780             : %type <str> DropTableSpaceStmt
     781             : %type <str> CreateExtensionStmt
     782             : %type <str> create_extension_opt_list
     783             : %type <str> create_extension_opt_item
     784             : %type <str> AlterExtensionStmt
     785             : %type <str> alter_extension_opt_list
     786             : %type <str> alter_extension_opt_item
     787             : %type <str> AlterExtensionContentsStmt
     788             : %type <str> CreateFdwStmt
     789             : %type <str> fdw_option
     790             : %type <str> fdw_options
     791             : %type <str> opt_fdw_options
     792             : %type <str> AlterFdwStmt
     793             : %type <str> create_generic_options
     794             : %type <str> generic_option_list
     795             : %type <str> alter_generic_options
     796             : %type <str> alter_generic_option_list
     797             : %type <str> alter_generic_option_elem
     798             : %type <str> generic_option_elem
     799             : %type <str> generic_option_name
     800             : %type <str> generic_option_arg
     801             : %type <str> CreateForeignServerStmt
     802             : %type <str> opt_type
     803             : %type <str> foreign_server_version
     804             : %type <str> opt_foreign_server_version
     805             : %type <str> AlterForeignServerStmt
     806             : %type <str> CreateForeignTableStmt
     807             : %type <str> ImportForeignSchemaStmt
     808             : %type <str> import_qualification_type
     809             : %type <str> import_qualification
     810             : %type <str> CreateUserMappingStmt
     811             : %type <str> auth_ident
     812             : %type <str> DropUserMappingStmt
     813             : %type <str> AlterUserMappingStmt
     814             : %type <str> CreatePolicyStmt
     815             : %type <str> AlterPolicyStmt
     816             : %type <str> RowSecurityOptionalExpr
     817             : %type <str> RowSecurityOptionalWithCheck
     818             : %type <str> RowSecurityDefaultToRole
     819             : %type <str> RowSecurityOptionalToRole
     820             : %type <str> RowSecurityDefaultPermissive
     821             : %type <str> RowSecurityDefaultForCmd
     822             : %type <str> row_security_cmd
     823             : %type <str> CreateAmStmt
     824             : %type <str> am_type
     825             : %type <str> CreateTrigStmt
     826             : %type <str> TriggerActionTime
     827             : %type <str> TriggerEvents
     828             : %type <str> TriggerOneEvent
     829             : %type <str> TriggerReferencing
     830             : %type <str> TriggerTransitions
     831             : %type <str> TriggerTransition
     832             : %type <str> TransitionOldOrNew
     833             : %type <str> TransitionRowOrTable
     834             : %type <str> TransitionRelName
     835             : %type <str> TriggerForSpec
     836             : %type <str> TriggerForOptEach
     837             : %type <str> TriggerForType
     838             : %type <str> TriggerWhen
     839             : %type <str> FUNCTION_or_PROCEDURE
     840             : %type <str> TriggerFuncArgs
     841             : %type <str> TriggerFuncArg
     842             : %type <str> OptConstrFromTable
     843             : %type <str> ConstraintAttributeSpec
     844             : %type <str> ConstraintAttributeElem
     845             : %type <str> CreateEventTrigStmt
     846             : %type <str> event_trigger_when_list
     847             : %type <str> event_trigger_when_item
     848             : %type <str> event_trigger_value_list
     849             : %type <str> AlterEventTrigStmt
     850             : %type <str> enable_trigger
     851             : %type <str> CreateAssertionStmt
     852             : %type <str> DefineStmt
     853             : %type <str> definition
     854             : %type <str> def_list
     855             : %type <str> def_elem
     856             : %type <str> def_arg
     857             : %type <str> old_aggr_definition
     858             : %type <str> old_aggr_list
     859             : %type <str> old_aggr_elem
     860             : %type <str> opt_enum_val_list
     861             : %type <str> enum_val_list
     862             : %type <str> AlterEnumStmt
     863             : %type <str> opt_if_not_exists
     864             : %type <str> CreateOpClassStmt
     865             : %type <str> opclass_item_list
     866             : %type <str> opclass_item
     867             : %type <str> opt_default
     868             : %type <str> opt_opfamily
     869             : %type <str> opclass_purpose
     870             : %type <str> opt_recheck
     871             : %type <str> CreateOpFamilyStmt
     872             : %type <str> AlterOpFamilyStmt
     873             : %type <str> opclass_drop_list
     874             : %type <str> opclass_drop
     875             : %type <str> DropOpClassStmt
     876             : %type <str> DropOpFamilyStmt
     877             : %type <str> DropOwnedStmt
     878             : %type <str> ReassignOwnedStmt
     879             : %type <str> DropStmt
     880             : %type <str> object_type_any_name
     881             : %type <str> object_type_name
     882             : %type <str> drop_type_name
     883             : %type <str> object_type_name_on_any_name
     884             : %type <str> any_name_list
     885             : %type <str> any_name
     886             : %type <str> attrs
     887             : %type <str> type_name_list
     888             : %type <str> TruncateStmt
     889             : %type <str> opt_restart_seqs
     890             : %type <str> CommentStmt
     891             : %type <str> comment_text
     892             : %type <str> SecLabelStmt
     893             : %type <str> opt_provider
     894             : %type <str> security_label
     895             : %type <str> FetchStmt
     896             : %type <str> fetch_args
     897             : %type <str> from_in
     898             : %type <str> opt_from_in
     899             : %type <str> GrantStmt
     900             : %type <str> RevokeStmt
     901             : %type <str> privileges
     902             : %type <str> privilege_list
     903             : %type <str> privilege
     904             : %type <str> privilege_target
     905             : %type <str> grantee_list
     906             : %type <str> grantee
     907             : %type <str> opt_grant_grant_option
     908             : %type <str> GrantRoleStmt
     909             : %type <str> RevokeRoleStmt
     910             : %type <str> opt_grant_admin_option
     911             : %type <str> opt_granted_by
     912             : %type <str> AlterDefaultPrivilegesStmt
     913             : %type <str> DefACLOptionList
     914             : %type <str> DefACLOption
     915             : %type <str> DefACLAction
     916             : %type <str> defacl_privilege_target
     917             : %type <str> IndexStmt
     918             : %type <str> opt_unique
     919             : %type <str> opt_concurrently
     920             : %type <str> opt_index_name
     921             : %type <str> access_method_clause
     922             : %type <str> index_params
     923             : %type <str> index_elem_options
     924             : %type <str> index_elem
     925             : %type <str> opt_include
     926             : %type <str> index_including_params
     927             : %type <str> opt_collate
     928             : %type <str> opt_class
     929             : %type <str> opt_asc_desc
     930             : %type <str> opt_nulls_order
     931             : %type <str> CreateFunctionStmt
     932             : %type <str> opt_or_replace
     933             : %type <str> func_args
     934             : %type <str> func_args_list
     935             : %type <str> function_with_argtypes_list
     936             : %type <str> procedure_with_argtypes_list
     937             : %type <str> function_with_argtypes
     938             : %type <str> function_with_argtypes_common
     939             : %type <str> procedure_with_argtypes
     940             : %type <str> func_args_with_defaults
     941             : %type <str> func_args_with_defaults_list
     942             : %type <str> func_arg
     943             : %type <str> arg_class
     944             : %type <str> param_name
     945             : %type <str> func_return
     946             : %type <str> func_type
     947             : %type <str> func_arg_with_default
     948             : %type <str> aggr_arg
     949             : %type <str> aggr_args
     950             : %type <str> aggr_args_list
     951             : %type <str> aggregate_with_argtypes
     952             : %type <str> aggregate_with_argtypes_list
     953             : %type <str> createfunc_opt_list
     954             : %type <str> common_func_opt_item
     955             : %type <str> createfunc_opt_item
     956             : %type <str> func_as
     957             : %type <str> transform_type_list
     958             : %type <str> opt_definition
     959             : %type <str> table_func_column
     960             : %type <str> table_func_column_list
     961             : %type <str> AlterFunctionStmt
     962             : %type <str> alterfunc_opt_list
     963             : %type <str> opt_restrict
     964             : %type <str> RemoveFuncStmt
     965             : %type <str> RemoveAggrStmt
     966             : %type <str> RemoveOperStmt
     967             : %type <str> oper_argtypes
     968             : %type <str> any_operator
     969             : %type <str> operator_with_argtypes_list
     970             : %type <str> operator_with_argtypes
     971             : %type <str> DoStmt
     972             : %type <str> dostmt_opt_list
     973             : %type <str> dostmt_opt_item
     974             : %type <str> CreateCastStmt
     975             : %type <str> cast_context
     976             : %type <str> DropCastStmt
     977             : %type <str> opt_if_exists
     978             : %type <str> CreateTransformStmt
     979             : %type <str> transform_element_list
     980             : %type <str> DropTransformStmt
     981             : %type <str> ReindexStmt
     982             : %type <str> reindex_target_type
     983             : %type <str> reindex_target_multitable
     984             : %type <str> reindex_option_list
     985             : %type <str> reindex_option_elem
     986             : %type <str> AlterTblSpcStmt
     987             : %type <str> RenameStmt
     988             : %type <str> opt_column
     989             : %type <str> opt_set_data
     990             : %type <str> AlterObjectDependsStmt
     991             : %type <str> opt_no
     992             : %type <str> AlterObjectSchemaStmt
     993             : %type <str> AlterOperatorStmt
     994             : %type <str> operator_def_list
     995             : %type <str> operator_def_elem
     996             : %type <str> operator_def_arg
     997             : %type <str> AlterTypeStmt
     998             : %type <str> AlterOwnerStmt
     999             : %type <str> CreatePublicationStmt
    1000             : %type <str> opt_publication_for_tables
    1001             : %type <str> publication_for_tables
    1002             : %type <str> AlterPublicationStmt
    1003             : %type <str> CreateSubscriptionStmt
    1004             : %type <str> publication_name_list
    1005             : %type <str> publication_name_item
    1006             : %type <str> AlterSubscriptionStmt
    1007             : %type <str> DropSubscriptionStmt
    1008             : %type <str> RuleStmt
    1009             : %type <str> RuleActionList
    1010             : %type <str> RuleActionMulti
    1011             : %type <str> RuleActionStmt
    1012             : %type <str> RuleActionStmtOrEmpty
    1013             : %type <str> event
    1014             : %type <str> opt_instead
    1015             : %type <str> NotifyStmt
    1016             : %type <str> notify_payload
    1017             : %type <str> ListenStmt
    1018             : %type <str> UnlistenStmt
    1019             : %type <str> TransactionStmt
    1020             : %type <str> opt_transaction
    1021             : %type <str> transaction_mode_item
    1022             : %type <str> transaction_mode_list
    1023             : %type <str> transaction_mode_list_or_empty
    1024             : %type <str> opt_transaction_chain
    1025             : %type <str> ViewStmt
    1026             : %type <str> opt_check_option
    1027             : %type <str> LoadStmt
    1028             : %type <str> CreatedbStmt
    1029             : %type <str> createdb_opt_list
    1030             : %type <str> createdb_opt_items
    1031             : %type <str> createdb_opt_item
    1032             : %type <str> createdb_opt_name
    1033             : %type <str> opt_equal
    1034             : %type <str> AlterDatabaseStmt
    1035             : %type <str> AlterDatabaseSetStmt
    1036             : %type <str> DropdbStmt
    1037             : %type <str> drop_option_list
    1038             : %type <str> drop_option
    1039             : %type <str> AlterSystemStmt
    1040             : %type <str> CreateDomainStmt
    1041             : %type <str> AlterDomainStmt
    1042             : %type <str> opt_as
    1043             : %type <str> AlterTSDictionaryStmt
    1044             : %type <str> AlterTSConfigurationStmt
    1045             : %type <str> any_with
    1046             : %type <str> CreateConversionStmt
    1047             : %type <str> ClusterStmt
    1048             : %type <str> cluster_index_specification
    1049             : %type <str> VacuumStmt
    1050             : %type <str> AnalyzeStmt
    1051             : %type <str> vac_analyze_option_list
    1052             : %type <str> analyze_keyword
    1053             : %type <str> vac_analyze_option_elem
    1054             : %type <str> vac_analyze_option_name
    1055             : %type <str> vac_analyze_option_arg
    1056             : %type <str> opt_analyze
    1057             : %type <str> opt_verbose
    1058             : %type <str> opt_full
    1059             : %type <str> opt_freeze
    1060             : %type <str> opt_name_list
    1061             : %type <str> vacuum_relation
    1062             : %type <str> vacuum_relation_list
    1063             : %type <str> opt_vacuum_relation_list
    1064             : %type <str> ExplainStmt
    1065             : %type <str> ExplainableStmt
    1066             : %type <str> explain_option_list
    1067             : %type <str> explain_option_elem
    1068             : %type <str> explain_option_name
    1069             : %type <str> explain_option_arg
    1070             : %type <prep> PrepareStmt
    1071             : %type <str> prep_type_clause
    1072             : %type <str> PreparableStmt
    1073             : %type <exec> ExecuteStmt
    1074             : %type <str> execute_param_clause
    1075             : %type <str> InsertStmt
    1076             : %type <str> insert_target
    1077             : %type <str> insert_rest
    1078             : %type <str> override_kind
    1079             : %type <str> insert_column_list
    1080             : %type <str> insert_column_item
    1081             : %type <str> opt_on_conflict
    1082             : %type <str> opt_conf_expr
    1083             : %type <str> returning_clause
    1084             : %type <str> DeleteStmt
    1085             : %type <str> using_clause
    1086             : %type <str> LockStmt
    1087             : %type <str> opt_lock
    1088             : %type <str> lock_type
    1089             : %type <str> opt_nowait
    1090             : %type <str> opt_nowait_or_skip
    1091             : %type <str> UpdateStmt
    1092             : %type <str> set_clause_list
    1093             : %type <str> set_clause
    1094             : %type <str> set_target
    1095             : %type <str> set_target_list
    1096             : %type <str> DeclareCursorStmt
    1097             : %type <str> cursor_name
    1098             : %type <str> cursor_options
    1099             : %type <str> opt_hold
    1100             : %type <str> SelectStmt
    1101             : %type <str> select_with_parens
    1102             : %type <str> select_no_parens
    1103             : %type <str> select_clause
    1104             : %type <str> simple_select
    1105             : %type <str> with_clause
    1106             : %type <str> cte_list
    1107             : %type <str> common_table_expr
    1108             : %type <str> opt_materialized
    1109             : %type <str> opt_with_clause
    1110             : %type <str> into_clause
    1111             : %type <str> OptTempTableName
    1112             : %type <str> opt_table
    1113             : %type <str> all_or_distinct
    1114             : %type <str> distinct_clause
    1115             : %type <str> opt_all_clause
    1116             : %type <str> opt_sort_clause
    1117             : %type <str> sort_clause
    1118             : %type <str> sortby_list
    1119             : %type <str> sortby
    1120             : %type <str> select_limit
    1121             : %type <str> opt_select_limit
    1122             : %type <str> limit_clause
    1123             : %type <str> offset_clause
    1124             : %type <str> select_limit_value
    1125             : %type <str> select_offset_value
    1126             : %type <str> select_fetch_first_value
    1127             : %type <str> I_or_F_const
    1128             : %type <str> row_or_rows
    1129             : %type <str> first_or_next
    1130             : %type <str> group_clause
    1131             : %type <str> group_by_list
    1132             : %type <str> group_by_item
    1133             : %type <str> empty_grouping_set
    1134             : %type <str> rollup_clause
    1135             : %type <str> cube_clause
    1136             : %type <str> grouping_sets_clause
    1137             : %type <str> having_clause
    1138             : %type <str> for_locking_clause
    1139             : %type <str> opt_for_locking_clause
    1140             : %type <str> for_locking_items
    1141             : %type <str> for_locking_item
    1142             : %type <str> for_locking_strength
    1143             : %type <str> locked_rels_list
    1144             : %type <str> values_clause
    1145             : %type <str> from_clause
    1146             : %type <str> from_list
    1147             : %type <str> table_ref
    1148             : %type <str> joined_table
    1149             : %type <str> alias_clause
    1150             : %type <str> opt_alias_clause
    1151             : %type <str> func_alias_clause
    1152             : %type <str> join_type
    1153             : %type <str> opt_outer
    1154             : %type <str> join_qual
    1155             : %type <str> relation_expr
    1156             : %type <str> relation_expr_list
    1157             : %type <str> relation_expr_opt_alias
    1158             : %type <str> tablesample_clause
    1159             : %type <str> opt_repeatable_clause
    1160             : %type <str> func_table
    1161             : %type <str> rowsfrom_item
    1162             : %type <str> rowsfrom_list
    1163             : %type <str> opt_col_def_list
    1164             : %type <str> opt_ordinality
    1165             : %type <str> where_clause
    1166             : %type <str> where_or_current_clause
    1167             : %type <str> OptTableFuncElementList
    1168             : %type <str> TableFuncElementList
    1169             : %type <str> TableFuncElement
    1170             : %type <str> xmltable
    1171             : %type <str> xmltable_column_list
    1172             : %type <str> xmltable_column_el
    1173             : %type <str> xmltable_column_option_list
    1174             : %type <str> xmltable_column_option_el
    1175             : %type <str> xml_namespace_list
    1176             : %type <str> xml_namespace_el
    1177             : %type <str> Typename
    1178             : %type <index> opt_array_bounds
    1179             : %type <str> SimpleTypename
    1180             : %type <str> ConstTypename
    1181             : %type <str> GenericType
    1182             : %type <str> opt_type_modifiers
    1183             : %type <str> Numeric
    1184             : %type <str> opt_float
    1185             : %type <str> Bit
    1186             : %type <str> ConstBit
    1187             : %type <str> BitWithLength
    1188             : %type <str> BitWithoutLength
    1189             : %type <str> Character
    1190             : %type <str> ConstCharacter
    1191             : %type <str> CharacterWithLength
    1192             : %type <str> CharacterWithoutLength
    1193             : %type <str> character
    1194             : %type <str> opt_varying
    1195             : %type <str> ConstDatetime
    1196             : %type <str> ConstInterval
    1197             : %type <str> opt_timezone
    1198             : %type <str> opt_interval
    1199             : %type <str> interval_second
    1200             : %type <str> a_expr
    1201             : %type <str> b_expr
    1202             : %type <str> c_expr
    1203             : %type <str> func_application
    1204             : %type <str> func_expr
    1205             : %type <str> func_expr_windowless
    1206             : %type <str> func_expr_common_subexpr
    1207             : %type <str> xml_root_version
    1208             : %type <str> opt_xml_root_standalone
    1209             : %type <str> xml_attributes
    1210             : %type <str> xml_attribute_list
    1211             : %type <str> xml_attribute_el
    1212             : %type <str> document_or_content
    1213             : %type <str> xml_whitespace_option
    1214             : %type <str> xmlexists_argument
    1215             : %type <str> xml_passing_mech
    1216             : %type <str> within_group_clause
    1217             : %type <str> filter_clause
    1218             : %type <str> window_clause
    1219             : %type <str> window_definition_list
    1220             : %type <str> window_definition
    1221             : %type <str> over_clause
    1222             : %type <str> window_specification
    1223             : %type <str> opt_existing_window_name
    1224             : %type <str> opt_partition_clause
    1225             : %type <str> opt_frame_clause
    1226             : %type <str> frame_extent
    1227             : %type <str> frame_bound
    1228             : %type <str> opt_window_exclusion_clause
    1229             : %type <str> row
    1230             : %type <str> explicit_row
    1231             : %type <str> implicit_row
    1232             : %type <str> sub_type
    1233             : %type <str> all_Op
    1234             : %type <str> MathOp
    1235             : %type <str> qual_Op
    1236             : %type <str> qual_all_Op
    1237             : %type <str> subquery_Op
    1238             : %type <str> expr_list
    1239             : %type <str> func_arg_list
    1240             : %type <str> func_arg_expr
    1241             : %type <str> func_arg_list_opt
    1242             : %type <str> type_list
    1243             : %type <str> array_expr
    1244             : %type <str> array_expr_list
    1245             : %type <str> extract_list
    1246             : %type <str> extract_arg
    1247             : %type <str> unicode_normal_form
    1248             : %type <str> overlay_list
    1249             : %type <str> position_list
    1250             : %type <str> substr_list
    1251             : %type <str> trim_list
    1252             : %type <str> in_expr
    1253             : %type <str> case_expr
    1254             : %type <str> when_clause_list
    1255             : %type <str> when_clause
    1256             : %type <str> case_default
    1257             : %type <str> case_arg
    1258             : %type <str> columnref
    1259             : %type <str> indirection_el
    1260             : %type <str> opt_slice_bound
    1261             : %type <str> indirection
    1262             : %type <str> opt_indirection
    1263             : %type <str> opt_asymmetric
    1264             : %type <str> opt_target_list
    1265             : %type <str> target_list
    1266             : %type <str> target_el
    1267             : %type <str> qualified_name_list
    1268             : %type <str> qualified_name
    1269             : %type <str> name_list
    1270             : %type <str> name
    1271             : %type <str> attr_name
    1272             : %type <str> file_name
    1273             : %type <str> func_name
    1274             : %type <str> AexprConst
    1275             : %type <str> Iconst
    1276             : %type <str> SignedIconst
    1277             : %type <str> RoleId
    1278             : %type <str> RoleSpec
    1279             : %type <str> role_list
    1280             : %type <str> NonReservedWord
    1281             : %type <str> BareColLabel
    1282             : %type <str> unreserved_keyword
    1283             : %type <str> col_name_keyword
    1284             : %type <str> type_func_name_keyword
    1285             : %type <str> reserved_keyword
    1286             : %type <str> bare_label_keyword
    1287             : /* ecpgtype */
    1288             : /* src/interfaces/ecpg/preproc/ecpg.type */
    1289             : %type <str> ECPGAllocateDescr
    1290             : %type <str> ECPGCKeywords
    1291             : %type <str> ECPGColId
    1292             : %type <str> ECPGColLabel
    1293             : %type <str> ECPGColLabelCommon
    1294             : %type <str> ECPGConnect
    1295             : %type <str> ECPGCursorStmt
    1296             : %type <str> ECPGDeallocateDescr
    1297             : %type <str> ECPGDeclaration
    1298             : %type <str> ECPGDeclare
    1299             : %type <str> ECPGDescribe
    1300             : %type <str> ECPGDisconnect
    1301             : %type <str> ECPGExecuteImmediateStmt
    1302             : %type <str> ECPGFree
    1303             : %type <str> ECPGGetDescHeaderItem
    1304             : %type <str> ECPGGetDescItem
    1305             : %type <str> ECPGGetDescriptorHeader
    1306             : %type <str> ECPGKeywords
    1307             : %type <str> ECPGKeywords_rest
    1308             : %type <str> ECPGKeywords_vanames
    1309             : %type <str> ECPGOpen
    1310             : %type <str> ECPGSetAutocommit
    1311             : %type <str> ECPGSetConnection
    1312             : %type <str> ECPGSetDescHeaderItem
    1313             : %type <str> ECPGSetDescItem
    1314             : %type <str> ECPGSetDescriptorHeader
    1315             : %type <str> ECPGTypeName
    1316             : %type <str> ECPGTypedef
    1317             : %type <str> ECPGVar
    1318             : %type <str> ECPGVarDeclaration
    1319             : %type <str> ECPGWhenever
    1320             : %type <str> ECPGunreserved_interval
    1321             : %type <str> UsingConst
    1322             : %type <str> UsingValue
    1323             : %type <str> all_unreserved_keyword
    1324             : %type <str> c_anything
    1325             : %type <str> c_args
    1326             : %type <str> c_list
    1327             : %type <str> c_stuff
    1328             : %type <str> c_stuff_item
    1329             : %type <str> c_term
    1330             : %type <str> c_thing
    1331             : %type <str> char_variable
    1332             : %type <str> char_civar
    1333             : %type <str> civar
    1334             : %type <str> civarind
    1335             : %type <str> ColId
    1336             : %type <str> ColLabel
    1337             : %type <str> connect_options
    1338             : %type <str> connection_object
    1339             : %type <str> connection_target
    1340             : %type <str> coutputvariable
    1341             : %type <str> cvariable
    1342             : %type <str> db_prefix
    1343             : %type <str> CreateAsStmt
    1344             : %type <str> DeallocateStmt
    1345             : %type <str> dis_name
    1346             : %type <str> ecpg_bconst
    1347             : %type <str> ecpg_fconst
    1348             : %type <str> ecpg_ident
    1349             : %type <str> ecpg_interval
    1350             : %type <str> ecpg_into
    1351             : %type <str> ecpg_fetch_into
    1352             : %type <str> ecpg_param
    1353             : %type <str> ecpg_sconst
    1354             : %type <str> ecpg_using
    1355             : %type <str> ecpg_xconst
    1356             : %type <str> enum_definition
    1357             : %type <str> enum_type
    1358             : %type <str> execstring
    1359             : %type <str> execute_rest
    1360             : %type <str> indicator
    1361             : %type <str> into_descriptor
    1362             : %type <str> into_sqlda
    1363             : %type <str> Iresult
    1364             : %type <str> on_off
    1365             : %type <str> opt_bit_field
    1366             : %type <str> opt_connection_name
    1367             : %type <str> opt_database_name
    1368             : %type <str> opt_ecpg_into
    1369             : %type <str> opt_ecpg_fetch_into
    1370             : %type <str> opt_ecpg_using
    1371             : %type <str> opt_initializer
    1372             : %type <str> opt_options
    1373             : %type <str> opt_output
    1374             : %type <str> opt_pointer
    1375             : %type <str> opt_port
    1376             : %type <str> opt_reference
    1377             : %type <str> opt_scale
    1378             : %type <str> opt_server
    1379             : %type <str> opt_user
    1380             : %type <str> opt_opt_value
    1381             : %type <str> ora_user
    1382             : %type <str> precision
    1383             : %type <str> prepared_name
    1384             : %type <str> quoted_ident_stringvar
    1385             : %type <str> s_struct_union
    1386             : %type <str> server
    1387             : %type <str> server_name
    1388             : %type <str> single_vt_declaration
    1389             : %type <str> storage_clause
    1390             : %type <str> storage_declaration
    1391             : %type <str> storage_modifier
    1392             : %type <str> struct_union_type
    1393             : %type <str> struct_union_type_with_symbol
    1394             : %type <str> symbol
    1395             : %type <str> type_declaration
    1396             : %type <str> type_function_name
    1397             : %type <str> user_name
    1398             : %type <str> using_descriptor
    1399             : %type <str> var_declaration
    1400             : %type <str> var_type_declarations
    1401             : %type <str> variable
    1402             : %type <str> variable_declarations
    1403             : %type <str> variable_list
    1404             : %type <str> vt_declarations
    1405             : 
    1406             : %type <str> Op
    1407             : %type <str> IntConstVar
    1408             : %type <str> AllConstVar
    1409             : %type <str> CSTRING
    1410             : %type <str> CPP_LINE
    1411             : %type <str> CVARIABLE
    1412             : %type <str> BCONST
    1413             : %type <str> SCONST
    1414             : %type <str> XCONST
    1415             : %type <str> IDENT
    1416             : 
    1417             : %type  <struct_union> s_struct_union_symbol
    1418             : 
    1419             : %type  <descriptor> ECPGGetDescriptor
    1420             : %type  <descriptor> ECPGSetDescriptor
    1421             : 
    1422             : %type  <type_enum> simple_type
    1423             : %type  <type_enum> signed_type
    1424             : %type  <type_enum> unsigned_type
    1425             : 
    1426             : %type  <dtype_enum> descriptor_item
    1427             : %type  <dtype_enum> desc_header_item
    1428             : 
    1429             : %type  <type>   var_type
    1430             : 
    1431             : %type  <action> action
    1432             : /* orig_tokens */
    1433             :  %token IDENT UIDENT FCONST SCONST USCONST BCONST XCONST Op
    1434             :  %token ICONST PARAM
    1435             :  %token TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER
    1436             :  %token LESS_EQUALS GREATER_EQUALS NOT_EQUALS
    1437             : 
    1438             : 
    1439             : 
    1440             : 
    1441             : 
    1442             : 
    1443             : 
    1444             : 
    1445             : 
    1446             :  %token ABORT_P ABSOLUTE_P ACCESS ACTION ADD_P ADMIN AFTER
    1447             :  AGGREGATE ALL ALSO ALTER ALWAYS ANALYSE ANALYZE AND ANY ARRAY AS ASC
    1448             :  ASSERTION ASSIGNMENT ASYMMETRIC AT ATTACH ATTRIBUTE AUTHORIZATION
    1449             : 
    1450             :  BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
    1451             :  BOOLEAN_P BOTH BY
    1452             : 
    1453             :  CACHE CALL CALLED CASCADE CASCADED CASE CAST CATALOG_P CHAIN CHAR_P
    1454             :  CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
    1455             :  CLUSTER COALESCE COLLATE COLLATION COLUMN COLUMNS COMMENT COMMENTS COMMIT
    1456             :  COMMITTED CONCURRENTLY CONFIGURATION CONFLICT CONNECTION CONSTRAINT
    1457             :  CONSTRAINTS CONTENT_P CONTINUE_P CONVERSION_P COPY COST CREATE
    1458             :  CROSS CSV CUBE CURRENT_P
    1459             :  CURRENT_CATALOG CURRENT_DATE CURRENT_ROLE CURRENT_SCHEMA
    1460             :  CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
    1461             : 
    1462             :  DATA_P DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
    1463             :  DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS DEPENDS DESC
    1464             :  DETACH DICTIONARY DISABLE_P DISCARD DISTINCT DO DOCUMENT_P DOMAIN_P
    1465             :  DOUBLE_P DROP
    1466             : 
    1467             :  EACH ELSE ENABLE_P ENCODING ENCRYPTED END_P ENUM_P ESCAPE EVENT EXCEPT
    1468             :  EXCLUDE EXCLUDING EXCLUSIVE EXECUTE EXISTS EXPLAIN EXPRESSION
    1469             :  EXTENSION EXTERNAL EXTRACT
    1470             : 
    1471             :  FALSE_P FAMILY FETCH FILTER FIRST_P FLOAT_P FOLLOWING FOR
    1472             :  FORCE FOREIGN FORWARD FREEZE FROM FULL FUNCTION FUNCTIONS
    1473             : 
    1474             :  GENERATED GLOBAL GRANT GRANTED GREATEST GROUP_P GROUPING GROUPS
    1475             : 
    1476             :  HANDLER HAVING HEADER_P HOLD HOUR_P
    1477             : 
    1478             :  IDENTITY_P IF_P ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IMPORT_P IN_P INCLUDE
    1479             :  INCLUDING INCREMENT INDEX INDEXES INHERIT INHERITS INITIALLY INLINE_P
    1480             :  INNER_P INOUT INPUT_P INSENSITIVE INSERT INSTEAD INT_P INTEGER
    1481             :  INTERSECT INTERVAL INTO INVOKER IS ISNULL ISOLATION
    1482             : 
    1483             :  JOIN
    1484             : 
    1485             :  KEY
    1486             : 
    1487             :  LABEL LANGUAGE LARGE_P LAST_P LATERAL_P
    1488             :  LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL
    1489             :  LOCALTIME LOCALTIMESTAMP LOCATION LOCK_P LOCKED LOGGED
    1490             : 
    1491             :  MAPPING MATCH MATERIALIZED MAXVALUE METHOD MINUTE_P MINVALUE MODE MONTH_P MOVE
    1492             : 
    1493             :  NAME_P NAMES NATIONAL NATURAL NCHAR NEW NEXT NFC NFD NFKC NFKD NO NONE
    1494             :  NORMALIZE NORMALIZED
    1495             :  NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF
    1496             :  NULLS_P NUMERIC
    1497             : 
    1498             :  OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OPTIONS OR
    1499             :  ORDER ORDINALITY OTHERS OUT_P OUTER_P
    1500             :  OVER OVERLAPS OVERLAY OVERRIDING OWNED OWNER
    1501             : 
    1502             :  PARALLEL PARSER PARTIAL PARTITION PASSING PASSWORD PLACING PLANS POLICY
    1503             :  POSITION PRECEDING PRECISION PRESERVE PREPARE PREPARED PRIMARY
    1504             :  PRIOR PRIVILEGES PROCEDURAL PROCEDURE PROCEDURES PROGRAM PUBLICATION
    1505             : 
    1506             :  QUOTE
    1507             : 
    1508             :  RANGE READ REAL REASSIGN RECHECK RECURSIVE REF REFERENCES REFERENCING
    1509             :  REFRESH REINDEX RELATIVE_P RELEASE RENAME REPEATABLE REPLACE REPLICA
    1510             :  RESET RESTART RESTRICT RETURNING RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
    1511             :  ROUTINE ROUTINES ROW ROWS RULE
    1512             : 
    1513             :  SAVEPOINT SCHEMA SCHEMAS SCROLL SEARCH SECOND_P SECURITY SELECT SEQUENCE SEQUENCES
    1514             :  SERIALIZABLE SERVER SESSION SESSION_USER SET SETS SETOF SHARE SHOW
    1515             :  SIMILAR SIMPLE SKIP SMALLINT SNAPSHOT SOME SQL_P STABLE STANDALONE_P
    1516             :  START STATEMENT STATISTICS STDIN STDOUT STORAGE STORED STRICT_P STRIP_P
    1517             :  SUBSCRIPTION SUBSTRING SUPPORT SYMMETRIC SYSID SYSTEM_P
    1518             : 
    1519             :  TABLE TABLES TABLESAMPLE TABLESPACE TEMP TEMPLATE TEMPORARY TEXT_P THEN
    1520             :  TIES TIME TIMESTAMP TO TRAILING TRANSACTION TRANSFORM
    1521             :  TREAT TRIGGER TRIM TRUE_P
    1522             :  TRUNCATE TRUSTED TYPE_P TYPES_P
    1523             : 
    1524             :  UESCAPE UNBOUNDED UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN
    1525             :  UNLISTEN UNLOGGED UNTIL UPDATE USER USING
    1526             : 
    1527             :  VACUUM VALID VALIDATE VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
    1528             :  VERBOSE VERSION_P VIEW VIEWS VOLATILE
    1529             : 
    1530             :  WHEN WHERE WHITESPACE_P WINDOW WITH WITHIN WITHOUT WORK WRAPPER WRITE
    1531             : 
    1532             :  XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLEXISTS XMLFOREST XMLNAMESPACES
    1533             :  XMLPARSE XMLPI XMLROOT XMLSERIALIZE XMLTABLE
    1534             : 
    1535             :  YEAR_P YES_P
    1536             : 
    1537             :  ZONE
    1538             : 
    1539             : 
    1540             : 
    1541             : 
    1542             : 
    1543             : 
    1544             : 
    1545             : 
    1546             : 
    1547             : 
    1548             : 
    1549             :  %token NOT_LA NULLS_LA WITH_LA
    1550             : 
    1551             : 
    1552             : 
    1553             :  %nonassoc SET
    1554             :  %left UNION EXCEPT
    1555             :  %left INTERSECT
    1556             :  %left OR
    1557             :  %left AND
    1558             :  %right NOT
    1559             :  %nonassoc IS ISNULL NOTNULL
    1560             :  %nonassoc '<' '>' '=' LESS_EQUALS GREATER_EQUALS NOT_EQUALS
    1561             :  %nonassoc BETWEEN IN_P LIKE ILIKE SIMILAR NOT_LA
    1562             :  %nonassoc ESCAPE
    1563             : 
    1564             : 
    1565             : 
    1566             : 
    1567             : 
    1568             : 
    1569             : 
    1570             : 
    1571             : 
    1572             : 
    1573             : 
    1574             : 
    1575             : 
    1576             : 
    1577             : 
    1578             : 
    1579             : 
    1580             : 
    1581             : 
    1582             : 
    1583             : 
    1584             : 
    1585             : 
    1586             : 
    1587             : 
    1588             :  %nonassoc UNBOUNDED
    1589             :  %nonassoc IDENT
    1590             : %nonassoc CSTRING PARTITION RANGE ROWS GROUPS PRECEDING FOLLOWING CUBE ROLLUP
    1591             :  %left Op OPERATOR
    1592             :  %left '+' '-'
    1593             :  %left '*' '/' '%'
    1594             :  %left '^'
    1595             : 
    1596             :  %left AT
    1597             :  %left COLLATE
    1598             :  %right UMINUS
    1599             :  %left '[' ']'
    1600             :  %left '(' ')'
    1601             :  %left TYPECAST
    1602             :  %left '.'
    1603             : 
    1604             : 
    1605             : 
    1606             : 
    1607             : 
    1608             : 
    1609             : 
    1610             :  %left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
    1611             : 
    1612             : %%
    1613             : prog: statements;
    1614             : /* rules */
    1615             :  stmt:
    1616             :  AlterEventTrigStmt
    1617           0 :  { output_statement($1, 0, ECPGst_normal); }
    1618             : |  AlterDatabaseStmt
    1619           0 :  { output_statement($1, 0, ECPGst_normal); }
    1620             : |  AlterDatabaseSetStmt
    1621           0 :  { output_statement($1, 0, ECPGst_normal); }
    1622             : |  AlterDefaultPrivilegesStmt
    1623           0 :  { output_statement($1, 0, ECPGst_normal); }
    1624             : |  AlterDomainStmt
    1625           0 :  { output_statement($1, 0, ECPGst_normal); }
    1626             : |  AlterEnumStmt
    1627           0 :  { output_statement($1, 0, ECPGst_normal); }
    1628             : |  AlterExtensionStmt
    1629           0 :  { output_statement($1, 0, ECPGst_normal); }
    1630             : |  AlterExtensionContentsStmt
    1631           0 :  { output_statement($1, 0, ECPGst_normal); }
    1632             : |  AlterFdwStmt
    1633           0 :  { output_statement($1, 0, ECPGst_normal); }
    1634             : |  AlterForeignServerStmt
    1635           0 :  { output_statement($1, 0, ECPGst_normal); }
    1636             : |  AlterFunctionStmt
    1637           0 :  { output_statement($1, 0, ECPGst_normal); }
    1638             : |  AlterGroupStmt
    1639           0 :  { output_statement($1, 0, ECPGst_normal); }
    1640             : |  AlterObjectDependsStmt
    1641           0 :  { output_statement($1, 0, ECPGst_normal); }
    1642             : |  AlterObjectSchemaStmt
    1643           0 :  { output_statement($1, 0, ECPGst_normal); }
    1644             : |  AlterOwnerStmt
    1645           0 :  { output_statement($1, 0, ECPGst_normal); }
    1646             : |  AlterOperatorStmt
    1647           0 :  { output_statement($1, 0, ECPGst_normal); }
    1648             : |  AlterTypeStmt
    1649           0 :  { output_statement($1, 0, ECPGst_normal); }
    1650             : |  AlterPolicyStmt
    1651           0 :  { output_statement($1, 0, ECPGst_normal); }
    1652             : |  AlterSeqStmt
    1653           0 :  { output_statement($1, 0, ECPGst_normal); }
    1654             : |  AlterSystemStmt
    1655           0 :  { output_statement($1, 0, ECPGst_normal); }
    1656             : |  AlterTableStmt
    1657           4 :  { output_statement($1, 0, ECPGst_normal); }
    1658             : |  AlterTblSpcStmt
    1659           0 :  { output_statement($1, 0, ECPGst_normal); }
    1660             : |  AlterCompositeTypeStmt
    1661           0 :  { output_statement($1, 0, ECPGst_normal); }
    1662             : |  AlterPublicationStmt
    1663           0 :  { output_statement($1, 0, ECPGst_normal); }
    1664             : |  AlterRoleSetStmt
    1665           0 :  { output_statement($1, 0, ECPGst_normal); }
    1666             : |  AlterRoleStmt
    1667           6 :  { output_statement($1, 0, ECPGst_normal); }
    1668             : |  AlterSubscriptionStmt
    1669           0 :  { output_statement($1, 0, ECPGst_normal); }
    1670             : |  AlterStatsStmt
    1671           0 :  { output_statement($1, 0, ECPGst_normal); }
    1672             : |  AlterTSConfigurationStmt
    1673           0 :  { output_statement($1, 0, ECPGst_normal); }
    1674             : |  AlterTSDictionaryStmt
    1675           0 :  { output_statement($1, 0, ECPGst_normal); }
    1676             : |  AlterUserMappingStmt
    1677           0 :  { output_statement($1, 0, ECPGst_normal); }
    1678             : |  AnalyzeStmt
    1679           0 :  { output_statement($1, 0, ECPGst_normal); }
    1680             : |  CallStmt
    1681           0 :  { output_statement($1, 0, ECPGst_normal); }
    1682             : |  CheckPointStmt
    1683           0 :  { output_statement($1, 0, ECPGst_normal); }
    1684             : |  ClosePortalStmt
    1685             :     {
    1686          66 :         if (INFORMIX_MODE)
    1687             :         {
    1688           8 :             if (pg_strcasecmp($1+strlen("close "), "database") == 0)
    1689             :             {
    1690           4 :                 if (connection)
    1691           0 :                     mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CLOSE DATABASE statement");
    1692             : 
    1693           4 :                 fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, \"CURRENT\");");
    1694           4 :                 whenever_action(2);
    1695           4 :                 free($1);
    1696           4 :                 break;
    1697             :             }
    1698             :         }
    1699             : 
    1700          62 :         output_statement($1, 0, ECPGst_normal);
    1701             :     }
    1702             : |  ClusterStmt
    1703           0 :  { output_statement($1, 0, ECPGst_normal); }
    1704             : |  CommentStmt
    1705           0 :  { output_statement($1, 0, ECPGst_normal); }
    1706             : |  ConstraintsSetStmt
    1707           0 :  { output_statement($1, 0, ECPGst_normal); }
    1708             : |  CopyStmt
    1709           2 :  { output_statement($1, 0, ECPGst_normal); }
    1710             : |  CreateAmStmt
    1711           0 :  { output_statement($1, 0, ECPGst_normal); }
    1712             : |  CreateAsStmt
    1713           4 :  { output_statement($1, 0, ECPGst_normal); }
    1714             : |  CreateAssertionStmt
    1715           0 :  { output_statement($1, 0, ECPGst_normal); }
    1716             : |  CreateCastStmt
    1717           0 :  { output_statement($1, 0, ECPGst_normal); }
    1718             : |  CreateConversionStmt
    1719           0 :  { output_statement($1, 0, ECPGst_normal); }
    1720             : |  CreateDomainStmt
    1721           0 :  { output_statement($1, 0, ECPGst_normal); }
    1722             : |  CreateExtensionStmt
    1723           0 :  { output_statement($1, 0, ECPGst_normal); }
    1724             : |  CreateFdwStmt
    1725           0 :  { output_statement($1, 0, ECPGst_normal); }
    1726             : |  CreateForeignServerStmt
    1727           0 :  { output_statement($1, 0, ECPGst_normal); }
    1728             : |  CreateForeignTableStmt
    1729           0 :  { output_statement($1, 0, ECPGst_normal); }
    1730             : |  CreateFunctionStmt
    1731           2 :  { output_statement($1, 0, ECPGst_normal); }
    1732             : |  CreateGroupStmt
    1733           0 :  { output_statement($1, 0, ECPGst_normal); }
    1734             : |  CreateMatViewStmt
    1735           0 :  { output_statement($1, 0, ECPGst_normal); }
    1736             : |  CreateOpClassStmt
    1737           0 :  { output_statement($1, 0, ECPGst_normal); }
    1738             : |  CreateOpFamilyStmt
    1739           0 :  { output_statement($1, 0, ECPGst_normal); }
    1740             : |  CreatePublicationStmt
    1741           0 :  { output_statement($1, 0, ECPGst_normal); }
    1742             : |  AlterOpFamilyStmt
    1743           0 :  { output_statement($1, 0, ECPGst_normal); }
    1744             : |  CreatePolicyStmt
    1745           0 :  { output_statement($1, 0, ECPGst_normal); }
    1746             : |  CreatePLangStmt
    1747           0 :  { output_statement($1, 0, ECPGst_normal); }
    1748             : |  CreateSchemaStmt
    1749           0 :  { output_statement($1, 0, ECPGst_normal); }
    1750             : |  CreateSeqStmt
    1751           0 :  { output_statement($1, 0, ECPGst_normal); }
    1752             : |  CreateStmt
    1753          96 :  { output_statement($1, 0, ECPGst_normal); }
    1754             : |  CreateSubscriptionStmt
    1755           0 :  { output_statement($1, 0, ECPGst_normal); }
    1756             : |  CreateStatsStmt
    1757           0 :  { output_statement($1, 0, ECPGst_normal); }
    1758             : |  CreateTableSpaceStmt
    1759           0 :  { output_statement($1, 0, ECPGst_normal); }
    1760             : |  CreateTransformStmt
    1761           0 :  { output_statement($1, 0, ECPGst_normal); }
    1762             : |  CreateTrigStmt
    1763           2 :  { output_statement($1, 0, ECPGst_normal); }
    1764             : |  CreateEventTrigStmt
    1765           0 :  { output_statement($1, 0, ECPGst_normal); }
    1766             : |  CreateRoleStmt
    1767           0 :  { output_statement($1, 0, ECPGst_normal); }
    1768             : |  CreateUserStmt
    1769           0 :  { output_statement($1, 0, ECPGst_normal); }
    1770             : |  CreateUserMappingStmt
    1771           0 :  { output_statement($1, 0, ECPGst_normal); }
    1772             : |  CreatedbStmt
    1773           0 :  { output_statement($1, 0, ECPGst_normal); }
    1774             : |  DeallocateStmt
    1775             :     {
    1776          66 :         output_deallocate_prepare_statement($1);
    1777             :     }
    1778             : |  DeclareCursorStmt
    1779          34 :     { output_simple_statement($1, (strncmp($1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0); }
    1780             : |  DefineStmt
    1781           0 :  { output_statement($1, 0, ECPGst_normal); }
    1782             : |  DeleteStmt
    1783           4 :     { output_statement($1, 1, ECPGst_prepnormal); }
    1784             : |  DiscardStmt
    1785           0 :     { output_statement($1, 1, ECPGst_normal); }
    1786             : |  DoStmt
    1787           0 :  { output_statement($1, 0, ECPGst_normal); }
    1788             : |  DropCastStmt
    1789           0 :  { output_statement($1, 0, ECPGst_normal); }
    1790             : |  DropOpClassStmt
    1791           0 :  { output_statement($1, 0, ECPGst_normal); }
    1792             : |  DropOpFamilyStmt
    1793           0 :  { output_statement($1, 0, ECPGst_normal); }
    1794             : |  DropOwnedStmt
    1795           0 :  { output_statement($1, 0, ECPGst_normal); }
    1796             : |  DropStmt
    1797          72 :  { output_statement($1, 0, ECPGst_normal); }
    1798             : |  DropSubscriptionStmt
    1799           0 :  { output_statement($1, 0, ECPGst_normal); }
    1800             : |  DropTableSpaceStmt
    1801           0 :  { output_statement($1, 0, ECPGst_normal); }
    1802             : |  DropTransformStmt
    1803           0 :  { output_statement($1, 0, ECPGst_normal); }
    1804             : |  DropRoleStmt
    1805           0 :  { output_statement($1, 0, ECPGst_normal); }
    1806             : |  DropUserMappingStmt
    1807           0 :  { output_statement($1, 0, ECPGst_normal); }
    1808             : |  DropdbStmt
    1809           0 :  { output_statement($1, 0, ECPGst_normal); }
    1810             : |  ExecuteStmt
    1811             :     {
    1812          64 :         if ($1.type == NULL || strlen($1.type) == 0)
    1813          46 :             output_statement($1.name, 1, ECPGst_execute);
    1814             :         else
    1815             :         {
    1816          18 :             if ($1.name[0] != '"')
    1817             :                 /* case of char_variable */
    1818           8 :                 add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
    1819             :             else
    1820             :             {
    1821             :                 /* case of ecpg_ident or CSTRING */
    1822          10 :                 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
    1823          10 :                 char *str = mm_strdup($1.name + 1);
    1824             : 
    1825             :                 /* It must be cut off double quotation because new_variable() double-quotes. */
    1826          10 :                 str[strlen(str) - 1] = '\0';
    1827          10 :                 sprintf(length, "%zu", strlen(str));
    1828          10 :                 add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
    1829             :             }
    1830          18 :             output_statement(cat_str(3, mm_strdup("execute"), mm_strdup("$0"), $1.type), 0, ECPGst_exec_with_exprlist);
    1831             :         }
    1832             :     }
    1833             : |  ExplainStmt
    1834           0 :  { output_statement($1, 0, ECPGst_normal); }
    1835             : |  FetchStmt
    1836         116 :     { output_statement($1, 1, ECPGst_normal); }
    1837             : |  GrantStmt
    1838           0 :  { output_statement($1, 0, ECPGst_normal); }
    1839             : |  GrantRoleStmt
    1840           0 :  { output_statement($1, 0, ECPGst_normal); }
    1841             : |  ImportForeignSchemaStmt
    1842           0 :  { output_statement($1, 0, ECPGst_normal); }
    1843             : |  IndexStmt
    1844           0 :  { output_statement($1, 0, ECPGst_normal); }
    1845             : |  InsertStmt
    1846         216 :     { output_statement($1, 1, ECPGst_prepnormal); }
    1847             : |  ListenStmt
    1848           0 :  { output_statement($1, 0, ECPGst_normal); }
    1849             : |  RefreshMatViewStmt
    1850           0 :  { output_statement($1, 0, ECPGst_normal); }
    1851             : |  LoadStmt
    1852           0 :  { output_statement($1, 0, ECPGst_normal); }
    1853             : |  LockStmt
    1854           0 :  { output_statement($1, 0, ECPGst_normal); }
    1855             : |  NotifyStmt
    1856           0 :  { output_statement($1, 0, ECPGst_normal); }
    1857             : |  PrepareStmt
    1858             :     {
    1859          94 :         if ($1.type == NULL)
    1860          82 :             output_prepare_statement($1.name, $1.stmt);
    1861          12 :         else if (strlen($1.type) == 0)
    1862             :         {
    1863           2 :             char *stmt = cat_str(3, mm_strdup("\""), $1.stmt, mm_strdup("\""));
    1864           2 :             output_prepare_statement($1.name, stmt);
    1865             :         }
    1866             :         else
    1867             :         {
    1868          10 :             if ($1.name[0] != '"')
    1869             :                 /* case of char_variable */
    1870           4 :                 add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
    1871             :             else
    1872             :             {
    1873           6 :                 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
    1874           6 :                 char *str = mm_strdup($1.name + 1);
    1875             : 
    1876             :                 /* It must be cut off double quotation because new_variable() double-quotes. */
    1877           6 :                 str[strlen(str) - 1] = '\0';
    1878           6 :                 sprintf(length, "%zu", strlen(str));
    1879           6 :                 add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
    1880             :             }
    1881          10 :             output_statement(cat_str(5, mm_strdup("prepare"), mm_strdup("$0"), $1.type, mm_strdup("as"), $1.stmt), 0, ECPGst_prepare);
    1882             :         }
    1883             :     }
    1884             : |  ReassignOwnedStmt
    1885           0 :  { output_statement($1, 0, ECPGst_normal); }
    1886             : |  ReindexStmt
    1887           0 :  { output_statement($1, 0, ECPGst_normal); }
    1888             : |  RemoveAggrStmt
    1889           0 :  { output_statement($1, 0, ECPGst_normal); }
    1890             : |  RemoveFuncStmt
    1891           2 :  { output_statement($1, 0, ECPGst_normal); }
    1892             : |  RemoveOperStmt
    1893           0 :  { output_statement($1, 0, ECPGst_normal); }
    1894             : |  RenameStmt
    1895           0 :  { output_statement($1, 0, ECPGst_normal); }
    1896             : |  RevokeStmt
    1897           0 :  { output_statement($1, 0, ECPGst_normal); }
    1898             : |  RevokeRoleStmt
    1899           0 :  { output_statement($1, 0, ECPGst_normal); }
    1900             : |  RuleStmt
    1901           0 :  { output_statement($1, 0, ECPGst_normal); }
    1902             : |  SecLabelStmt
    1903           0 :  { output_statement($1, 0, ECPGst_normal); }
    1904             : |  SelectStmt
    1905         136 :     { output_statement($1, 1, ECPGst_prepnormal); }
    1906             : |  TransactionStmt
    1907             :     {
    1908         168 :         fprintf(base_yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", $1);
    1909         168 :         whenever_action(2);
    1910         168 :         free($1);
    1911             :     }
    1912             : |  TruncateStmt
    1913          44 :  { output_statement($1, 0, ECPGst_normal); }
    1914             : |  UnlistenStmt
    1915           0 :  { output_statement($1, 0, ECPGst_normal); }
    1916             : |  UpdateStmt
    1917          10 :     { output_statement($1, 1, ECPGst_prepnormal); }
    1918             : |  VacuumStmt
    1919           0 :  { output_statement($1, 0, ECPGst_normal); }
    1920             : |  VariableResetStmt
    1921           0 :  { output_statement($1, 0, ECPGst_normal); }
    1922             : |  VariableSetStmt
    1923          46 :  { output_statement($1, 0, ECPGst_normal); }
    1924             : |  VariableShowStmt
    1925          14 :  { output_statement($1, 0, ECPGst_normal); }
    1926             : |  ViewStmt
    1927           0 :  { output_statement($1, 0, ECPGst_normal); }
    1928             :     | ECPGAllocateDescr
    1929             :     {
    1930          32 :         fprintf(base_yyout,"ECPGallocate_desc(__LINE__, %s);",$1);
    1931          32 :         whenever_action(0);
    1932          32 :         free($1);
    1933             :     }
    1934             :     | ECPGConnect
    1935             :     {
    1936         180 :         if (connection)
    1937           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CONNECT statement");
    1938             : 
    1939         180 :         fprintf(base_yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, $1, autocommit);
    1940         180 :         reset_variables();
    1941         180 :         whenever_action(2);
    1942         180 :         free($1);
    1943             :     }
    1944             :     | ECPGCursorStmt
    1945             :     {
    1946          30 :          output_simple_statement($1, (strncmp($1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0);
    1947             :     }
    1948             :     | ECPGDeallocateDescr
    1949             :     {
    1950          28 :         fprintf(base_yyout,"ECPGdeallocate_desc(__LINE__, %s);",$1);
    1951          28 :         whenever_action(0);
    1952          28 :         free($1);
    1953             :     }
    1954             :     | ECPGDeclare
    1955             :     {
    1956           0 :         output_simple_statement($1, 0);
    1957             :     }
    1958             :     | ECPGDescribe
    1959             :     {
    1960          40 :         fprintf(base_yyout, "{ ECPGdescribe(__LINE__, %d, %s,", compat, $1);
    1961          40 :         dump_variables(argsresult, 1);
    1962          40 :         fputs("ECPGt_EORT);", base_yyout);
    1963          40 :         fprintf(base_yyout, "}");
    1964          40 :         output_line_number();
    1965             : 
    1966          40 :         free($1);
    1967             :     }
    1968             :     | ECPGDisconnect
    1969             :     {
    1970         168 :         if (connection)
    1971           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DISCONNECT statement");
    1972             : 
    1973         168 :         fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, %s);",
    1974         168 :                 $1 ? $1 : "\"CURRENT\"");
    1975         168 :         whenever_action(2);
    1976         168 :         free($1);
    1977             :     }
    1978          14 :     | ECPGExecuteImmediateStmt  { output_statement($1, 0, ECPGst_exec_immediate); }
    1979             :     | ECPGFree
    1980             :     {
    1981           2 :         const char *con = connection ? connection : "NULL";
    1982             : 
    1983           2 :         if (strcmp($1, "all") == 0)
    1984           0 :             fprintf(base_yyout, "{ ECPGdeallocate_all(__LINE__, %d, %s);", compat, con);
    1985           2 :         else if ($1[0] == ':')
    1986           0 :             fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, %s);", compat, con, $1+1);
    1987             :         else
    1988           2 :             fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, \"%s\");", compat, con, $1);
    1989             : 
    1990           2 :         whenever_action(2);
    1991           2 :         free($1);
    1992             :     }
    1993             :     | ECPGGetDescriptor
    1994             :     {
    1995          58 :         lookup_descriptor($1.name, connection);
    1996          58 :         output_get_descr($1.name, $1.str);
    1997          58 :         free($1.name);
    1998          58 :         free($1.str);
    1999             :     }
    2000             :     | ECPGGetDescriptorHeader
    2001             :     {
    2002          20 :         lookup_descriptor($1, connection);
    2003          20 :         output_get_descr_header($1);
    2004          20 :         free($1);
    2005             :     }
    2006             :     | ECPGOpen
    2007           0 :     {
    2008             :         struct cursor *ptr;
    2009             : 
    2010          66 :         if ((ptr = add_additional_variables($1, true)) != NULL)
    2011             :         {
    2012          66 :             connection = ptr->connection ? mm_strdup(ptr->connection) : NULL;
    2013          66 :             output_statement(mm_strdup(ptr->command), 0, ECPGst_normal);
    2014          66 :             ptr->opened = true;
    2015             :         }
    2016             :     }
    2017             :     | ECPGSetAutocommit
    2018             :     {
    2019          22 :         fprintf(base_yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", $1, connection ? connection : "NULL");
    2020          22 :         whenever_action(2);
    2021          22 :         free($1);
    2022             :     }
    2023             :     | ECPGSetConnection
    2024             :     {
    2025           4 :         if (connection)
    2026           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in SET CONNECTION statement");
    2027             : 
    2028           4 :         fprintf(base_yyout, "{ ECPGsetconn(__LINE__, %s);", $1);
    2029           4 :         whenever_action(2);
    2030           4 :         free($1);
    2031             :     }
    2032             :     | ECPGSetDescriptor
    2033             :     {
    2034          22 :         lookup_descriptor($1.name, connection);
    2035          22 :         output_set_descr($1.name, $1.str);
    2036          22 :         free($1.name);
    2037          22 :         free($1.str);
    2038             :     }
    2039             :     | ECPGSetDescriptorHeader
    2040             :     {
    2041           2 :         lookup_descriptor($1, connection);
    2042           2 :         output_set_descr_header($1);
    2043           2 :         free($1);
    2044             :     }
    2045             :     | ECPGTypedef
    2046             :     {
    2047          26 :         if (connection)
    2048           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in TYPE statement");
    2049             : 
    2050          26 :         fprintf(base_yyout, "%s", $1);
    2051          26 :         free($1);
    2052          26 :         output_line_number();
    2053             :     }
    2054             :     | ECPGVar
    2055             :     {
    2056           4 :         if (connection)
    2057           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in VAR statement");
    2058             : 
    2059           4 :         output_simple_statement($1, 0);
    2060             :     }
    2061             :     | ECPGWhenever
    2062             :     {
    2063         178 :         if (connection)
    2064           0 :             mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in WHENEVER statement");
    2065             : 
    2066         178 :         output_simple_statement($1, 0);
    2067             :     }
    2068             : | 
    2069           0 :  { $$ = NULL; }
    2070             : ;
    2071             : 
    2072             : 
    2073             :  CallStmt:
    2074             :  CALL func_application
    2075             :  { 
    2076           0 :  $$ = cat_str(2,mm_strdup("call"),$2);
    2077             : }
    2078             : ;
    2079             : 
    2080             : 
    2081             :  CreateRoleStmt:
    2082             :  CREATE ROLE RoleId opt_with OptRoleList
    2083             :  { 
    2084           0 :  $$ = cat_str(4,mm_strdup("create role"),$3,$4,$5);
    2085             : }
    2086             : ;
    2087             : 
    2088             : 
    2089             :  opt_with:
    2090             :  WITH
    2091             :  { 
    2092           2 :  $$ = mm_strdup("with");
    2093             : }
    2094             : |  WITH_LA
    2095             :  { 
    2096           0 :  $$ = mm_strdup("with");
    2097             : }
    2098             : | 
    2099             :  { 
    2100           6 :  $$=EMPTY; }
    2101             : ;
    2102             : 
    2103             : 
    2104             :  OptRoleList:
    2105             :  OptRoleList CreateOptRoleElem
    2106             :  { 
    2107           0 :  $$ = cat_str(2,$1,$2);
    2108             : }
    2109             : | 
    2110             :  { 
    2111           0 :  $$=EMPTY; }
    2112             : ;
    2113             : 
    2114             : 
    2115             :  AlterOptRoleList:
    2116             :  AlterOptRoleList AlterOptRoleElem
    2117             :  { 
    2118           6 :  $$ = cat_str(2,$1,$2);
    2119             : }
    2120             : | 
    2121             :  { 
    2122           6 :  $$=EMPTY; }
    2123             : ;
    2124             : 
    2125             : 
    2126             :  AlterOptRoleElem:
    2127             :  PASSWORD ecpg_sconst
    2128             :  { 
    2129           0 :  $$ = cat_str(2,mm_strdup("password"),$2);
    2130             : }
    2131             : |  PASSWORD NULL_P
    2132             :  { 
    2133           0 :  $$ = mm_strdup("password null");
    2134             : }
    2135             : |  ENCRYPTED PASSWORD ecpg_sconst
    2136             :  { 
    2137           6 :  $$ = cat_str(2,mm_strdup("encrypted password"),$3);
    2138             : }
    2139             : |  UNENCRYPTED PASSWORD ecpg_sconst
    2140             :  { 
    2141           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    2142           0 :  $$ = cat_str(2,mm_strdup("unencrypted password"),$3);
    2143             : }
    2144             : |  INHERIT
    2145             :  { 
    2146           0 :  $$ = mm_strdup("inherit");
    2147             : }
    2148             : |  CONNECTION LIMIT SignedIconst
    2149             :  { 
    2150           0 :  $$ = cat_str(2,mm_strdup("connection limit"),$3);
    2151             : }
    2152             : |  VALID UNTIL ecpg_sconst
    2153             :  { 
    2154           0 :  $$ = cat_str(2,mm_strdup("valid until"),$3);
    2155             : }
    2156             : |  USER role_list
    2157             :  { 
    2158           0 :  $$ = cat_str(2,mm_strdup("user"),$2);
    2159             : }
    2160             : |  ecpg_ident
    2161             :  { 
    2162           0 :  $$ = $1;
    2163             : }
    2164             : ;
    2165             : 
    2166             : 
    2167             :  CreateOptRoleElem:
    2168             :  AlterOptRoleElem
    2169             :  { 
    2170           0 :  $$ = $1;
    2171             : }
    2172             : |  SYSID Iconst
    2173             :  { 
    2174           0 :  $$ = cat_str(2,mm_strdup("sysid"),$2);
    2175             : }
    2176             : |  ADMIN role_list
    2177             :  { 
    2178           0 :  $$ = cat_str(2,mm_strdup("admin"),$2);
    2179             : }
    2180             : |  ROLE role_list
    2181             :  { 
    2182           0 :  $$ = cat_str(2,mm_strdup("role"),$2);
    2183             : }
    2184             : |  IN_P ROLE role_list
    2185             :  { 
    2186           0 :  $$ = cat_str(2,mm_strdup("in role"),$3);
    2187             : }
    2188             : |  IN_P GROUP_P role_list
    2189             :  { 
    2190           0 :  $$ = cat_str(2,mm_strdup("in group"),$3);
    2191             : }
    2192             : ;
    2193             : 
    2194             : 
    2195             :  CreateUserStmt:
    2196             :  CREATE USER RoleId opt_with OptRoleList
    2197             :  { 
    2198           0 :  $$ = cat_str(4,mm_strdup("create user"),$3,$4,$5);
    2199             : }
    2200             : ;
    2201             : 
    2202             : 
    2203             :  AlterRoleStmt:
    2204             :  ALTER ROLE RoleSpec opt_with AlterOptRoleList
    2205             :  { 
    2206           0 :  $$ = cat_str(4,mm_strdup("alter role"),$3,$4,$5);
    2207             : }
    2208             : |  ALTER USER RoleSpec opt_with AlterOptRoleList
    2209             :  { 
    2210           6 :  $$ = cat_str(4,mm_strdup("alter user"),$3,$4,$5);
    2211             : }
    2212             : ;
    2213             : 
    2214             : 
    2215             :  opt_in_database:
    2216             : 
    2217             :  { 
    2218           0 :  $$=EMPTY; }
    2219             : |  IN_P DATABASE name
    2220             :  { 
    2221           0 :  $$ = cat_str(2,mm_strdup("in database"),$3);
    2222             : }
    2223             : ;
    2224             : 
    2225             : 
    2226             :  AlterRoleSetStmt:
    2227             :  ALTER ROLE RoleSpec opt_in_database SetResetClause
    2228             :  { 
    2229           0 :  $$ = cat_str(4,mm_strdup("alter role"),$3,$4,$5);
    2230             : }
    2231             : |  ALTER ROLE ALL opt_in_database SetResetClause
    2232             :  { 
    2233           0 :  $$ = cat_str(3,mm_strdup("alter role all"),$4,$5);
    2234             : }
    2235             : |  ALTER USER RoleSpec opt_in_database SetResetClause
    2236             :  { 
    2237           0 :  $$ = cat_str(4,mm_strdup("alter user"),$3,$4,$5);
    2238             : }
    2239             : |  ALTER USER ALL opt_in_database SetResetClause
    2240             :  { 
    2241           0 :  $$ = cat_str(3,mm_strdup("alter user all"),$4,$5);
    2242             : }
    2243             : ;
    2244             : 
    2245             : 
    2246             :  DropRoleStmt:
    2247             :  DROP ROLE role_list
    2248             :  { 
    2249           0 :  $$ = cat_str(2,mm_strdup("drop role"),$3);
    2250             : }
    2251             : |  DROP ROLE IF_P EXISTS role_list
    2252             :  { 
    2253           0 :  $$ = cat_str(2,mm_strdup("drop role if exists"),$5);
    2254             : }
    2255             : |  DROP USER role_list
    2256             :  { 
    2257           0 :  $$ = cat_str(2,mm_strdup("drop user"),$3);
    2258             : }
    2259             : |  DROP USER IF_P EXISTS role_list
    2260             :  { 
    2261           0 :  $$ = cat_str(2,mm_strdup("drop user if exists"),$5);
    2262             : }
    2263             : |  DROP GROUP_P role_list
    2264             :  { 
    2265           0 :  $$ = cat_str(2,mm_strdup("drop group"),$3);
    2266             : }
    2267             : |  DROP GROUP_P IF_P EXISTS role_list
    2268             :  { 
    2269           0 :  $$ = cat_str(2,mm_strdup("drop group if exists"),$5);
    2270             : }
    2271             : ;
    2272             : 
    2273             : 
    2274             :  CreateGroupStmt:
    2275             :  CREATE GROUP_P RoleId opt_with OptRoleList
    2276             :  { 
    2277           0 :  $$ = cat_str(4,mm_strdup("create group"),$3,$4,$5);
    2278             : }
    2279             : ;
    2280             : 
    2281             : 
    2282             :  AlterGroupStmt:
    2283             :  ALTER GROUP_P RoleSpec add_drop USER role_list
    2284             :  { 
    2285           0 :  $$ = cat_str(5,mm_strdup("alter group"),$3,$4,mm_strdup("user"),$6);
    2286             : }
    2287             : ;
    2288             : 
    2289             : 
    2290             :  add_drop:
    2291             :  ADD_P
    2292             :  { 
    2293           0 :  $$ = mm_strdup("add");
    2294             : }
    2295             : |  DROP
    2296             :  { 
    2297           0 :  $$ = mm_strdup("drop");
    2298             : }
    2299             : ;
    2300             : 
    2301             : 
    2302             :  CreateSchemaStmt:
    2303             :  CREATE SCHEMA OptSchemaName AUTHORIZATION RoleSpec OptSchemaEltList
    2304             :  { 
    2305           0 :  $$ = cat_str(5,mm_strdup("create schema"),$3,mm_strdup("authorization"),$5,$6);
    2306             : }
    2307             : |  CREATE SCHEMA ColId OptSchemaEltList
    2308             :  { 
    2309           0 :  $$ = cat_str(3,mm_strdup("create schema"),$3,$4);
    2310             : }
    2311             : |  CREATE SCHEMA IF_P NOT EXISTS OptSchemaName AUTHORIZATION RoleSpec OptSchemaEltList
    2312             :  { 
    2313           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    2314           0 :  $$ = cat_str(5,mm_strdup("create schema if not exists"),$6,mm_strdup("authorization"),$8,$9);
    2315             : }
    2316             : |  CREATE SCHEMA IF_P NOT EXISTS ColId OptSchemaEltList
    2317             :  { 
    2318           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    2319           0 :  $$ = cat_str(3,mm_strdup("create schema if not exists"),$6,$7);
    2320             : }
    2321             : ;
    2322             : 
    2323             : 
    2324             :  OptSchemaName:
    2325             :  ColId
    2326             :  { 
    2327           0 :  $$ = $1;
    2328             : }
    2329             : | 
    2330             :  { 
    2331           0 :  $$=EMPTY; }
    2332             : ;
    2333             : 
    2334             : 
    2335             :  OptSchemaEltList:
    2336             :  OptSchemaEltList schema_stmt
    2337             :  { 
    2338           0 :  $$ = cat_str(2,$1,$2);
    2339             : }
    2340             : | 
    2341             :  { 
    2342           0 :  $$=EMPTY; }
    2343             : ;
    2344             : 
    2345             : 
    2346             :  schema_stmt:
    2347             :  CreateStmt
    2348             :  { 
    2349           0 :  $$ = $1;
    2350             : }
    2351             : |  IndexStmt
    2352             :  { 
    2353           0 :  $$ = $1;
    2354             : }
    2355             : |  CreateSeqStmt
    2356             :  { 
    2357           0 :  $$ = $1;
    2358             : }
    2359             : |  CreateTrigStmt
    2360             :  { 
    2361           0 :  $$ = $1;
    2362             : }
    2363             : |  GrantStmt
    2364             :  { 
    2365           0 :  $$ = $1;
    2366             : }
    2367             : |  ViewStmt
    2368             :  { 
    2369           0 :  $$ = $1;
    2370             : }
    2371             : ;
    2372             : 
    2373             : 
    2374             :  VariableSetStmt:
    2375             :  SET set_rest
    2376             :  { 
    2377          46 :  $$ = cat_str(2,mm_strdup("set"),$2);
    2378             : }
    2379             : |  SET LOCAL set_rest
    2380             :  { 
    2381           0 :  $$ = cat_str(2,mm_strdup("set local"),$3);
    2382             : }
    2383             : |  SET SESSION set_rest
    2384             :  { 
    2385           0 :  $$ = cat_str(2,mm_strdup("set session"),$3);
    2386             : }
    2387             : ;
    2388             : 
    2389             : 
    2390             :  set_rest:
    2391             :  TRANSACTION transaction_mode_list
    2392             :  { 
    2393           2 :  $$ = cat_str(2,mm_strdup("transaction"),$2);
    2394             : }
    2395             : |  SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
    2396             :  { 
    2397           0 :  $$ = cat_str(2,mm_strdup("session characteristics as transaction"),$5);
    2398             : }
    2399             : |  set_rest_more
    2400             :  { 
    2401          44 :  $$ = $1;
    2402             : }
    2403             : ;
    2404             : 
    2405             : 
    2406             :  generic_set:
    2407             :  var_name TO var_list
    2408             :  { 
    2409          40 :  $$ = cat_str(3,$1,mm_strdup("to"),$3);
    2410             : }
    2411             : |  var_name '=' var_list
    2412             :  { 
    2413           2 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    2414             : }
    2415             : |  var_name TO DEFAULT
    2416             :  { 
    2417           0 :  $$ = cat_str(2,$1,mm_strdup("to default"));
    2418             : }
    2419             : |  var_name '=' DEFAULT
    2420             :  { 
    2421           0 :  $$ = cat_str(2,$1,mm_strdup("= default"));
    2422             : }
    2423             : ;
    2424             : 
    2425             : 
    2426             :  set_rest_more:
    2427             :  generic_set
    2428             :  { 
    2429          42 :  $$ = $1;
    2430             : }
    2431             : |  var_name FROM CURRENT_P
    2432             :  { 
    2433           0 :  $$ = cat_str(2,$1,mm_strdup("from current"));
    2434             : }
    2435             : |  TIME ZONE zone_value
    2436             :  { 
    2437           2 :  $$ = cat_str(2,mm_strdup("time zone"),$3);
    2438             : }
    2439             : |  CATALOG_P ecpg_sconst
    2440             :  { 
    2441           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    2442           0 :  $$ = cat_str(2,mm_strdup("catalog"),$2);
    2443             : }
    2444             : |  SCHEMA ecpg_sconst
    2445             :  { 
    2446           0 :  $$ = cat_str(2,mm_strdup("schema"),$2);
    2447             : }
    2448             : |  NAMES opt_encoding
    2449             :  { 
    2450           0 :  $$ = cat_str(2,mm_strdup("names"),$2);
    2451             : }
    2452             : |  ROLE NonReservedWord_or_Sconst
    2453             :  { 
    2454           0 :  $$ = cat_str(2,mm_strdup("role"),$2);
    2455             : }
    2456             : |  SESSION AUTHORIZATION NonReservedWord_or_Sconst
    2457             :  { 
    2458           0 :  $$ = cat_str(2,mm_strdup("session authorization"),$3);
    2459             : }
    2460             : |  SESSION AUTHORIZATION DEFAULT
    2461             :  { 
    2462           0 :  $$ = mm_strdup("session authorization default");
    2463             : }
    2464             : |  XML_P OPTION document_or_content
    2465             :  { 
    2466           0 :  $$ = cat_str(2,mm_strdup("xml option"),$3);
    2467             : }
    2468             : |  TRANSACTION SNAPSHOT ecpg_sconst
    2469             :  { 
    2470           0 :  $$ = cat_str(2,mm_strdup("transaction snapshot"),$3);
    2471             : }
    2472             : ;
    2473             : 
    2474             : 
    2475             :  var_name:
    2476             : ECPGColId
    2477             :  { 
    2478          52 :  $$ = $1;
    2479             : }
    2480             : |  var_name '.' ColId
    2481             :  { 
    2482           0 :  $$ = cat_str(3,$1,mm_strdup("."),$3);
    2483             : }
    2484             : ;
    2485             : 
    2486             : 
    2487             :  var_list:
    2488             :  var_value
    2489             :  { 
    2490          42 :  $$ = $1;
    2491             : }
    2492             : |  var_list ',' var_value
    2493             :  { 
    2494           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    2495             : }
    2496             : ;
    2497             : 
    2498             : 
    2499             :  var_value:
    2500             :  opt_boolean_or_string
    2501             :  { 
    2502          40 :  $$ = $1;
    2503             : }
    2504             : |  NumericOnly
    2505             :  { 
    2506           2 :         if ($1[0] == '$')
    2507             :         {
    2508           2 :             free($1);
    2509           2 :             $1 = mm_strdup("$0");
    2510             :         }
    2511             : 
    2512           2 :  $$ = $1;
    2513             : }
    2514             : ;
    2515             : 
    2516             : 
    2517             :  iso_level:
    2518             :  READ UNCOMMITTED
    2519             :  { 
    2520           0 :  $$ = mm_strdup("read uncommitted");
    2521             : }
    2522             : |  READ COMMITTED
    2523             :  { 
    2524           2 :  $$ = mm_strdup("read committed");
    2525             : }
    2526             : |  REPEATABLE READ
    2527             :  { 
    2528           0 :  $$ = mm_strdup("repeatable read");
    2529             : }
    2530             : |  SERIALIZABLE
    2531             :  { 
    2532           0 :  $$ = mm_strdup("serializable");
    2533             : }
    2534             : ;
    2535             : 
    2536             : 
    2537             :  opt_boolean_or_string:
    2538             :  TRUE_P
    2539             :  { 
    2540           0 :  $$ = mm_strdup("true");
    2541             : }
    2542             : |  FALSE_P
    2543             :  { 
    2544           0 :  $$ = mm_strdup("false");
    2545             : }
    2546             : |  ON
    2547             :  { 
    2548           4 :  $$ = mm_strdup("on");
    2549             : }
    2550             : |  NonReservedWord_or_Sconst
    2551             :  { 
    2552          36 :  $$ = $1;
    2553             : }
    2554             : ;
    2555             : 
    2556             : 
    2557             :  zone_value:
    2558             :  ecpg_sconst
    2559             :  { 
    2560           0 :  $$ = $1;
    2561             : }
    2562             : |  ecpg_ident
    2563             :  { 
    2564           2 :  $$ = $1;
    2565             : }
    2566             : |  ConstInterval ecpg_sconst opt_interval
    2567             :  { 
    2568           0 :  $$ = cat_str(3,$1,$2,$3);
    2569             : }
    2570             : |  ConstInterval '(' Iconst ')' ecpg_sconst
    2571             :  { 
    2572           0 :  $$ = cat_str(5,$1,mm_strdup("("),$3,mm_strdup(")"),$5);
    2573             : }
    2574             : |  NumericOnly
    2575             :  { 
    2576           0 :  $$ = $1;
    2577             : }
    2578             : |  DEFAULT
    2579             :  { 
    2580           0 :  $$ = mm_strdup("default");
    2581             : }
    2582             : |  LOCAL
    2583             :  { 
    2584           0 :  $$ = mm_strdup("local");
    2585             : }
    2586             : ;
    2587             : 
    2588             : 
    2589             :  opt_encoding:
    2590             :  ecpg_sconst
    2591             :  { 
    2592           0 :  $$ = $1;
    2593             : }
    2594             : |  DEFAULT
    2595             :  { 
    2596           0 :  $$ = mm_strdup("default");
    2597             : }
    2598             : | 
    2599             :  { 
    2600           0 :  $$=EMPTY; }
    2601             : ;
    2602             : 
    2603             : 
    2604             :  NonReservedWord_or_Sconst:
    2605             :  NonReservedWord
    2606             :  { 
    2607          32 :  $$ = $1;
    2608             : }
    2609             : |  ecpg_sconst
    2610             :  { 
    2611           6 :  $$ = $1;
    2612             : }
    2613             : ;
    2614             : 
    2615             : 
    2616             :  VariableResetStmt:
    2617             :  RESET reset_rest
    2618             :  { 
    2619           0 :  $$ = cat_str(2,mm_strdup("reset"),$2);
    2620             : }
    2621             : ;
    2622             : 
    2623             : 
    2624             :  reset_rest:
    2625             :  generic_reset
    2626             :  { 
    2627           0 :  $$ = $1;
    2628             : }
    2629             : |  TIME ZONE
    2630             :  { 
    2631           0 :  $$ = mm_strdup("time zone");
    2632             : }
    2633             : |  TRANSACTION ISOLATION LEVEL
    2634             :  { 
    2635           0 :  $$ = mm_strdup("transaction isolation level");
    2636             : }
    2637             : |  SESSION AUTHORIZATION
    2638             :  { 
    2639           0 :  $$ = mm_strdup("session authorization");
    2640             : }
    2641             : ;
    2642             : 
    2643             : 
    2644             :  generic_reset:
    2645             :  var_name
    2646             :  { 
    2647           0 :  $$ = $1;
    2648             : }
    2649             : |  ALL
    2650             :  { 
    2651           0 :  $$ = mm_strdup("all");
    2652             : }
    2653             : ;
    2654             : 
    2655             : 
    2656             :  SetResetClause:
    2657             :  SET set_rest
    2658             :  { 
    2659           0 :  $$ = cat_str(2,mm_strdup("set"),$2);
    2660             : }
    2661             : |  VariableResetStmt
    2662             :  { 
    2663           0 :  $$ = $1;
    2664             : }
    2665             : ;
    2666             : 
    2667             : 
    2668             :  FunctionSetResetClause:
    2669             :  SET set_rest_more
    2670             :  { 
    2671           0 :  $$ = cat_str(2,mm_strdup("set"),$2);
    2672             : }
    2673             : |  VariableResetStmt
    2674             :  { 
    2675           0 :  $$ = $1;
    2676             : }
    2677             : ;
    2678             : 
    2679             : 
    2680             :  VariableShowStmt:
    2681             : SHOW var_name ecpg_into
    2682             :  { 
    2683          10 :  $$ = cat_str(2,mm_strdup("show"),$2);
    2684             : }
    2685             : | SHOW TIME ZONE ecpg_into
    2686             :  { 
    2687           2 :  $$ = mm_strdup("show time zone");
    2688             : }
    2689             : | SHOW TRANSACTION ISOLATION LEVEL ecpg_into
    2690             :  { 
    2691           2 :  $$ = mm_strdup("show transaction isolation level");
    2692             : }
    2693             : | SHOW SESSION AUTHORIZATION ecpg_into
    2694             :  { 
    2695           0 :  $$ = mm_strdup("show session authorization");
    2696             : }
    2697             : |  SHOW ALL
    2698             :     {
    2699           0 :         mmerror(PARSE_ERROR, ET_ERROR, "SHOW ALL is not implemented");
    2700           0 :         $$ = EMPTY;
    2701             :     }
    2702             : ;
    2703             : 
    2704             : 
    2705             :  ConstraintsSetStmt:
    2706             :  SET CONSTRAINTS constraints_set_list constraints_set_mode
    2707             :  { 
    2708           0 :  $$ = cat_str(3,mm_strdup("set constraints"),$3,$4);
    2709             : }
    2710             : ;
    2711             : 
    2712             : 
    2713             :  constraints_set_list:
    2714             :  ALL
    2715             :  { 
    2716           0 :  $$ = mm_strdup("all");
    2717             : }
    2718             : |  qualified_name_list
    2719             :  { 
    2720           0 :  $$ = $1;
    2721             : }
    2722             : ;
    2723             : 
    2724             : 
    2725             :  constraints_set_mode:
    2726             :  DEFERRED
    2727             :  { 
    2728           0 :  $$ = mm_strdup("deferred");
    2729             : }
    2730             : |  IMMEDIATE
    2731             :  { 
    2732           0 :  $$ = mm_strdup("immediate");
    2733             : }
    2734             : ;
    2735             : 
    2736             : 
    2737             :  CheckPointStmt:
    2738             :  CHECKPOINT
    2739             :  { 
    2740           0 :  $$ = mm_strdup("checkpoint");
    2741             : }
    2742             : ;
    2743             : 
    2744             : 
    2745             :  DiscardStmt:
    2746             :  DISCARD ALL
    2747             :  { 
    2748           0 :  $$ = mm_strdup("discard all");
    2749             : }
    2750             : |  DISCARD TEMP
    2751             :  { 
    2752           0 :  $$ = mm_strdup("discard temp");
    2753             : }
    2754             : |  DISCARD TEMPORARY
    2755             :  { 
    2756           0 :  $$ = mm_strdup("discard temporary");
    2757             : }
    2758             : |  DISCARD PLANS
    2759             :  { 
    2760           0 :  $$ = mm_strdup("discard plans");
    2761             : }
    2762             : |  DISCARD SEQUENCES
    2763             :  { 
    2764           0 :  $$ = mm_strdup("discard sequences");
    2765             : }
    2766             : ;
    2767             : 
    2768             : 
    2769             :  AlterTableStmt:
    2770             :  ALTER TABLE relation_expr alter_table_cmds
    2771             :  { 
    2772           4 :  $$ = cat_str(3,mm_strdup("alter table"),$3,$4);
    2773             : }
    2774             : |  ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds
    2775             :  { 
    2776           0 :  $$ = cat_str(3,mm_strdup("alter table if exists"),$5,$6);
    2777             : }
    2778             : |  ALTER TABLE relation_expr partition_cmd
    2779             :  { 
    2780           0 :  $$ = cat_str(3,mm_strdup("alter table"),$3,$4);
    2781             : }
    2782             : |  ALTER TABLE IF_P EXISTS relation_expr partition_cmd
    2783             :  { 
    2784           0 :  $$ = cat_str(3,mm_strdup("alter table if exists"),$5,$6);
    2785             : }
    2786             : |  ALTER TABLE ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
    2787             :  { 
    2788           0 :  $$ = cat_str(5,mm_strdup("alter table all in tablespace"),$6,mm_strdup("set tablespace"),$9,$10);
    2789             : }
    2790             : |  ALTER TABLE ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
    2791             :  { 
    2792           0 :  $$ = cat_str(7,mm_strdup("alter table all in tablespace"),$6,mm_strdup("owned by"),$9,mm_strdup("set tablespace"),$12,$13);
    2793             : }
    2794             : |  ALTER INDEX qualified_name alter_table_cmds
    2795             :  { 
    2796           0 :  $$ = cat_str(3,mm_strdup("alter index"),$3,$4);
    2797             : }
    2798             : |  ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds
    2799             :  { 
    2800           0 :  $$ = cat_str(3,mm_strdup("alter index if exists"),$5,$6);
    2801             : }
    2802             : |  ALTER INDEX qualified_name index_partition_cmd
    2803             :  { 
    2804           0 :  $$ = cat_str(3,mm_strdup("alter index"),$3,$4);
    2805             : }
    2806             : |  ALTER INDEX ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
    2807             :  { 
    2808           0 :  $$ = cat_str(5,mm_strdup("alter index all in tablespace"),$6,mm_strdup("set tablespace"),$9,$10);
    2809             : }
    2810             : |  ALTER INDEX ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
    2811             :  { 
    2812           0 :  $$ = cat_str(7,mm_strdup("alter index all in tablespace"),$6,mm_strdup("owned by"),$9,mm_strdup("set tablespace"),$12,$13);
    2813             : }
    2814             : |  ALTER SEQUENCE qualified_name alter_table_cmds
    2815             :  { 
    2816           0 :  $$ = cat_str(3,mm_strdup("alter sequence"),$3,$4);
    2817             : }
    2818             : |  ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds
    2819             :  { 
    2820           0 :  $$ = cat_str(3,mm_strdup("alter sequence if exists"),$5,$6);
    2821             : }
    2822             : |  ALTER VIEW qualified_name alter_table_cmds
    2823             :  { 
    2824           0 :  $$ = cat_str(3,mm_strdup("alter view"),$3,$4);
    2825             : }
    2826             : |  ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds
    2827             :  { 
    2828           0 :  $$ = cat_str(3,mm_strdup("alter view if exists"),$5,$6);
    2829             : }
    2830             : |  ALTER MATERIALIZED VIEW qualified_name alter_table_cmds
    2831             :  { 
    2832           0 :  $$ = cat_str(3,mm_strdup("alter materialized view"),$4,$5);
    2833             : }
    2834             : |  ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name alter_table_cmds
    2835             :  { 
    2836           0 :  $$ = cat_str(3,mm_strdup("alter materialized view if exists"),$6,$7);
    2837             : }
    2838             : |  ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
    2839             :  { 
    2840           0 :  $$ = cat_str(5,mm_strdup("alter materialized view all in tablespace"),$7,mm_strdup("set tablespace"),$10,$11);
    2841             : }
    2842             : |  ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
    2843             :  { 
    2844           0 :  $$ = cat_str(7,mm_strdup("alter materialized view all in tablespace"),$7,mm_strdup("owned by"),$10,mm_strdup("set tablespace"),$13,$14);
    2845             : }
    2846             : |  ALTER FOREIGN TABLE relation_expr alter_table_cmds
    2847             :  { 
    2848           0 :  $$ = cat_str(3,mm_strdup("alter foreign table"),$4,$5);
    2849             : }
    2850             : |  ALTER FOREIGN TABLE IF_P EXISTS relation_expr alter_table_cmds
    2851             :  { 
    2852           0 :  $$ = cat_str(3,mm_strdup("alter foreign table if exists"),$6,$7);
    2853             : }
    2854             : ;
    2855             : 
    2856             : 
    2857             :  alter_table_cmds:
    2858             :  alter_table_cmd
    2859             :  { 
    2860           4 :  $$ = $1;
    2861             : }
    2862             : |  alter_table_cmds ',' alter_table_cmd
    2863             :  { 
    2864           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    2865             : }
    2866             : ;
    2867             : 
    2868             : 
    2869             :  partition_cmd:
    2870             :  ATTACH PARTITION qualified_name PartitionBoundSpec
    2871             :  { 
    2872           0 :  $$ = cat_str(3,mm_strdup("attach partition"),$3,$4);
    2873             : }
    2874             : |  DETACH PARTITION qualified_name
    2875             :  { 
    2876           0 :  $$ = cat_str(2,mm_strdup("detach partition"),$3);
    2877             : }
    2878             : ;
    2879             : 
    2880             : 
    2881             :  index_partition_cmd:
    2882             :  ATTACH PARTITION qualified_name
    2883             :  { 
    2884           0 :  $$ = cat_str(2,mm_strdup("attach partition"),$3);
    2885             : }
    2886             : ;
    2887             : 
    2888             : 
    2889             :  alter_table_cmd:
    2890             :  ADD_P columnDef
    2891             :  { 
    2892           0 :  $$ = cat_str(2,mm_strdup("add"),$2);
    2893             : }
    2894             : |  ADD_P IF_P NOT EXISTS columnDef
    2895             :  { 
    2896           0 :  $$ = cat_str(2,mm_strdup("add if not exists"),$5);
    2897             : }
    2898             : |  ADD_P COLUMN columnDef
    2899             :  { 
    2900           0 :  $$ = cat_str(2,mm_strdup("add column"),$3);
    2901             : }
    2902             : |  ADD_P COLUMN IF_P NOT EXISTS columnDef
    2903             :  { 
    2904           0 :  $$ = cat_str(2,mm_strdup("add column if not exists"),$6);
    2905             : }
    2906             : |  ALTER opt_column ColId alter_column_default
    2907             :  { 
    2908           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,$4);
    2909             : }
    2910             : |  ALTER opt_column ColId DROP NOT NULL_P
    2911             :  { 
    2912           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("drop not null"));
    2913             : }
    2914             : |  ALTER opt_column ColId SET NOT NULL_P
    2915             :  { 
    2916           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("set not null"));
    2917             : }
    2918             : |  ALTER opt_column ColId DROP EXPRESSION
    2919             :  { 
    2920           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("drop expression"));
    2921             : }
    2922             : |  ALTER opt_column ColId DROP EXPRESSION IF_P EXISTS
    2923             :  { 
    2924           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("drop expression if exists"));
    2925             : }
    2926             : |  ALTER opt_column ColId SET STATISTICS SignedIconst
    2927             :  { 
    2928           0 :  $$ = cat_str(5,mm_strdup("alter"),$2,$3,mm_strdup("set statistics"),$6);
    2929             : }
    2930             : |  ALTER opt_column Iconst SET STATISTICS SignedIconst
    2931             :  { 
    2932           0 :  $$ = cat_str(5,mm_strdup("alter"),$2,$3,mm_strdup("set statistics"),$6);
    2933             : }
    2934             : |  ALTER opt_column ColId SET reloptions
    2935             :  { 
    2936           0 :  $$ = cat_str(5,mm_strdup("alter"),$2,$3,mm_strdup("set"),$5);
    2937             : }
    2938             : |  ALTER opt_column ColId RESET reloptions
    2939             :  { 
    2940           0 :  $$ = cat_str(5,mm_strdup("alter"),$2,$3,mm_strdup("reset"),$5);
    2941             : }
    2942             : |  ALTER opt_column ColId SET STORAGE ColId
    2943             :  { 
    2944           0 :  $$ = cat_str(5,mm_strdup("alter"),$2,$3,mm_strdup("set storage"),$6);
    2945             : }
    2946             : |  ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
    2947             :  { 
    2948           0 :  $$ = cat_str(7,mm_strdup("alter"),$2,$3,mm_strdup("add generated"),$6,mm_strdup("as identity"),$9);
    2949             : }
    2950             : |  ALTER opt_column ColId alter_identity_column_option_list
    2951             :  { 
    2952           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,$4);
    2953             : }
    2954             : |  ALTER opt_column ColId DROP IDENTITY_P
    2955             :  { 
    2956           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("drop identity"));
    2957             : }
    2958             : |  ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS
    2959             :  { 
    2960           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,mm_strdup("drop identity if exists"));
    2961             : }
    2962             : |  DROP opt_column IF_P EXISTS ColId opt_drop_behavior
    2963             :  { 
    2964           0 :  $$ = cat_str(5,mm_strdup("drop"),$2,mm_strdup("if exists"),$5,$6);
    2965             : }
    2966             : |  DROP opt_column ColId opt_drop_behavior
    2967             :  { 
    2968           0 :  $$ = cat_str(4,mm_strdup("drop"),$2,$3,$4);
    2969             : }
    2970             : |  ALTER opt_column ColId opt_set_data TYPE_P Typename opt_collate_clause alter_using
    2971             :  { 
    2972           4 :  $$ = cat_str(8,mm_strdup("alter"),$2,$3,$4,mm_strdup("type"),$6,$7,$8);
    2973             : }
    2974             : |  ALTER opt_column ColId alter_generic_options
    2975             :  { 
    2976           0 :  $$ = cat_str(4,mm_strdup("alter"),$2,$3,$4);
    2977             : }
    2978             : |  ADD_P TableConstraint
    2979             :  { 
    2980           0 :  $$ = cat_str(2,mm_strdup("add"),$2);
    2981             : }
    2982             : |  ALTER CONSTRAINT name ConstraintAttributeSpec
    2983             :  { 
    2984           0 :  $$ = cat_str(3,mm_strdup("alter constraint"),$3,$4);
    2985             : }
    2986             : |  VALIDATE CONSTRAINT name
    2987             :  { 
    2988           0 :  $$ = cat_str(2,mm_strdup("validate constraint"),$3);
    2989             : }
    2990             : |  DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
    2991             :  { 
    2992           0 :  $$ = cat_str(3,mm_strdup("drop constraint if exists"),$5,$6);
    2993             : }
    2994             : |  DROP CONSTRAINT name opt_drop_behavior
    2995             :  { 
    2996           0 :  $$ = cat_str(3,mm_strdup("drop constraint"),$3,$4);
    2997             : }
    2998             : |  SET WITHOUT OIDS
    2999             :  { 
    3000           0 :  $$ = mm_strdup("set without oids");
    3001             : }
    3002             : |  CLUSTER ON name
    3003             :  { 
    3004           0 :  $$ = cat_str(2,mm_strdup("cluster on"),$3);
    3005             : }
    3006             : |  SET WITHOUT CLUSTER
    3007             :  { 
    3008           0 :  $$ = mm_strdup("set without cluster");
    3009             : }
    3010             : |  SET LOGGED
    3011             :  { 
    3012           0 :  $$ = mm_strdup("set logged");
    3013             : }
    3014             : |  SET UNLOGGED
    3015             :  { 
    3016           0 :  $$ = mm_strdup("set unlogged");
    3017             : }
    3018             : |  ENABLE_P TRIGGER name
    3019             :  { 
    3020           0 :  $$ = cat_str(2,mm_strdup("enable trigger"),$3);
    3021             : }
    3022             : |  ENABLE_P ALWAYS TRIGGER name
    3023             :  { 
    3024           0 :  $$ = cat_str(2,mm_strdup("enable always trigger"),$4);
    3025             : }
    3026             : |  ENABLE_P REPLICA TRIGGER name
    3027             :  { 
    3028           0 :  $$ = cat_str(2,mm_strdup("enable replica trigger"),$4);
    3029             : }
    3030             : |  ENABLE_P TRIGGER ALL
    3031             :  { 
    3032           0 :  $$ = mm_strdup("enable trigger all");
    3033             : }
    3034             : |  ENABLE_P TRIGGER USER
    3035             :  { 
    3036           0 :  $$ = mm_strdup("enable trigger user");
    3037             : }
    3038             : |  DISABLE_P TRIGGER name
    3039             :  { 
    3040           0 :  $$ = cat_str(2,mm_strdup("disable trigger"),$3);
    3041             : }
    3042             : |  DISABLE_P TRIGGER ALL
    3043             :  { 
    3044           0 :  $$ = mm_strdup("disable trigger all");
    3045             : }
    3046             : |  DISABLE_P TRIGGER USER
    3047             :  { 
    3048           0 :  $$ = mm_strdup("disable trigger user");
    3049             : }
    3050             : |  ENABLE_P RULE name
    3051             :  { 
    3052           0 :  $$ = cat_str(2,mm_strdup("enable rule"),$3);
    3053             : }
    3054             : |  ENABLE_P ALWAYS RULE name
    3055             :  { 
    3056           0 :  $$ = cat_str(2,mm_strdup("enable always rule"),$4);
    3057             : }
    3058             : |  ENABLE_P REPLICA RULE name
    3059             :  { 
    3060           0 :  $$ = cat_str(2,mm_strdup("enable replica rule"),$4);
    3061             : }
    3062             : |  DISABLE_P RULE name
    3063             :  { 
    3064           0 :  $$ = cat_str(2,mm_strdup("disable rule"),$3);
    3065             : }
    3066             : |  INHERIT qualified_name
    3067             :  { 
    3068           0 :  $$ = cat_str(2,mm_strdup("inherit"),$2);
    3069             : }
    3070             : |  NO INHERIT qualified_name
    3071             :  { 
    3072           0 :  $$ = cat_str(2,mm_strdup("no inherit"),$3);
    3073             : }
    3074             : |  OF any_name
    3075             :  { 
    3076           0 :  $$ = cat_str(2,mm_strdup("of"),$2);
    3077             : }
    3078             : |  NOT OF
    3079             :  { 
    3080           0 :  $$ = mm_strdup("not of");
    3081             : }
    3082             : |  OWNER TO RoleSpec
    3083             :  { 
    3084           0 :  $$ = cat_str(2,mm_strdup("owner to"),$3);
    3085             : }
    3086             : |  SET TABLESPACE name
    3087             :  { 
    3088           0 :  $$ = cat_str(2,mm_strdup("set tablespace"),$3);
    3089             : }
    3090             : |  SET reloptions
    3091             :  { 
    3092           0 :  $$ = cat_str(2,mm_strdup("set"),$2);
    3093             : }
    3094             : |  RESET reloptions
    3095             :  { 
    3096           0 :  $$ = cat_str(2,mm_strdup("reset"),$2);
    3097             : }
    3098             : |  REPLICA IDENTITY_P replica_identity
    3099             :  { 
    3100           0 :  $$ = cat_str(2,mm_strdup("replica identity"),$3);
    3101             : }
    3102             : |  ENABLE_P ROW LEVEL SECURITY
    3103             :  { 
    3104           0 :  $$ = mm_strdup("enable row level security");
    3105             : }
    3106             : |  DISABLE_P ROW LEVEL SECURITY
    3107             :  { 
    3108           0 :  $$ = mm_strdup("disable row level security");
    3109             : }
    3110             : |  FORCE ROW LEVEL SECURITY
    3111             :  { 
    3112           0 :  $$ = mm_strdup("force row level security");
    3113             : }
    3114             : |  NO FORCE ROW LEVEL SECURITY
    3115             :  { 
    3116           0 :  $$ = mm_strdup("no force row level security");
    3117             : }
    3118             : |  ALTER COLLATION any_name REFRESH VERSION_P
    3119             :  { 
    3120           0 :  $$ = cat_str(3,mm_strdup("alter collation"),$3,mm_strdup("refresh version"));
    3121             : }
    3122             : |  alter_generic_options
    3123             :  { 
    3124           0 :  $$ = $1;
    3125             : }
    3126             : ;
    3127             : 
    3128             : 
    3129             :  alter_column_default:
    3130             :  SET DEFAULT a_expr
    3131             :  { 
    3132           0 :  $$ = cat_str(2,mm_strdup("set default"),$3);
    3133             : }
    3134             : |  DROP DEFAULT
    3135             :  { 
    3136           0 :  $$ = mm_strdup("drop default");
    3137             : }
    3138             : ;
    3139             : 
    3140             : 
    3141             :  opt_drop_behavior:
    3142             :  CASCADE
    3143             :  { 
    3144           0 :  $$ = mm_strdup("cascade");
    3145             : }
    3146             : |  RESTRICT
    3147             :  { 
    3148           0 :  $$ = mm_strdup("restrict");
    3149             : }
    3150             : | 
    3151             :  { 
    3152         118 :  $$=EMPTY; }
    3153             : ;
    3154             : 
    3155             : 
    3156             :  opt_collate_clause:
    3157             :  COLLATE any_name
    3158             :  { 
    3159           0 :  $$ = cat_str(2,mm_strdup("collate"),$2);
    3160             : }
    3161             : | 
    3162             :  { 
    3163           4 :  $$=EMPTY; }
    3164             : ;
    3165             : 
    3166             : 
    3167             :  alter_using:
    3168             :  USING a_expr
    3169             :  { 
    3170           0 :  $$ = cat_str(2,mm_strdup("using"),$2);
    3171             : }
    3172             : | 
    3173             :  { 
    3174           4 :  $$=EMPTY; }
    3175             : ;
    3176             : 
    3177             : 
    3178             :  replica_identity:
    3179             :  NOTHING
    3180             :  { 
    3181           0 :  $$ = mm_strdup("nothing");
    3182             : }
    3183             : |  FULL
    3184             :  { 
    3185           0 :  $$ = mm_strdup("full");
    3186             : }
    3187             : |  DEFAULT
    3188             :  { 
    3189           0 :  $$ = mm_strdup("default");
    3190             : }
    3191             : |  USING INDEX name
    3192             :  { 
    3193           0 :  $$ = cat_str(2,mm_strdup("using index"),$3);
    3194             : }
    3195             : ;
    3196             : 
    3197             : 
    3198             :  reloptions:
    3199             :  '(' reloption_list ')'
    3200             :  { 
    3201           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    3202             : }
    3203             : ;
    3204             : 
    3205             : 
    3206             :  opt_reloptions:
    3207             :  WITH reloptions
    3208             :  { 
    3209           0 :  $$ = cat_str(2,mm_strdup("with"),$2);
    3210             : }
    3211             : | 
    3212             :  { 
    3213           0 :  $$=EMPTY; }
    3214             : ;
    3215             : 
    3216             : 
    3217             :  reloption_list:
    3218             :  reloption_elem
    3219             :  { 
    3220           0 :  $$ = $1;
    3221             : }
    3222             : |  reloption_list ',' reloption_elem
    3223             :  { 
    3224           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3225             : }
    3226             : ;
    3227             : 
    3228             : 
    3229             :  reloption_elem:
    3230             :  ColLabel '=' def_arg
    3231             :  { 
    3232           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    3233             : }
    3234             : |  ColLabel
    3235             :  { 
    3236           0 :  $$ = $1;
    3237             : }
    3238             : |  ColLabel '.' ColLabel '=' def_arg
    3239             :  { 
    3240           0 :  $$ = cat_str(5,$1,mm_strdup("."),$3,mm_strdup("="),$5);
    3241             : }
    3242             : |  ColLabel '.' ColLabel
    3243             :  { 
    3244           0 :  $$ = cat_str(3,$1,mm_strdup("."),$3);
    3245             : }
    3246             : ;
    3247             : 
    3248             : 
    3249             :  alter_identity_column_option_list:
    3250             :  alter_identity_column_option
    3251             :  { 
    3252           0 :  $$ = $1;
    3253             : }
    3254             : |  alter_identity_column_option_list alter_identity_column_option
    3255             :  { 
    3256           0 :  $$ = cat_str(2,$1,$2);
    3257             : }
    3258             : ;
    3259             : 
    3260             : 
    3261             :  alter_identity_column_option:
    3262             :  RESTART
    3263             :  { 
    3264           0 :  $$ = mm_strdup("restart");
    3265             : }
    3266             : |  RESTART opt_with NumericOnly
    3267             :  { 
    3268           0 :  $$ = cat_str(3,mm_strdup("restart"),$2,$3);
    3269             : }
    3270             : |  SET SeqOptElem
    3271             :  { 
    3272           0 :  $$ = cat_str(2,mm_strdup("set"),$2);
    3273             : }
    3274             : |  SET GENERATED generated_when
    3275             :  { 
    3276           0 :  $$ = cat_str(2,mm_strdup("set generated"),$3);
    3277             : }
    3278             : ;
    3279             : 
    3280             : 
    3281             :  PartitionBoundSpec:
    3282             :  FOR VALUES WITH '(' hash_partbound ')'
    3283             :  { 
    3284           0 :  $$ = cat_str(3,mm_strdup("for values with ("),$5,mm_strdup(")"));
    3285             : }
    3286             : |  FOR VALUES IN_P '(' expr_list ')'
    3287             :  { 
    3288           0 :  $$ = cat_str(3,mm_strdup("for values in ("),$5,mm_strdup(")"));
    3289             : }
    3290             : |  FOR VALUES FROM '(' expr_list ')' TO '(' expr_list ')'
    3291             :  { 
    3292           0 :  $$ = cat_str(5,mm_strdup("for values from ("),$5,mm_strdup(") to ("),$9,mm_strdup(")"));
    3293             : }
    3294             : |  DEFAULT
    3295             :  { 
    3296           0 :  $$ = mm_strdup("default");
    3297             : }
    3298             : ;
    3299             : 
    3300             : 
    3301             :  hash_partbound_elem:
    3302             :  NonReservedWord Iconst
    3303             :  { 
    3304           0 :  $$ = cat_str(2,$1,$2);
    3305             : }
    3306             : ;
    3307             : 
    3308             : 
    3309             :  hash_partbound:
    3310             :  hash_partbound_elem
    3311             :  { 
    3312           0 :  $$ = $1;
    3313             : }
    3314             : |  hash_partbound ',' hash_partbound_elem
    3315             :  { 
    3316           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3317             : }
    3318             : ;
    3319             : 
    3320             : 
    3321             :  AlterCompositeTypeStmt:
    3322             :  ALTER TYPE_P any_name alter_type_cmds
    3323             :  { 
    3324           0 :  $$ = cat_str(3,mm_strdup("alter type"),$3,$4);
    3325             : }
    3326             : ;
    3327             : 
    3328             : 
    3329             :  alter_type_cmds:
    3330             :  alter_type_cmd
    3331             :  { 
    3332           0 :  $$ = $1;
    3333             : }
    3334             : |  alter_type_cmds ',' alter_type_cmd
    3335             :  { 
    3336           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3337             : }
    3338             : ;
    3339             : 
    3340             : 
    3341             :  alter_type_cmd:
    3342             :  ADD_P ATTRIBUTE TableFuncElement opt_drop_behavior
    3343             :  { 
    3344           0 :  $$ = cat_str(3,mm_strdup("add attribute"),$3,$4);
    3345             : }
    3346             : |  DROP ATTRIBUTE IF_P EXISTS ColId opt_drop_behavior
    3347             :  { 
    3348           0 :  $$ = cat_str(3,mm_strdup("drop attribute if exists"),$5,$6);
    3349             : }
    3350             : |  DROP ATTRIBUTE ColId opt_drop_behavior
    3351             :  { 
    3352           0 :  $$ = cat_str(3,mm_strdup("drop attribute"),$3,$4);
    3353             : }
    3354             : |  ALTER ATTRIBUTE ColId opt_set_data TYPE_P Typename opt_collate_clause opt_drop_behavior
    3355             :  { 
    3356           0 :  $$ = cat_str(7,mm_strdup("alter attribute"),$3,$4,mm_strdup("type"),$6,$7,$8);
    3357             : }
    3358             : ;
    3359             : 
    3360             : 
    3361             :  ClosePortalStmt:
    3362             :  CLOSE cursor_name
    3363             :     {
    3364          66 :         char *cursor_marker = $2[0] == ':' ? mm_strdup("$0") : $2;
    3365          66 :         $$ = cat2_str(mm_strdup("close"), cursor_marker);
    3366             :     }
    3367             : |  CLOSE ALL
    3368             :  { 
    3369           0 :  $$ = mm_strdup("close all");
    3370             : }
    3371             : ;
    3372             : 
    3373             : 
    3374             :  CopyStmt:
    3375             :  COPY opt_binary qualified_name opt_column_list copy_from opt_program copy_file_name copy_delimiter opt_with copy_options where_clause
    3376             :  { 
    3377           2 :             if (strcmp($6, "from") == 0 &&
    3378           0 :                (strcmp($7, "stdin") == 0 || strcmp($7, "stdout") == 0))
    3379           0 :                 mmerror(PARSE_ERROR, ET_WARNING, "COPY FROM STDIN is not implemented");
    3380             : 
    3381           2 :  $$ = cat_str(11,mm_strdup("copy"),$2,$3,$4,$5,$6,$7,$8,$9,$10,$11);
    3382             : }
    3383             : |  COPY '(' PreparableStmt ')' TO opt_program copy_file_name opt_with copy_options
    3384             :  { 
    3385           0 :  $$ = cat_str(7,mm_strdup("copy ("),$3,mm_strdup(") to"),$6,$7,$8,$9);
    3386             : }
    3387             : ;
    3388             : 
    3389             : 
    3390             :  copy_from:
    3391             :  FROM
    3392             :  { 
    3393           0 :  $$ = mm_strdup("from");
    3394             : }
    3395             : |  TO
    3396             :  { 
    3397           2 :  $$ = mm_strdup("to");
    3398             : }
    3399             : ;
    3400             : 
    3401             : 
    3402             :  opt_program:
    3403             :  PROGRAM
    3404             :  { 
    3405           0 :  $$ = mm_strdup("program");
    3406             : }
    3407             : | 
    3408             :  { 
    3409           2 :  $$=EMPTY; }
    3410             : ;
    3411             : 
    3412             : 
    3413             :  copy_file_name:
    3414             :  ecpg_sconst
    3415             :  { 
    3416           0 :  $$ = $1;
    3417             : }
    3418             : |  STDIN
    3419             :  { 
    3420           0 :  $$ = mm_strdup("stdin");
    3421             : }
    3422             : |  STDOUT
    3423             :  { 
    3424           2 :  $$ = mm_strdup("stdout");
    3425             : }
    3426             : ;
    3427             : 
    3428             : 
    3429             :  copy_options:
    3430             :  copy_opt_list
    3431             :  { 
    3432           2 :  $$ = $1;
    3433             : }
    3434             : |  '(' copy_generic_opt_list ')'
    3435             :  { 
    3436           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    3437             : }
    3438             : ;
    3439             : 
    3440             : 
    3441             :  copy_opt_list:
    3442             :  copy_opt_list copy_opt_item
    3443             :  { 
    3444           2 :  $$ = cat_str(2,$1,$2);
    3445             : }
    3446             : | 
    3447             :  { 
    3448           2 :  $$=EMPTY; }
    3449             : ;
    3450             : 
    3451             : 
    3452             :  copy_opt_item:
    3453             :  BINARY
    3454             :  { 
    3455           0 :  $$ = mm_strdup("binary");
    3456             : }
    3457             : |  FREEZE
    3458             :  { 
    3459           0 :  $$ = mm_strdup("freeze");
    3460             : }
    3461             : |  DELIMITER opt_as ecpg_sconst
    3462             :  { 
    3463           2 :  $$ = cat_str(3,mm_strdup("delimiter"),$2,$3);
    3464             : }
    3465             : |  NULL_P opt_as ecpg_sconst
    3466             :  { 
    3467           0 :  $$ = cat_str(3,mm_strdup("null"),$2,$3);
    3468             : }
    3469             : |  CSV
    3470             :  { 
    3471           0 :  $$ = mm_strdup("csv");
    3472             : }
    3473             : |  HEADER_P
    3474             :  { 
    3475           0 :  $$ = mm_strdup("header");
    3476             : }
    3477             : |  QUOTE opt_as ecpg_sconst
    3478             :  { 
    3479           0 :  $$ = cat_str(3,mm_strdup("quote"),$2,$3);
    3480             : }
    3481             : |  ESCAPE opt_as ecpg_sconst
    3482             :  { 
    3483           0 :  $$ = cat_str(3,mm_strdup("escape"),$2,$3);
    3484             : }
    3485             : |  FORCE QUOTE columnList
    3486             :  { 
    3487           0 :  $$ = cat_str(2,mm_strdup("force quote"),$3);
    3488             : }
    3489             : |  FORCE QUOTE '*'
    3490             :  { 
    3491           0 :  $$ = mm_strdup("force quote *");
    3492             : }
    3493             : |  FORCE NOT NULL_P columnList
    3494             :  { 
    3495           0 :  $$ = cat_str(2,mm_strdup("force not null"),$4);
    3496             : }
    3497             : |  FORCE NULL_P columnList
    3498             :  { 
    3499           0 :  $$ = cat_str(2,mm_strdup("force null"),$3);
    3500             : }
    3501             : |  ENCODING ecpg_sconst
    3502             :  { 
    3503           0 :  $$ = cat_str(2,mm_strdup("encoding"),$2);
    3504             : }
    3505             : ;
    3506             : 
    3507             : 
    3508             :  opt_binary:
    3509             :  BINARY
    3510             :  { 
    3511           0 :  $$ = mm_strdup("binary");
    3512             : }
    3513             : | 
    3514             :  { 
    3515           2 :  $$=EMPTY; }
    3516             : ;
    3517             : 
    3518             : 
    3519             :  copy_delimiter:
    3520             :  opt_using DELIMITERS ecpg_sconst
    3521             :  { 
    3522           0 :  $$ = cat_str(3,$1,mm_strdup("delimiters"),$3);
    3523             : }
    3524             : | 
    3525             :  { 
    3526           2 :  $$=EMPTY; }
    3527             : ;
    3528             : 
    3529             : 
    3530             :  opt_using:
    3531             :  USING
    3532             :  { 
    3533           0 :  $$ = mm_strdup("using");
    3534             : }
    3535             : | 
    3536             :  { 
    3537           0 :  $$=EMPTY; }
    3538             : ;
    3539             : 
    3540             : 
    3541             :  copy_generic_opt_list:
    3542             :  copy_generic_opt_elem
    3543             :  { 
    3544           0 :  $$ = $1;
    3545             : }
    3546             : |  copy_generic_opt_list ',' copy_generic_opt_elem
    3547             :  { 
    3548           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3549             : }
    3550             : ;
    3551             : 
    3552             : 
    3553             :  copy_generic_opt_elem:
    3554             :  ColLabel copy_generic_opt_arg
    3555             :  { 
    3556           0 :  $$ = cat_str(2,$1,$2);
    3557             : }
    3558             : ;
    3559             : 
    3560             : 
    3561             :  copy_generic_opt_arg:
    3562             :  opt_boolean_or_string
    3563             :  { 
    3564           0 :  $$ = $1;
    3565             : }
    3566             : |  NumericOnly
    3567             :  { 
    3568           0 :  $$ = $1;
    3569             : }
    3570             : |  '*'
    3571             :  { 
    3572           0 :  $$ = mm_strdup("*");
    3573             : }
    3574             : |  '(' copy_generic_opt_arg_list ')'
    3575             :  { 
    3576           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    3577             : }
    3578             : | 
    3579             :  { 
    3580           0 :  $$=EMPTY; }
    3581             : ;
    3582             : 
    3583             : 
    3584             :  copy_generic_opt_arg_list:
    3585             :  copy_generic_opt_arg_list_item
    3586             :  { 
    3587           0 :  $$ = $1;
    3588             : }
    3589             : |  copy_generic_opt_arg_list ',' copy_generic_opt_arg_list_item
    3590             :  { 
    3591           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3592             : }
    3593             : ;
    3594             : 
    3595             : 
    3596             :  copy_generic_opt_arg_list_item:
    3597             :  opt_boolean_or_string
    3598             :  { 
    3599           0 :  $$ = $1;
    3600             : }
    3601             : ;
    3602             : 
    3603             : 
    3604             :  CreateStmt:
    3605             :  CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3606             :  { 
    3607          94 :  $$ = cat_str(13,mm_strdup("create"),$2,mm_strdup("table"),$4,mm_strdup("("),$6,mm_strdup(")"),$8,$9,$10,$11,$12,$13);
    3608             : }
    3609             : |  CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3610             :  { 
    3611           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);
    3612             : }
    3613             : |  CREATE OptTemp TABLE qualified_name OF any_name OptTypedTableElementList OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3614             :  { 
    3615           0 :  $$ = cat_str(12,mm_strdup("create"),$2,mm_strdup("table"),$4,mm_strdup("of"),$6,$7,$8,$9,$10,$11,$12);
    3616             : }
    3617             : |  CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name OF any_name OptTypedTableElementList OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3618             :  { 
    3619           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);
    3620             : }
    3621             : |  CREATE OptTemp TABLE qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3622             :  { 
    3623           0 :  $$ = cat_str(13,mm_strdup("create"),$2,mm_strdup("table"),$4,mm_strdup("partition of"),$7,$8,$9,$10,$11,$12,$13,$14);
    3624             : }
    3625             : |  CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec table_access_method_clause OptWith OnCommitOption OptTableSpace
    3626             :  { 
    3627           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);
    3628             : }
    3629             : ;
    3630             : 
    3631             : 
    3632             :  OptTemp:
    3633             :  TEMPORARY
    3634             :  { 
    3635           0 :  $$ = mm_strdup("temporary");
    3636             : }
    3637             : |  TEMP
    3638             :  { 
    3639           0 :  $$ = mm_strdup("temp");
    3640             : }
    3641             : |  LOCAL TEMPORARY
    3642             :  { 
    3643           0 :  $$ = mm_strdup("local temporary");
    3644             : }
    3645             : |  LOCAL TEMP
    3646             :  { 
    3647           0 :  $$ = mm_strdup("local temp");
    3648             : }
    3649             : |  GLOBAL TEMPORARY
    3650             :  { 
    3651           0 :  $$ = mm_strdup("global temporary");
    3652             : }
    3653             : |  GLOBAL TEMP
    3654             :  { 
    3655           0 :  $$ = mm_strdup("global temp");
    3656             : }
    3657             : |  UNLOGGED
    3658             :  { 
    3659           0 :  $$ = mm_strdup("unlogged");
    3660             : }
    3661             : | 
    3662             :  { 
    3663         100 :  $$=EMPTY; }
    3664             : ;
    3665             : 
    3666             : 
    3667             :  OptTableElementList:
    3668             :  TableElementList
    3669             :  { 
    3670          96 :  $$ = $1;
    3671             : }
    3672             : | 
    3673             :  { 
    3674           0 :  $$=EMPTY; }
    3675             : ;
    3676             : 
    3677             : 
    3678             :  OptTypedTableElementList:
    3679             :  '(' TypedTableElementList ')'
    3680             :  { 
    3681           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    3682             : }
    3683             : | 
    3684             :  { 
    3685           0 :  $$=EMPTY; }
    3686             : ;
    3687             : 
    3688             : 
    3689             :  TableElementList:
    3690             :  TableElement
    3691             :  { 
    3692          96 :  $$ = $1;
    3693             : }
    3694             : |  TableElementList ',' TableElement
    3695             :  { 
    3696         204 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3697             : }
    3698             : ;
    3699             : 
    3700             : 
    3701             :  TypedTableElementList:
    3702             :  TypedTableElement
    3703             :  { 
    3704           0 :  $$ = $1;
    3705             : }
    3706             : |  TypedTableElementList ',' TypedTableElement
    3707             :  { 
    3708           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    3709             : }
    3710             : ;
    3711             : 
    3712             : 
    3713             :  TableElement:
    3714             :  columnDef
    3715             :  { 
    3716         296 :  $$ = $1;
    3717             : }
    3718             : |  TableLikeClause
    3719             :  { 
    3720           0 :  $$ = $1;
    3721             : }
    3722             : |  TableConstraint
    3723             :  { 
    3724           4 :  $$ = $1;
    3725             : }
    3726             : ;
    3727             : 
    3728             : 
    3729             :  TypedTableElement:
    3730             :  columnOptions
    3731             :  { 
    3732           0 :  $$ = $1;
    3733             : }
    3734             : |  TableConstraint
    3735             :  { 
    3736           0 :  $$ = $1;
    3737             : }
    3738             : ;
    3739             : 
    3740             : 
    3741             :  columnDef:
    3742             :  ColId Typename create_generic_options ColQualList
    3743             :  { 
    3744         296 :  $$ = cat_str(4,$1,$2,$3,$4);
    3745             : }
    3746             : ;
    3747             : 
    3748             : 
    3749             :  columnOptions:
    3750             :  ColId ColQualList
    3751             :  { 
    3752           0 :  $$ = cat_str(2,$1,$2);
    3753             : }
    3754             : |  ColId WITH OPTIONS ColQualList
    3755             :  { 
    3756           0 :  $$ = cat_str(3,$1,mm_strdup("with options"),$4);
    3757             : }
    3758             : ;
    3759             : 
    3760             : 
    3761             :  ColQualList:
    3762             :  ColQualList ColConstraint
    3763             :  { 
    3764          38 :  $$ = cat_str(2,$1,$2);
    3765             : }
    3766             : | 
    3767             :  { 
    3768         296 :  $$=EMPTY; }
    3769             : ;
    3770             : 
    3771             : 
    3772             :  ColConstraint:
    3773             :  CONSTRAINT name ColConstraintElem
    3774             :  { 
    3775           0 :  $$ = cat_str(3,mm_strdup("constraint"),$2,$3);
    3776             : }
    3777             : |  ColConstraintElem
    3778             :  { 
    3779          38 :  $$ = $1;
    3780             : }
    3781             : |  ConstraintAttr
    3782             :  { 
    3783           0 :  $$ = $1;
    3784             : }
    3785             : |  COLLATE any_name
    3786             :  { 
    3787           0 :  $$ = cat_str(2,mm_strdup("collate"),$2);
    3788             : }
    3789             : ;
    3790             : 
    3791             : 
    3792             :  ColConstraintElem:
    3793             :  NOT NULL_P
    3794             :  { 
    3795          16 :  $$ = mm_strdup("not null");
    3796             : }
    3797             : |  NULL_P
    3798             :  { 
    3799           2 :  $$ = mm_strdup("null");
    3800             : }
    3801             : |  UNIQUE opt_definition OptConsTableSpace
    3802             :  { 
    3803           0 :  $$ = cat_str(3,mm_strdup("unique"),$2,$3);
    3804             : }
    3805             : |  PRIMARY KEY opt_definition OptConsTableSpace
    3806             :  { 
    3807          16 :  $$ = cat_str(3,mm_strdup("primary key"),$3,$4);
    3808             : }
    3809             : |  CHECK '(' a_expr ')' opt_no_inherit
    3810             :  { 
    3811           0 :  $$ = cat_str(4,mm_strdup("check ("),$3,mm_strdup(")"),$5);
    3812             : }
    3813             : |  DEFAULT b_expr
    3814             :  { 
    3815           4 :  $$ = cat_str(2,mm_strdup("default"),$2);
    3816             : }
    3817             : |  GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
    3818             :  { 
    3819           0 :  $$ = cat_str(4,mm_strdup("generated"),$2,mm_strdup("as identity"),$5);
    3820             : }
    3821             : |  GENERATED generated_when AS '(' a_expr ')' STORED
    3822             :  { 
    3823           0 :  $$ = cat_str(5,mm_strdup("generated"),$2,mm_strdup("as ("),$5,mm_strdup(") stored"));
    3824             : }
    3825             : |  REFERENCES qualified_name opt_column_list key_match key_actions
    3826             :  { 
    3827           0 :  $$ = cat_str(5,mm_strdup("references"),$2,$3,$4,$5);
    3828             : }
    3829             : ;
    3830             : 
    3831             : 
    3832             :  generated_when:
    3833             :  ALWAYS
    3834             :  { 
    3835           0 :  $$ = mm_strdup("always");
    3836             : }
    3837             : |  BY DEFAULT
    3838             :  { 
    3839           0 :  $$ = mm_strdup("by default");
    3840             : }
    3841             : ;
    3842             : 
    3843             : 
    3844             :  ConstraintAttr:
    3845             :  DEFERRABLE
    3846             :  { 
    3847           0 :  $$ = mm_strdup("deferrable");
    3848             : }
    3849             : |  NOT DEFERRABLE
    3850             :  { 
    3851           0 :  $$ = mm_strdup("not deferrable");
    3852             : }
    3853             : |  INITIALLY DEFERRED
    3854             :  { 
    3855           0 :  $$ = mm_strdup("initially deferred");
    3856             : }
    3857             : |  INITIALLY IMMEDIATE
    3858             :  { 
    3859           0 :  $$ = mm_strdup("initially immediate");
    3860             : }
    3861             : ;
    3862             : 
    3863             : 
    3864             :  TableLikeClause:
    3865             :  LIKE qualified_name TableLikeOptionList
    3866             :  { 
    3867           0 :  $$ = cat_str(3,mm_strdup("like"),$2,$3);
    3868             : }
    3869             : ;
    3870             : 
    3871             : 
    3872             :  TableLikeOptionList:
    3873             :  TableLikeOptionList INCLUDING TableLikeOption
    3874             :  { 
    3875           0 :  $$ = cat_str(3,$1,mm_strdup("including"),$3);
    3876             : }
    3877             : |  TableLikeOptionList EXCLUDING TableLikeOption
    3878             :  { 
    3879           0 :  $$ = cat_str(3,$1,mm_strdup("excluding"),$3);
    3880             : }
    3881             : | 
    3882             :  { 
    3883           0 :  $$=EMPTY; }
    3884             : ;
    3885             : 
    3886             : 
    3887             :  TableLikeOption:
    3888             :  COMMENTS
    3889             :  { 
    3890           0 :  $$ = mm_strdup("comments");
    3891             : }
    3892             : |  CONSTRAINTS
    3893             :  { 
    3894           0 :  $$ = mm_strdup("constraints");
    3895             : }
    3896             : |  DEFAULTS
    3897             :  { 
    3898           0 :  $$ = mm_strdup("defaults");
    3899             : }
    3900             : |  IDENTITY_P
    3901             :  { 
    3902           0 :  $$ = mm_strdup("identity");
    3903             : }
    3904             : |  GENERATED
    3905             :  { 
    3906           0 :  $$ = mm_strdup("generated");
    3907             : }
    3908             : |  INDEXES
    3909             :  { 
    3910           0 :  $$ = mm_strdup("indexes");
    3911             : }
    3912             : |  STATISTICS
    3913             :  { 
    3914           0 :  $$ = mm_strdup("statistics");
    3915             : }
    3916             : |  STORAGE
    3917             :  { 
    3918           0 :  $$ = mm_strdup("storage");
    3919             : }
    3920             : |  ALL
    3921             :  { 
    3922           0 :  $$ = mm_strdup("all");
    3923             : }
    3924             : ;
    3925             : 
    3926             : 
    3927             :  TableConstraint:
    3928             :  CONSTRAINT name ConstraintElem
    3929             :  { 
    3930           0 :  $$ = cat_str(3,mm_strdup("constraint"),$2,$3);
    3931             : }
    3932             : |  ConstraintElem
    3933             :  { 
    3934           4 :  $$ = $1;
    3935             : }
    3936             : ;
    3937             : 
    3938             : 
    3939             :  ConstraintElem:
    3940             :  CHECK '(' a_expr ')' ConstraintAttributeSpec
    3941             :  { 
    3942           0 :  $$ = cat_str(4,mm_strdup("check ("),$3,mm_strdup(")"),$5);
    3943             : }
    3944             : |  UNIQUE '(' columnList ')' opt_c_include opt_definition OptConsTableSpace ConstraintAttributeSpec
    3945             :  { 
    3946           0 :  $$ = cat_str(7,mm_strdup("unique ("),$3,mm_strdup(")"),$5,$6,$7,$8);
    3947             : }
    3948             : |  UNIQUE ExistingIndex ConstraintAttributeSpec
    3949             :  { 
    3950           0 :  $$ = cat_str(3,mm_strdup("unique"),$2,$3);
    3951             : }
    3952             : |  PRIMARY KEY '(' columnList ')' opt_c_include opt_definition OptConsTableSpace ConstraintAttributeSpec
    3953             :  { 
    3954           4 :  $$ = cat_str(7,mm_strdup("primary key ("),$4,mm_strdup(")"),$6,$7,$8,$9);
    3955             : }
    3956             : |  PRIMARY KEY ExistingIndex ConstraintAttributeSpec
    3957             :  { 
    3958           0 :  $$ = cat_str(3,mm_strdup("primary key"),$3,$4);
    3959             : }
    3960             : |  EXCLUDE access_method_clause '(' ExclusionConstraintList ')' opt_c_include opt_definition OptConsTableSpace ExclusionWhereClause ConstraintAttributeSpec
    3961             :  { 
    3962           0 :  $$ = cat_str(10,mm_strdup("exclude"),$2,mm_strdup("("),$4,mm_strdup(")"),$6,$7,$8,$9,$10);
    3963             : }
    3964             : |  FOREIGN KEY '(' columnList ')' REFERENCES qualified_name opt_column_list key_match key_actions ConstraintAttributeSpec
    3965             :  { 
    3966           0 :  $$ = cat_str(8,mm_strdup("foreign key ("),$4,mm_strdup(") references"),$7,$8,$9,$10,$11);
    3967             : }
    3968             : ;
    3969             : 
    3970             : 
    3971             :  opt_no_inherit:
    3972             :  NO INHERIT
    3973             :  { 
    3974           0 :  $$ = mm_strdup("no inherit");
    3975             : }
    3976             : | 
    3977             :  { 
    3978           0 :  $$=EMPTY; }
    3979             : ;
    3980             : 
    3981             : 
    3982             :  opt_column_list:
    3983             :  '(' columnList ')'
    3984             :  { 
    3985           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    3986             : }
    3987             : | 
    3988             :  { 
    3989           6 :  $$=EMPTY; }
    3990             : ;
    3991             : 
    3992             : 
    3993             :  columnList:
    3994             :  columnElem
    3995             :  { 
    3996           4 :  $$ = $1;
    3997             : }
    3998             : |  columnList ',' columnElem
    3999             :  { 
    4000           4 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4001             : }
    4002             : ;
    4003             : 
    4004             : 
    4005             :  columnElem:
    4006             :  ColId
    4007             :  { 
    4008           8 :  $$ = $1;
    4009             : }
    4010             : ;
    4011             : 
    4012             : 
    4013             :  opt_c_include:
    4014             :  INCLUDE '(' columnList ')'
    4015             :  { 
    4016           0 :  $$ = cat_str(3,mm_strdup("include ("),$3,mm_strdup(")"));
    4017             : }
    4018             : | 
    4019             :  { 
    4020           4 :  $$=EMPTY; }
    4021             : ;
    4022             : 
    4023             : 
    4024             :  key_match:
    4025             :  MATCH FULL
    4026             :  { 
    4027           0 :  $$ = mm_strdup("match full");
    4028             : }
    4029             : |  MATCH PARTIAL
    4030             :  { 
    4031           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    4032           0 :  $$ = mm_strdup("match partial");
    4033             : }
    4034             : |  MATCH SIMPLE
    4035             :  { 
    4036           0 :  $$ = mm_strdup("match simple");
    4037             : }
    4038             : | 
    4039             :  { 
    4040           0 :  $$=EMPTY; }
    4041             : ;
    4042             : 
    4043             : 
    4044             :  ExclusionConstraintList:
    4045             :  ExclusionConstraintElem
    4046             :  { 
    4047           0 :  $$ = $1;
    4048             : }
    4049             : |  ExclusionConstraintList ',' ExclusionConstraintElem
    4050             :  { 
    4051           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4052             : }
    4053             : ;
    4054             : 
    4055             : 
    4056             :  ExclusionConstraintElem:
    4057             :  index_elem WITH any_operator
    4058             :  { 
    4059           0 :  $$ = cat_str(3,$1,mm_strdup("with"),$3);
    4060             : }
    4061             : |  index_elem WITH OPERATOR '(' any_operator ')'
    4062             :  { 
    4063           0 :  $$ = cat_str(4,$1,mm_strdup("with operator ("),$5,mm_strdup(")"));
    4064             : }
    4065             : ;
    4066             : 
    4067             : 
    4068             :  ExclusionWhereClause:
    4069             :  WHERE '(' a_expr ')'
    4070             :  { 
    4071           0 :  $$ = cat_str(3,mm_strdup("where ("),$3,mm_strdup(")"));
    4072             : }
    4073             : | 
    4074             :  { 
    4075           0 :  $$=EMPTY; }
    4076             : ;
    4077             : 
    4078             : 
    4079             :  key_actions:
    4080             :  key_update
    4081             :  { 
    4082           0 :  $$ = $1;
    4083             : }
    4084             : |  key_delete
    4085             :  { 
    4086           0 :  $$ = $1;
    4087             : }
    4088             : |  key_update key_delete
    4089             :  { 
    4090           0 :  $$ = cat_str(2,$1,$2);
    4091             : }
    4092             : |  key_delete key_update
    4093             :  { 
    4094           0 :  $$ = cat_str(2,$1,$2);
    4095             : }
    4096             : | 
    4097             :  { 
    4098           0 :  $$=EMPTY; }
    4099             : ;
    4100             : 
    4101             : 
    4102             :  key_update:
    4103             :  ON UPDATE key_action
    4104             :  { 
    4105           0 :  $$ = cat_str(2,mm_strdup("on update"),$3);
    4106             : }
    4107             : ;
    4108             : 
    4109             : 
    4110             :  key_delete:
    4111             :  ON DELETE_P key_action
    4112             :  { 
    4113           0 :  $$ = cat_str(2,mm_strdup("on delete"),$3);
    4114             : }
    4115             : ;
    4116             : 
    4117             : 
    4118             :  key_action:
    4119             :  NO ACTION
    4120             :  { 
    4121           0 :  $$ = mm_strdup("no action");
    4122             : }
    4123             : |  RESTRICT
    4124             :  { 
    4125           0 :  $$ = mm_strdup("restrict");
    4126             : }
    4127             : |  CASCADE
    4128             :  { 
    4129           0 :  $$ = mm_strdup("cascade");
    4130             : }
    4131             : |  SET NULL_P
    4132             :  { 
    4133           0 :  $$ = mm_strdup("set null");
    4134             : }
    4135             : |  SET DEFAULT
    4136             :  { 
    4137           0 :  $$ = mm_strdup("set default");
    4138             : }
    4139             : ;
    4140             : 
    4141             : 
    4142             :  OptInherit:
    4143             :  INHERITS '(' qualified_name_list ')'
    4144             :  { 
    4145           0 :  $$ = cat_str(3,mm_strdup("inherits ("),$3,mm_strdup(")"));
    4146             : }
    4147             : | 
    4148             :  { 
    4149          96 :  $$=EMPTY; }
    4150             : ;
    4151             : 
    4152             : 
    4153             :  OptPartitionSpec:
    4154             :  PartitionSpec
    4155             :  { 
    4156           0 :  $$ = $1;
    4157             : }
    4158             : | 
    4159             :  { 
    4160          96 :  $$=EMPTY; }
    4161             : ;
    4162             : 
    4163             : 
    4164             :  PartitionSpec:
    4165             :  PARTITION BY ColId '(' part_params ')'
    4166             :  { 
    4167           0 :  $$ = cat_str(5,mm_strdup("partition by"),$3,mm_strdup("("),$5,mm_strdup(")"));
    4168             : }
    4169             : ;
    4170             : 
    4171             : 
    4172             :  part_params:
    4173             :  part_elem
    4174             :  { 
    4175           0 :  $$ = $1;
    4176             : }
    4177             : |  part_params ',' part_elem
    4178             :  { 
    4179           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4180             : }
    4181             : ;
    4182             : 
    4183             : 
    4184             :  part_elem:
    4185             :  ColId opt_collate opt_class
    4186             :  { 
    4187           0 :  $$ = cat_str(3,$1,$2,$3);
    4188             : }
    4189             : |  func_expr_windowless opt_collate opt_class
    4190             :  { 
    4191           0 :  $$ = cat_str(3,$1,$2,$3);
    4192             : }
    4193             : |  '(' a_expr ')' opt_collate opt_class
    4194             :  { 
    4195           0 :  $$ = cat_str(5,mm_strdup("("),$2,mm_strdup(")"),$4,$5);
    4196             : }
    4197             : ;
    4198             : 
    4199             : 
    4200             :  table_access_method_clause:
    4201             :  USING name
    4202             :  { 
    4203           0 :  $$ = cat_str(2,mm_strdup("using"),$2);
    4204             : }
    4205             : | 
    4206             :  { 
    4207         100 :  $$=EMPTY; }
    4208             : ;
    4209             : 
    4210             : 
    4211             :  OptWith:
    4212             :  WITH reloptions
    4213             :  { 
    4214           0 :  $$ = cat_str(2,mm_strdup("with"),$2);
    4215             : }
    4216             : |  WITHOUT OIDS
    4217             :  { 
    4218           0 :  $$ = mm_strdup("without oids");
    4219             : }
    4220             : | 
    4221             :  { 
    4222         100 :  $$=EMPTY; }
    4223             : ;
    4224             : 
    4225             : 
    4226             :  OnCommitOption:
    4227             :  ON COMMIT DROP
    4228             :  { 
    4229           0 :  $$ = mm_strdup("on commit drop");
    4230             : }
    4231             : |  ON COMMIT DELETE_P ROWS
    4232             :  { 
    4233           0 :  $$ = mm_strdup("on commit delete rows");
    4234             : }
    4235             : |  ON COMMIT PRESERVE ROWS
    4236             :  { 
    4237           0 :  $$ = mm_strdup("on commit preserve rows");
    4238             : }
    4239             : | 
    4240             :  { 
    4241         100 :  $$=EMPTY; }
    4242             : ;
    4243             : 
    4244             : 
    4245             :  OptTableSpace:
    4246             :  TABLESPACE name
    4247             :  { 
    4248           0 :  $$ = cat_str(2,mm_strdup("tablespace"),$2);
    4249             : }
    4250             : | 
    4251             :  { 
    4252         100 :  $$=EMPTY; }
    4253             : ;
    4254             : 
    4255             : 
    4256             :  OptConsTableSpace:
    4257             :  USING INDEX TABLESPACE name
    4258             :  { 
    4259           0 :  $$ = cat_str(2,mm_strdup("using index tablespace"),$4);
    4260             : }
    4261             : | 
    4262             :  { 
    4263          20 :  $$=EMPTY; }
    4264             : ;
    4265             : 
    4266             : 
    4267             :  ExistingIndex:
    4268             :  USING INDEX name
    4269             :  { 
    4270           0 :  $$ = cat_str(2,mm_strdup("using index"),$3);
    4271             : }
    4272             : ;
    4273             : 
    4274             : 
    4275             :  CreateStatsStmt:
    4276             :  CREATE STATISTICS any_name opt_name_list ON expr_list FROM from_list
    4277             :  { 
    4278           0 :  $$ = cat_str(7,mm_strdup("create statistics"),$3,$4,mm_strdup("on"),$6,mm_strdup("from"),$8);
    4279             : }
    4280             : |  CREATE STATISTICS IF_P NOT EXISTS any_name opt_name_list ON expr_list FROM from_list
    4281             :  { 
    4282           0 :  $$ = cat_str(7,mm_strdup("create statistics if not exists"),$6,$7,mm_strdup("on"),$9,mm_strdup("from"),$11);
    4283             : }
    4284             : ;
    4285             : 
    4286             : 
    4287             :  AlterStatsStmt:
    4288             :  ALTER STATISTICS any_name SET STATISTICS SignedIconst
    4289             :  { 
    4290           0 :  $$ = cat_str(4,mm_strdup("alter statistics"),$3,mm_strdup("set statistics"),$6);
    4291             : }
    4292             : |  ALTER STATISTICS IF_P EXISTS any_name SET STATISTICS SignedIconst
    4293             :  { 
    4294           0 :  $$ = cat_str(4,mm_strdup("alter statistics if exists"),$5,mm_strdup("set statistics"),$8);
    4295             : }
    4296             : ;
    4297             : 
    4298             : 
    4299             :  create_as_target:
    4300             :  qualified_name opt_column_list table_access_method_clause OptWith OnCommitOption OptTableSpace
    4301             :  { 
    4302           4 :  $$ = cat_str(6,$1,$2,$3,$4,$5,$6);
    4303             : }
    4304             : ;
    4305             : 
    4306             : 
    4307             :  opt_with_data:
    4308             :  WITH DATA_P
    4309             :  { 
    4310           0 :  $$ = mm_strdup("with data");
    4311             : }
    4312             : |  WITH NO DATA_P
    4313             :  { 
    4314           2 :  $$ = mm_strdup("with no data");
    4315             : }
    4316             : | 
    4317             :  { 
    4318           2 :  $$=EMPTY; }
    4319             : ;
    4320             : 
    4321             : 
    4322             :  CreateMatViewStmt:
    4323             :  CREATE OptNoLog MATERIALIZED VIEW create_mv_target AS SelectStmt opt_with_data
    4324             :  { 
    4325           0 :  $$ = cat_str(7,mm_strdup("create"),$2,mm_strdup("materialized view"),$5,mm_strdup("as"),$7,$8);
    4326             : }
    4327             : |  CREATE OptNoLog MATERIALIZED VIEW IF_P NOT EXISTS create_mv_target AS SelectStmt opt_with_data
    4328             :  { 
    4329           0 :  $$ = cat_str(7,mm_strdup("create"),$2,mm_strdup("materialized view if not exists"),$8,mm_strdup("as"),$10,$11);
    4330             : }
    4331             : ;
    4332             : 
    4333             : 
    4334             :  create_mv_target:
    4335             :  qualified_name opt_column_list table_access_method_clause opt_reloptions OptTableSpace
    4336             :  { 
    4337           0 :  $$ = cat_str(5,$1,$2,$3,$4,$5);
    4338             : }
    4339             : ;
    4340             : 
    4341             : 
    4342             :  OptNoLog:
    4343             :  UNLOGGED
    4344             :  { 
    4345           0 :  $$ = mm_strdup("unlogged");
    4346             : }
    4347             : | 
    4348             :  { 
    4349           0 :  $$=EMPTY; }
    4350             : ;
    4351             : 
    4352             : 
    4353             :  RefreshMatViewStmt:
    4354             :  REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data
    4355             :  { 
    4356           0 :  $$ = cat_str(4,mm_strdup("refresh materialized view"),$4,$5,$6);
    4357             : }
    4358             : ;
    4359             : 
    4360             : 
    4361             :  CreateSeqStmt:
    4362             :  CREATE OptTemp SEQUENCE qualified_name OptSeqOptList
    4363             :  { 
    4364           0 :  $$ = cat_str(5,mm_strdup("create"),$2,mm_strdup("sequence"),$4,$5);
    4365             : }
    4366             : |  CREATE OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList
    4367             :  { 
    4368           0 :  $$ = cat_str(5,mm_strdup("create"),$2,mm_strdup("sequence if not exists"),$7,$8);
    4369             : }
    4370             : ;
    4371             : 
    4372             : 
    4373             :  AlterSeqStmt:
    4374             :  ALTER SEQUENCE qualified_name SeqOptList
    4375             :  { 
    4376           0 :  $$ = cat_str(3,mm_strdup("alter sequence"),$3,$4);
    4377             : }
    4378             : |  ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList
    4379             :  { 
    4380           0 :  $$ = cat_str(3,mm_strdup("alter sequence if exists"),$5,$6);
    4381             : }
    4382             : ;
    4383             : 
    4384             : 
    4385             :  OptSeqOptList:
    4386             :  SeqOptList
    4387             :  { 
    4388           0 :  $$ = $1;
    4389             : }
    4390             : | 
    4391             :  { 
    4392           0 :  $$=EMPTY; }
    4393             : ;
    4394             : 
    4395             : 
    4396             :  OptParenthesizedSeqOptList:
    4397             :  '(' SeqOptList ')'
    4398             :  { 
    4399           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    4400             : }
    4401             : | 
    4402             :  { 
    4403           0 :  $$=EMPTY; }
    4404             : ;
    4405             : 
    4406             : 
    4407             :  SeqOptList:
    4408             :  SeqOptElem
    4409             :  { 
    4410           0 :  $$ = $1;
    4411             : }
    4412             : |  SeqOptList SeqOptElem
    4413             :  { 
    4414           0 :  $$ = cat_str(2,$1,$2);
    4415             : }
    4416             : ;
    4417             : 
    4418             : 
    4419             :  SeqOptElem:
    4420             :  AS SimpleTypename
    4421             :  { 
    4422           0 :  $$ = cat_str(2,mm_strdup("as"),$2);
    4423             : }
    4424             : |  CACHE NumericOnly
    4425             :  { 
    4426           0 :  $$ = cat_str(2,mm_strdup("cache"),$2);
    4427             : }
    4428             : |  CYCLE
    4429             :  { 
    4430           0 :  $$ = mm_strdup("cycle");
    4431             : }
    4432             : |  NO CYCLE
    4433             :  { 
    4434           0 :  $$ = mm_strdup("no cycle");
    4435             : }
    4436             : |  INCREMENT opt_by NumericOnly
    4437             :  { 
    4438           0 :  $$ = cat_str(3,mm_strdup("increment"),$2,$3);
    4439             : }
    4440             : |  MAXVALUE NumericOnly
    4441             :  { 
    4442           0 :  $$ = cat_str(2,mm_strdup("maxvalue"),$2);
    4443             : }
    4444             : |  MINVALUE NumericOnly
    4445             :  { 
    4446           0 :  $$ = cat_str(2,mm_strdup("minvalue"),$2);
    4447             : }
    4448             : |  NO MAXVALUE
    4449             :  { 
    4450           0 :  $$ = mm_strdup("no maxvalue");
    4451             : }
    4452             : |  NO MINVALUE
    4453             :  { 
    4454           0 :  $$ = mm_strdup("no minvalue");
    4455             : }
    4456             : |  OWNED BY any_name
    4457             :  { 
    4458           0 :  $$ = cat_str(2,mm_strdup("owned by"),$3);
    4459             : }
    4460             : |  SEQUENCE NAME_P any_name
    4461             :  { 
    4462           0 :  $$ = cat_str(2,mm_strdup("sequence name"),$3);
    4463             : }
    4464             : |  START opt_with NumericOnly
    4465             :  { 
    4466           0 :  $$ = cat_str(3,mm_strdup("start"),$2,$3);
    4467             : }
    4468             : |  RESTART
    4469             :  { 
    4470           0 :  $$ = mm_strdup("restart");
    4471             : }
    4472             : |  RESTART opt_with NumericOnly
    4473             :  { 
    4474           0 :  $$ = cat_str(3,mm_strdup("restart"),$2,$3);
    4475             : }
    4476             : ;
    4477             : 
    4478             : 
    4479             :  opt_by:
    4480             :  BY
    4481             :  { 
    4482           0 :  $$ = mm_strdup("by");
    4483             : }
    4484             : | 
    4485             :  { 
    4486           0 :  $$=EMPTY; }
    4487             : ;
    4488             : 
    4489             : 
    4490             :  NumericOnly:
    4491             :  ecpg_fconst
    4492             :  { 
    4493           0 :  $$ = $1;
    4494             : }
    4495             : |  '+' ecpg_fconst
    4496             :  { 
    4497           0 :  $$ = cat_str(2,mm_strdup("+"),$2);
    4498             : }
    4499             : |  '-' ecpg_fconst
    4500             :  { 
    4501           0 :  $$ = cat_str(2,mm_strdup("-"),$2);
    4502             : }
    4503             : |  SignedIconst
    4504             :  { 
    4505           6 :  $$ = $1;
    4506             : }
    4507             : ;
    4508             : 
    4509             : 
    4510             :  NumericOnly_list:
    4511             :  NumericOnly
    4512             :  { 
    4513           0 :  $$ = $1;
    4514             : }
    4515             : |  NumericOnly_list ',' NumericOnly
    4516             :  { 
    4517           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4518             : }
    4519             : ;
    4520             : 
    4521             : 
    4522             :  CreatePLangStmt:
    4523             :  CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name
    4524             :  { 
    4525           0 :  $$ = cat_str(6,mm_strdup("create"),$2,$3,$4,mm_strdup("language"),$6);
    4526             : }
    4527             : |  CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name HANDLER handler_name opt_inline_handler opt_validator
    4528             :  { 
    4529           0 :  $$ = cat_str(10,mm_strdup("create"),$2,$3,$4,mm_strdup("language"),$6,mm_strdup("handler"),$8,$9,$10);
    4530             : }
    4531             : ;
    4532             : 
    4533             : 
    4534             :  opt_trusted:
    4535             :  TRUSTED
    4536             :  { 
    4537           0 :  $$ = mm_strdup("trusted");
    4538             : }
    4539             : | 
    4540             :  { 
    4541           0 :  $$=EMPTY; }
    4542             : ;
    4543             : 
    4544             : 
    4545             :  handler_name:
    4546             :  name
    4547             :  { 
    4548           0 :  $$ = $1;
    4549             : }
    4550             : |  name attrs
    4551             :  { 
    4552           0 :  $$ = cat_str(2,$1,$2);
    4553             : }
    4554             : ;
    4555             : 
    4556             : 
    4557             :  opt_inline_handler:
    4558             :  INLINE_P handler_name
    4559             :  { 
    4560           0 :  $$ = cat_str(2,mm_strdup("inline"),$2);
    4561             : }
    4562             : | 
    4563             :  { 
    4564           0 :  $$=EMPTY; }
    4565             : ;
    4566             : 
    4567             : 
    4568             :  validator_clause:
    4569             :  VALIDATOR handler_name
    4570             :  { 
    4571           0 :  $$ = cat_str(2,mm_strdup("validator"),$2);
    4572             : }
    4573             : |  NO VALIDATOR
    4574             :  { 
    4575           0 :  $$ = mm_strdup("no validator");
    4576             : }
    4577             : ;
    4578             : 
    4579             : 
    4580             :  opt_validator:
    4581             :  validator_clause
    4582             :  { 
    4583           0 :  $$ = $1;
    4584             : }
    4585             : | 
    4586             :  { 
    4587           0 :  $$=EMPTY; }
    4588             : ;
    4589             : 
    4590             : 
    4591             :  opt_procedural:
    4592             :  PROCEDURAL
    4593             :  { 
    4594           0 :  $$ = mm_strdup("procedural");
    4595             : }
    4596             : | 
    4597             :  { 
    4598           0 :  $$=EMPTY; }
    4599             : ;
    4600             : 
    4601             : 
    4602             :  CreateTableSpaceStmt:
    4603             :  CREATE TABLESPACE name OptTableSpaceOwner LOCATION ecpg_sconst opt_reloptions
    4604             :  { 
    4605           0 :  $$ = cat_str(6,mm_strdup("create tablespace"),$3,$4,mm_strdup("location"),$6,$7);
    4606             : }
    4607             : ;
    4608             : 
    4609             : 
    4610             :  OptTableSpaceOwner:
    4611             :  OWNER RoleSpec
    4612             :  { 
    4613           0 :  $$ = cat_str(2,mm_strdup("owner"),$2);
    4614             : }
    4615             : | 
    4616             :  { 
    4617           0 :  $$=EMPTY; }
    4618             : ;
    4619             : 
    4620             : 
    4621             :  DropTableSpaceStmt:
    4622             :  DROP TABLESPACE name
    4623             :  { 
    4624           0 :  $$ = cat_str(2,mm_strdup("drop tablespace"),$3);
    4625             : }
    4626             : |  DROP TABLESPACE IF_P EXISTS name
    4627             :  { 
    4628           0 :  $$ = cat_str(2,mm_strdup("drop tablespace if exists"),$5);
    4629             : }
    4630             : ;
    4631             : 
    4632             : 
    4633             :  CreateExtensionStmt:
    4634             :  CREATE EXTENSION name opt_with create_extension_opt_list
    4635             :  { 
    4636           0 :  $$ = cat_str(4,mm_strdup("create extension"),$3,$4,$5);
    4637             : }
    4638             : |  CREATE EXTENSION IF_P NOT EXISTS name opt_with create_extension_opt_list
    4639             :  { 
    4640           0 :  $$ = cat_str(4,mm_strdup("create extension if not exists"),$6,$7,$8);
    4641             : }
    4642             : ;
    4643             : 
    4644             : 
    4645             :  create_extension_opt_list:
    4646             :  create_extension_opt_list create_extension_opt_item
    4647             :  { 
    4648           0 :  $$ = cat_str(2,$1,$2);
    4649             : }
    4650             : | 
    4651             :  { 
    4652           0 :  $$=EMPTY; }
    4653             : ;
    4654             : 
    4655             : 
    4656             :  create_extension_opt_item:
    4657             :  SCHEMA name
    4658             :  { 
    4659           0 :  $$ = cat_str(2,mm_strdup("schema"),$2);
    4660             : }
    4661             : |  VERSION_P NonReservedWord_or_Sconst
    4662             :  { 
    4663           0 :  $$ = cat_str(2,mm_strdup("version"),$2);
    4664             : }
    4665             : |  FROM NonReservedWord_or_Sconst
    4666             :  { 
    4667           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    4668           0 :  $$ = cat_str(2,mm_strdup("from"),$2);
    4669             : }
    4670             : |  CASCADE
    4671             :  { 
    4672           0 :  $$ = mm_strdup("cascade");
    4673             : }
    4674             : ;
    4675             : 
    4676             : 
    4677             :  AlterExtensionStmt:
    4678             :  ALTER EXTENSION name UPDATE alter_extension_opt_list
    4679             :  { 
    4680           0 :  $$ = cat_str(4,mm_strdup("alter extension"),$3,mm_strdup("update"),$5);
    4681             : }
    4682             : ;
    4683             : 
    4684             : 
    4685             :  alter_extension_opt_list:
    4686             :  alter_extension_opt_list alter_extension_opt_item
    4687             :  { 
    4688           0 :  $$ = cat_str(2,$1,$2);
    4689             : }
    4690             : | 
    4691             :  { 
    4692           0 :  $$=EMPTY; }
    4693             : ;
    4694             : 
    4695             : 
    4696             :  alter_extension_opt_item:
    4697             :  TO NonReservedWord_or_Sconst
    4698             :  { 
    4699           0 :  $$ = cat_str(2,mm_strdup("to"),$2);
    4700             : }
    4701             : ;
    4702             : 
    4703             : 
    4704             :  AlterExtensionContentsStmt:
    4705             :  ALTER EXTENSION name add_drop object_type_name name
    4706             :  { 
    4707           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,$5,$6);
    4708             : }
    4709             : |  ALTER EXTENSION name add_drop object_type_any_name any_name
    4710             :  { 
    4711           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,$5,$6);
    4712             : }
    4713             : |  ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes
    4714             :  { 
    4715           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("aggregate"),$6);
    4716             : }
    4717             : |  ALTER EXTENSION name add_drop CAST '(' Typename AS Typename ')'
    4718             :  { 
    4719           0 :  $$ = cat_str(8,mm_strdup("alter extension"),$3,$4,mm_strdup("cast ("),$7,mm_strdup("as"),$9,mm_strdup(")"));
    4720             : }
    4721             : |  ALTER EXTENSION name add_drop DOMAIN_P Typename
    4722             :  { 
    4723           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("domain"),$6);
    4724             : }
    4725             : |  ALTER EXTENSION name add_drop FUNCTION function_with_argtypes
    4726             :  { 
    4727           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("function"),$6);
    4728             : }
    4729             : |  ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes
    4730             :  { 
    4731           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("operator"),$6);
    4732             : }
    4733             : |  ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name
    4734             :  { 
    4735           0 :  $$ = cat_str(7,mm_strdup("alter extension"),$3,$4,mm_strdup("operator class"),$7,mm_strdup("using"),$9);
    4736             : }
    4737             : |  ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name
    4738             :  { 
    4739           0 :  $$ = cat_str(7,mm_strdup("alter extension"),$3,$4,mm_strdup("operator family"),$7,mm_strdup("using"),$9);
    4740             : }
    4741             : |  ALTER EXTENSION name add_drop PROCEDURE procedure_with_argtypes
    4742             :  { 
    4743           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("procedure"),$6);
    4744             : }
    4745             : |  ALTER EXTENSION name add_drop ROUTINE procedure_with_argtypes
    4746             :  { 
    4747           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("routine"),$6);
    4748             : }
    4749             : |  ALTER EXTENSION name add_drop TRANSFORM FOR Typename LANGUAGE name
    4750             :  { 
    4751           0 :  $$ = cat_str(7,mm_strdup("alter extension"),$3,$4,mm_strdup("transform for"),$7,mm_strdup("language"),$9);
    4752             : }
    4753             : |  ALTER EXTENSION name add_drop TYPE_P Typename
    4754             :  { 
    4755           0 :  $$ = cat_str(5,mm_strdup("alter extension"),$3,$4,mm_strdup("type"),$6);
    4756             : }
    4757             : ;
    4758             : 
    4759             : 
    4760             :  CreateFdwStmt:
    4761             :  CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options
    4762             :  { 
    4763           0 :  $$ = cat_str(4,mm_strdup("create foreign data wrapper"),$5,$6,$7);
    4764             : }
    4765             : ;
    4766             : 
    4767             : 
    4768             :  fdw_option:
    4769             :  HANDLER handler_name
    4770             :  { 
    4771           0 :  $$ = cat_str(2,mm_strdup("handler"),$2);
    4772             : }
    4773             : |  NO HANDLER
    4774             :  { 
    4775           0 :  $$ = mm_strdup("no handler");
    4776             : }
    4777             : |  VALIDATOR handler_name
    4778             :  { 
    4779           0 :  $$ = cat_str(2,mm_strdup("validator"),$2);
    4780             : }
    4781             : |  NO VALIDATOR
    4782             :  { 
    4783           0 :  $$ = mm_strdup("no validator");
    4784             : }
    4785             : ;
    4786             : 
    4787             : 
    4788             :  fdw_options:
    4789             :  fdw_option
    4790             :  { 
    4791           0 :  $$ = $1;
    4792             : }
    4793             : |  fdw_options fdw_option
    4794             :  { 
    4795           0 :  $$ = cat_str(2,$1,$2);
    4796             : }
    4797             : ;
    4798             : 
    4799             : 
    4800             :  opt_fdw_options:
    4801             :  fdw_options
    4802             :  { 
    4803           0 :  $$ = $1;
    4804             : }
    4805             : | 
    4806             :  { 
    4807           0 :  $$=EMPTY; }
    4808             : ;
    4809             : 
    4810             : 
    4811             :  AlterFdwStmt:
    4812             :  ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options
    4813             :  { 
    4814           0 :  $$ = cat_str(4,mm_strdup("alter foreign data wrapper"),$5,$6,$7);
    4815             : }
    4816             : |  ALTER FOREIGN DATA_P WRAPPER name fdw_options
    4817             :  { 
    4818           0 :  $$ = cat_str(3,mm_strdup("alter foreign data wrapper"),$5,$6);
    4819             : }
    4820             : ;
    4821             : 
    4822             : 
    4823             :  create_generic_options:
    4824             :  OPTIONS '(' generic_option_list ')'
    4825             :  { 
    4826           0 :  $$ = cat_str(3,mm_strdup("options ("),$3,mm_strdup(")"));
    4827             : }
    4828             : | 
    4829             :  { 
    4830         296 :  $$=EMPTY; }
    4831             : ;
    4832             : 
    4833             : 
    4834             :  generic_option_list:
    4835             :  generic_option_elem
    4836             :  { 
    4837           0 :  $$ = $1;
    4838             : }
    4839             : |  generic_option_list ',' generic_option_elem
    4840             :  { 
    4841           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4842             : }
    4843             : ;
    4844             : 
    4845             : 
    4846             :  alter_generic_options:
    4847             :  OPTIONS '(' alter_generic_option_list ')'
    4848             :  { 
    4849           0 :  $$ = cat_str(3,mm_strdup("options ("),$3,mm_strdup(")"));
    4850             : }
    4851             : ;
    4852             : 
    4853             : 
    4854             :  alter_generic_option_list:
    4855             :  alter_generic_option_elem
    4856             :  { 
    4857           0 :  $$ = $1;
    4858             : }
    4859             : |  alter_generic_option_list ',' alter_generic_option_elem
    4860             :  { 
    4861           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    4862             : }
    4863             : ;
    4864             : 
    4865             : 
    4866             :  alter_generic_option_elem:
    4867             :  generic_option_elem
    4868             :  { 
    4869           0 :  $$ = $1;
    4870             : }
    4871             : |  SET generic_option_elem
    4872             :  { 
    4873           0 :  $$ = cat_str(2,mm_strdup("set"),$2);
    4874             : }
    4875             : |  ADD_P generic_option_elem
    4876             :  { 
    4877           0 :  $$ = cat_str(2,mm_strdup("add"),$2);
    4878             : }
    4879             : |  DROP generic_option_name
    4880             :  { 
    4881           0 :  $$ = cat_str(2,mm_strdup("drop"),$2);
    4882             : }
    4883             : ;
    4884             : 
    4885             : 
    4886             :  generic_option_elem:
    4887             :  generic_option_name generic_option_arg
    4888             :  { 
    4889           0 :  $$ = cat_str(2,$1,$2);
    4890             : }
    4891             : ;
    4892             : 
    4893             : 
    4894             :  generic_option_name:
    4895             :  ColLabel
    4896             :  { 
    4897           0 :  $$ = $1;
    4898             : }
    4899             : ;
    4900             : 
    4901             : 
    4902             :  generic_option_arg:
    4903             :  ecpg_sconst
    4904             :  { 
    4905           0 :  $$ = $1;
    4906             : }
    4907             : ;
    4908             : 
    4909             : 
    4910             :  CreateForeignServerStmt:
    4911             :  CREATE SERVER name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options
    4912             :  { 
    4913           0 :  $$ = cat_str(7,mm_strdup("create server"),$3,$4,$5,mm_strdup("foreign data wrapper"),$9,$10);
    4914             : }
    4915             : |  CREATE SERVER IF_P NOT EXISTS name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options
    4916             :  { 
    4917           0 :  $$ = cat_str(7,mm_strdup("create server if not exists"),$6,$7,$8,mm_strdup("foreign data wrapper"),$12,$13);
    4918             : }
    4919             : ;
    4920             : 
    4921             : 
    4922             :  opt_type:
    4923             :  TYPE_P ecpg_sconst
    4924             :  { 
    4925           0 :  $$ = cat_str(2,mm_strdup("type"),$2);
    4926             : }
    4927             : | 
    4928             :  { 
    4929           0 :  $$=EMPTY; }
    4930             : ;
    4931             : 
    4932             : 
    4933             :  foreign_server_version:
    4934             :  VERSION_P ecpg_sconst
    4935             :  { 
    4936           0 :  $$ = cat_str(2,mm_strdup("version"),$2);
    4937             : }
    4938             : |  VERSION_P NULL_P
    4939             :  { 
    4940           0 :  $$ = mm_strdup("version null");
    4941             : }
    4942             : ;
    4943             : 
    4944             : 
    4945             :  opt_foreign_server_version:
    4946             :  foreign_server_version
    4947             :  { 
    4948           0 :  $$ = $1;
    4949             : }
    4950             : | 
    4951             :  { 
    4952           0 :  $$=EMPTY; }
    4953             : ;
    4954             : 
    4955             : 
    4956             :  AlterForeignServerStmt:
    4957             :  ALTER SERVER name foreign_server_version alter_generic_options
    4958             :  { 
    4959           0 :  $$ = cat_str(4,mm_strdup("alter server"),$3,$4,$5);
    4960             : }
    4961             : |  ALTER SERVER name foreign_server_version
    4962             :  { 
    4963           0 :  $$ = cat_str(3,mm_strdup("alter server"),$3,$4);
    4964             : }
    4965             : |  ALTER SERVER name alter_generic_options
    4966             :  { 
    4967           0 :  $$ = cat_str(3,mm_strdup("alter server"),$3,$4);
    4968             : }
    4969             : ;
    4970             : 
    4971             : 
    4972             :  CreateForeignTableStmt:
    4973             :  CREATE FOREIGN TABLE qualified_name '(' OptTableElementList ')' OptInherit SERVER name create_generic_options
    4974             :  { 
    4975           0 :  $$ = cat_str(9,mm_strdup("create foreign table"),$4,mm_strdup("("),$6,mm_strdup(")"),$8,mm_strdup("server"),$10,$11);
    4976             : }
    4977             : |  CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name '(' OptTableElementList ')' OptInherit SERVER name create_generic_options
    4978             :  { 
    4979           0 :  $$ = cat_str(9,mm_strdup("create foreign table if not exists"),$7,mm_strdup("("),$9,mm_strdup(")"),$11,mm_strdup("server"),$13,$14);
    4980             : }
    4981             : |  CREATE FOREIGN TABLE qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec SERVER name create_generic_options
    4982             :  { 
    4983           0 :  $$ = cat_str(9,mm_strdup("create foreign table"),$4,mm_strdup("partition of"),$7,$8,$9,mm_strdup("server"),$11,$12);
    4984             : }
    4985             : |  CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec SERVER name create_generic_options
    4986             :  { 
    4987           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);
    4988             : }
    4989             : ;
    4990             : 
    4991             : 
    4992             :  ImportForeignSchemaStmt:
    4993             :  IMPORT_P FOREIGN SCHEMA name import_qualification FROM SERVER name INTO name create_generic_options
    4994             :  { 
    4995           0 :  $$ = cat_str(8,mm_strdup("import foreign schema"),$4,$5,mm_strdup("from server"),$8,mm_strdup("into"),$10,$11);
    4996             : }
    4997             : ;
    4998             : 
    4999             : 
    5000             :  import_qualification_type:
    5001             :  LIMIT TO
    5002             :  { 
    5003           0 :  $$ = mm_strdup("limit to");
    5004             : }
    5005             : |  EXCEPT
    5006             :  { 
    5007           0 :  $$ = mm_strdup("except");
    5008             : }
    5009             : ;
    5010             : 
    5011             : 
    5012             :  import_qualification:
    5013             :  import_qualification_type '(' relation_expr_list ')'
    5014             :  { 
    5015           0 :  $$ = cat_str(4,$1,mm_strdup("("),$3,mm_strdup(")"));
    5016             : }
    5017             : | 
    5018             :  { 
    5019           0 :  $$=EMPTY; }
    5020             : ;
    5021             : 
    5022             : 
    5023             :  CreateUserMappingStmt:
    5024             :  CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
    5025             :  { 
    5026           0 :  $$ = cat_str(5,mm_strdup("create user mapping for"),$5,mm_strdup("server"),$7,$8);
    5027             : }
    5028             : |  CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options
    5029             :  { 
    5030           0 :  $$ = cat_str(5,mm_strdup("create user mapping if not exists for"),$8,mm_strdup("server"),$10,$11);
    5031             : }
    5032             : ;
    5033             : 
    5034             : 
    5035             :  auth_ident:
    5036             :  RoleSpec
    5037             :  { 
    5038           0 :  $$ = $1;
    5039             : }
    5040             : |  USER
    5041             :  { 
    5042           0 :  $$ = mm_strdup("user");
    5043             : }
    5044             : ;
    5045             : 
    5046             : 
    5047             :  DropUserMappingStmt:
    5048             :  DROP USER MAPPING FOR auth_ident SERVER name
    5049             :  { 
    5050           0 :  $$ = cat_str(4,mm_strdup("drop user mapping for"),$5,mm_strdup("server"),$7);
    5051             : }
    5052             : |  DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
    5053             :  { 
    5054           0 :  $$ = cat_str(4,mm_strdup("drop user mapping if exists for"),$7,mm_strdup("server"),$9);
    5055             : }
    5056             : ;
    5057             : 
    5058             : 
    5059             :  AlterUserMappingStmt:
    5060             :  ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
    5061             :  { 
    5062           0 :  $$ = cat_str(5,mm_strdup("alter user mapping for"),$5,mm_strdup("server"),$7,$8);
    5063             : }
    5064             : ;
    5065             : 
    5066             : 
    5067             :  CreatePolicyStmt:
    5068             :  CREATE POLICY name ON qualified_name RowSecurityDefaultPermissive RowSecurityDefaultForCmd RowSecurityDefaultToRole RowSecurityOptionalExpr RowSecurityOptionalWithCheck
    5069             :  { 
    5070           0 :  $$ = cat_str(9,mm_strdup("create policy"),$3,mm_strdup("on"),$5,$6,$7,$8,$9,$10);
    5071             : }
    5072             : ;
    5073             : 
    5074             : 
    5075             :  AlterPolicyStmt:
    5076             :  ALTER POLICY name ON qualified_name RowSecurityOptionalToRole RowSecurityOptionalExpr RowSecurityOptionalWithCheck
    5077             :  { 
    5078           0 :  $$ = cat_str(7,mm_strdup("alter policy"),$3,mm_strdup("on"),$5,$6,$7,$8);
    5079             : }
    5080             : ;
    5081             : 
    5082             : 
    5083             :  RowSecurityOptionalExpr:
    5084             :  USING '(' a_expr ')'
    5085             :  { 
    5086           0 :  $$ = cat_str(3,mm_strdup("using ("),$3,mm_strdup(")"));
    5087             : }
    5088             : | 
    5089             :  { 
    5090           0 :  $$=EMPTY; }
    5091             : ;
    5092             : 
    5093             : 
    5094             :  RowSecurityOptionalWithCheck:
    5095             :  WITH CHECK '(' a_expr ')'
    5096             :  { 
    5097           0 :  $$ = cat_str(3,mm_strdup("with check ("),$4,mm_strdup(")"));
    5098             : }
    5099             : | 
    5100             :  { 
    5101           0 :  $$=EMPTY; }
    5102             : ;
    5103             : 
    5104             : 
    5105             :  RowSecurityDefaultToRole:
    5106             :  TO role_list
    5107             :  { 
    5108           0 :  $$ = cat_str(2,mm_strdup("to"),$2);
    5109             : }
    5110             : | 
    5111             :  { 
    5112           0 :  $$=EMPTY; }
    5113             : ;
    5114             : 
    5115             : 
    5116             :  RowSecurityOptionalToRole:
    5117             :  TO role_list
    5118             :  { 
    5119           0 :  $$ = cat_str(2,mm_strdup("to"),$2);
    5120             : }
    5121             : | 
    5122             :  { 
    5123           0 :  $$=EMPTY; }
    5124             : ;
    5125             : 
    5126             : 
    5127             :  RowSecurityDefaultPermissive:
    5128             :  AS ecpg_ident
    5129             :  { 
    5130           0 :  $$ = cat_str(2,mm_strdup("as"),$2);
    5131             : }
    5132             : | 
    5133             :  { 
    5134           0 :  $$=EMPTY; }
    5135             : ;
    5136             : 
    5137             : 
    5138             :  RowSecurityDefaultForCmd:
    5139             :  FOR row_security_cmd
    5140             :  { 
    5141           0 :  $$ = cat_str(2,mm_strdup("for"),$2);
    5142             : }
    5143             : | 
    5144             :  { 
    5145           0 :  $$=EMPTY; }
    5146             : ;
    5147             : 
    5148             : 
    5149             :  row_security_cmd:
    5150             :  ALL
    5151             :  { 
    5152           0 :  $$ = mm_strdup("all");
    5153             : }
    5154             : |  SELECT
    5155             :  { 
    5156           0 :  $$ = mm_strdup("select");
    5157             : }
    5158             : |  INSERT
    5159             :  { 
    5160           0 :  $$ = mm_strdup("insert");
    5161             : }
    5162             : |  UPDATE
    5163             :  { 
    5164           0 :  $$ = mm_strdup("update");
    5165             : }
    5166             : |  DELETE_P
    5167             :  { 
    5168           0 :  $$ = mm_strdup("delete");
    5169             : }
    5170             : ;
    5171             : 
    5172             : 
    5173             :  CreateAmStmt:
    5174             :  CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name
    5175             :  { 
    5176           0 :  $$ = cat_str(6,mm_strdup("create access method"),$4,mm_strdup("type"),$6,mm_strdup("handler"),$8);
    5177             : }
    5178             : ;
    5179             : 
    5180             : 
    5181             :  am_type:
    5182             :  INDEX
    5183             :  { 
    5184           0 :  $$ = mm_strdup("index");
    5185             : }
    5186             : |  TABLE
    5187             :  { 
    5188           0 :  $$ = mm_strdup("table");
    5189             : }
    5190             : ;
    5191             : 
    5192             : 
    5193             :  CreateTrigStmt:
    5194             :  CREATE opt_or_replace TRIGGER name TriggerActionTime TriggerEvents ON qualified_name TriggerReferencing TriggerForSpec TriggerWhen EXECUTE FUNCTION_or_PROCEDURE func_name '(' TriggerFuncArgs ')'
    5195             :  { 
    5196           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(")"));
    5197             : }
    5198             : |  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 ')'
    5199             :  { 
    5200           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    5201           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(")"));
    5202             : }
    5203             : ;
    5204             : 
    5205             : 
    5206             :  TriggerActionTime:
    5207             :  BEFORE
    5208             :  { 
    5209           2 :  $$ = mm_strdup("before");
    5210             : }
    5211             : |  AFTER
    5212             :  { 
    5213           0 :  $$ = mm_strdup("after");
    5214             : }
    5215             : |  INSTEAD OF
    5216             :  { 
    5217           0 :  $$ = mm_strdup("instead of");
    5218             : }
    5219             : ;
    5220             : 
    5221             : 
    5222             :  TriggerEvents:
    5223             :  TriggerOneEvent
    5224             :  { 
    5225           2 :  $$ = $1;
    5226             : }
    5227             : |  TriggerEvents OR TriggerOneEvent
    5228             :  { 
    5229           0 :  $$ = cat_str(3,$1,mm_strdup("or"),$3);
    5230             : }
    5231             : ;
    5232             : 
    5233             : 
    5234             :  TriggerOneEvent:
    5235             :  INSERT
    5236             :  { 
    5237           2 :  $$ = mm_strdup("insert");
    5238             : }
    5239             : |  DELETE_P
    5240             :  { 
    5241           0 :  $$ = mm_strdup("delete");
    5242             : }
    5243             : |  UPDATE
    5244             :  { 
    5245           0 :  $$ = mm_strdup("update");
    5246             : }
    5247             : |  UPDATE OF columnList
    5248             :  { 
    5249           0 :  $$ = cat_str(2,mm_strdup("update of"),$3);
    5250             : }
    5251             : |  TRUNCATE
    5252             :  { 
    5253           0 :  $$ = mm_strdup("truncate");
    5254             : }
    5255             : ;
    5256             : 
    5257             : 
    5258             :  TriggerReferencing:
    5259             :  REFERENCING TriggerTransitions
    5260             :  { 
    5261           0 :  $$ = cat_str(2,mm_strdup("referencing"),$2);
    5262             : }
    5263             : | 
    5264             :  { 
    5265           2 :  $$=EMPTY; }
    5266             : ;
    5267             : 
    5268             : 
    5269             :  TriggerTransitions:
    5270             :  TriggerTransition
    5271             :  { 
    5272           0 :  $$ = $1;
    5273             : }
    5274             : |  TriggerTransitions TriggerTransition
    5275             :  { 
    5276           0 :  $$ = cat_str(2,$1,$2);
    5277             : }
    5278             : ;
    5279             : 
    5280             : 
    5281             :  TriggerTransition:
    5282             :  TransitionOldOrNew TransitionRowOrTable opt_as TransitionRelName
    5283             :  { 
    5284           0 :  $$ = cat_str(4,$1,$2,$3,$4);
    5285             : }
    5286             : ;
    5287             : 
    5288             : 
    5289             :  TransitionOldOrNew:
    5290             :  NEW
    5291             :  { 
    5292           0 :  $$ = mm_strdup("new");
    5293             : }
    5294             : |  OLD
    5295             :  { 
    5296           0 :  $$ = mm_strdup("old");
    5297             : }
    5298             : ;
    5299             : 
    5300             : 
    5301             :  TransitionRowOrTable:
    5302             :  TABLE
    5303             :  { 
    5304           0 :  $$ = mm_strdup("table");
    5305             : }
    5306             : |  ROW
    5307             :  { 
    5308           0 :  $$ = mm_strdup("row");
    5309             : }
    5310             : ;
    5311             : 
    5312             : 
    5313             :  TransitionRelName:
    5314             :  ColId
    5315             :  { 
    5316           0 :  $$ = $1;
    5317             : }
    5318             : ;
    5319             : 
    5320             : 
    5321             :  TriggerForSpec:
    5322             :  FOR TriggerForOptEach TriggerForType
    5323             :  { 
    5324           2 :  $$ = cat_str(3,mm_strdup("for"),$2,$3);
    5325             : }
    5326             : | 
    5327             :  { 
    5328           0 :  $$=EMPTY; }
    5329             : ;
    5330             : 
    5331             : 
    5332             :  TriggerForOptEach:
    5333             :  EACH
    5334             :  { 
    5335           2 :  $$ = mm_strdup("each");
    5336             : }
    5337             : | 
    5338             :  { 
    5339           0 :  $$=EMPTY; }
    5340             : ;
    5341             : 
    5342             : 
    5343             :  TriggerForType:
    5344             :  ROW
    5345             :  { 
    5346           2 :  $$ = mm_strdup("row");
    5347             : }
    5348             : |  STATEMENT
    5349             :  { 
    5350           0 :  $$ = mm_strdup("statement");
    5351             : }
    5352             : ;
    5353             : 
    5354             : 
    5355             :  TriggerWhen:
    5356             :  WHEN '(' a_expr ')'
    5357             :  { 
    5358           0 :  $$ = cat_str(3,mm_strdup("when ("),$3,mm_strdup(")"));
    5359             : }
    5360             : | 
    5361             :  { 
    5362           2 :  $$=EMPTY; }
    5363             : ;
    5364             : 
    5365             : 
    5366             :  FUNCTION_or_PROCEDURE:
    5367             :  FUNCTION
    5368             :  { 
    5369           0 :  $$ = mm_strdup("function");
    5370             : }
    5371             : |  PROCEDURE
    5372             :  { 
    5373           2 :  $$ = mm_strdup("procedure");
    5374             : }
    5375             : ;
    5376             : 
    5377             : 
    5378             :  TriggerFuncArgs:
    5379             :  TriggerFuncArg
    5380             :  { 
    5381           0 :  $$ = $1;
    5382             : }
    5383             : |  TriggerFuncArgs ',' TriggerFuncArg
    5384             :  { 
    5385           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5386             : }
    5387             : | 
    5388             :  { 
    5389           2 :  $$=EMPTY; }
    5390             : ;
    5391             : 
    5392             : 
    5393             :  TriggerFuncArg:
    5394             :  Iconst
    5395             :  { 
    5396           0 :  $$ = $1;
    5397             : }
    5398             : |  ecpg_fconst
    5399             :  { 
    5400           0 :  $$ = $1;
    5401             : }
    5402             : |  ecpg_sconst
    5403             :  { 
    5404           0 :  $$ = $1;
    5405             : }
    5406             : |  ColLabel
    5407             :  { 
    5408           0 :  $$ = $1;
    5409             : }
    5410             : ;
    5411             : 
    5412             : 
    5413             :  OptConstrFromTable:
    5414             :  FROM qualified_name
    5415             :  { 
    5416           0 :  $$ = cat_str(2,mm_strdup("from"),$2);
    5417             : }
    5418             : | 
    5419             :  { 
    5420           0 :  $$=EMPTY; }
    5421             : ;
    5422             : 
    5423             : 
    5424             :  ConstraintAttributeSpec:
    5425             : 
    5426             :  { 
    5427           4 :  $$=EMPTY; }
    5428             : |  ConstraintAttributeSpec ConstraintAttributeElem
    5429             :  { 
    5430           0 :  $$ = cat_str(2,$1,$2);
    5431             : }
    5432             : ;
    5433             : 
    5434             : 
    5435             :  ConstraintAttributeElem:
    5436             :  NOT DEFERRABLE
    5437             :  { 
    5438           0 :  $$ = mm_strdup("not deferrable");
    5439             : }
    5440             : |  DEFERRABLE
    5441             :  { 
    5442           0 :  $$ = mm_strdup("deferrable");
    5443             : }
    5444             : |  INITIALLY IMMEDIATE
    5445             :  { 
    5446           0 :  $$ = mm_strdup("initially immediate");
    5447             : }
    5448             : |  INITIALLY DEFERRED
    5449             :  { 
    5450           0 :  $$ = mm_strdup("initially deferred");
    5451             : }
    5452             : |  NOT VALID
    5453             :  { 
    5454           0 :  $$ = mm_strdup("not valid");
    5455             : }
    5456             : |  NO INHERIT
    5457             :  { 
    5458           0 :  $$ = mm_strdup("no inherit");
    5459             : }
    5460             : ;
    5461             : 
    5462             : 
    5463             :  CreateEventTrigStmt:
    5464             :  CREATE EVENT TRIGGER name ON ColLabel EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
    5465             :  { 
    5466           0 :  $$ = cat_str(8,mm_strdup("create event trigger"),$4,mm_strdup("on"),$6,mm_strdup("execute"),$8,$9,mm_strdup("( )"));
    5467             : }
    5468             : |  CREATE EVENT TRIGGER name ON ColLabel WHEN event_trigger_when_list EXECUTE FUNCTION_or_PROCEDURE func_name '(' ')'
    5469             :  { 
    5470           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("( )"));
    5471             : }
    5472             : ;
    5473             : 
    5474             : 
    5475             :  event_trigger_when_list:
    5476             :  event_trigger_when_item
    5477             :  { 
    5478           0 :  $$ = $1;
    5479             : }
    5480             : |  event_trigger_when_list AND event_trigger_when_item
    5481             :  { 
    5482           0 :  $$ = cat_str(3,$1,mm_strdup("and"),$3);
    5483             : }
    5484             : ;
    5485             : 
    5486             : 
    5487             :  event_trigger_when_item:
    5488             :  ColId IN_P '(' event_trigger_value_list ')'
    5489             :  { 
    5490           0 :  $$ = cat_str(4,$1,mm_strdup("in ("),$4,mm_strdup(")"));
    5491             : }
    5492             : ;
    5493             : 
    5494             : 
    5495             :  event_trigger_value_list:
    5496             :  SCONST
    5497             :  { 
    5498           0 :  $$ = mm_strdup("sconst");
    5499             : }
    5500             : |  event_trigger_value_list ',' SCONST
    5501             :  { 
    5502           0 :  $$ = cat_str(2,$1,mm_strdup(", sconst"));
    5503             : }
    5504             : ;
    5505             : 
    5506             : 
    5507             :  AlterEventTrigStmt:
    5508             :  ALTER EVENT TRIGGER name enable_trigger
    5509             :  { 
    5510           0 :  $$ = cat_str(3,mm_strdup("alter event trigger"),$4,$5);
    5511             : }
    5512             : ;
    5513             : 
    5514             : 
    5515             :  enable_trigger:
    5516             :  ENABLE_P
    5517             :  { 
    5518           0 :  $$ = mm_strdup("enable");
    5519             : }
    5520             : |  ENABLE_P REPLICA
    5521             :  { 
    5522           0 :  $$ = mm_strdup("enable replica");
    5523             : }
    5524             : |  ENABLE_P ALWAYS
    5525             :  { 
    5526           0 :  $$ = mm_strdup("enable always");
    5527             : }
    5528             : |  DISABLE_P
    5529             :  { 
    5530           0 :  $$ = mm_strdup("disable");
    5531             : }
    5532             : ;
    5533             : 
    5534             : 
    5535             :  CreateAssertionStmt:
    5536             :  CREATE ASSERTION any_name CHECK '(' a_expr ')' ConstraintAttributeSpec
    5537             :  { 
    5538           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    5539           0 :  $$ = cat_str(6,mm_strdup("create assertion"),$3,mm_strdup("check ("),$6,mm_strdup(")"),$8);
    5540             : }
    5541             : ;
    5542             : 
    5543             : 
    5544             :  DefineStmt:
    5545             :  CREATE opt_or_replace AGGREGATE func_name aggr_args definition
    5546             :  { 
    5547           0 :  $$ = cat_str(6,mm_strdup("create"),$2,mm_strdup("aggregate"),$4,$5,$6);
    5548             : }
    5549             : |  CREATE opt_or_replace AGGREGATE func_name old_aggr_definition
    5550             :  { 
    5551           0 :  $$ = cat_str(5,mm_strdup("create"),$2,mm_strdup("aggregate"),$4,$5);
    5552             : }
    5553             : |  CREATE OPERATOR any_operator definition
    5554             :  { 
    5555           0 :  $$ = cat_str(3,mm_strdup("create operator"),$3,$4);
    5556             : }
    5557             : |  CREATE TYPE_P any_name definition
    5558             :  { 
    5559           0 :  $$ = cat_str(3,mm_strdup("create type"),$3,$4);
    5560             : }
    5561             : |  CREATE TYPE_P any_name
    5562             :  { 
    5563           0 :  $$ = cat_str(2,mm_strdup("create type"),$3);
    5564             : }
    5565             : |  CREATE TYPE_P any_name AS '(' OptTableFuncElementList ')'
    5566             :  { 
    5567           0 :  $$ = cat_str(5,mm_strdup("create type"),$3,mm_strdup("as ("),$6,mm_strdup(")"));
    5568             : }
    5569             : |  CREATE TYPE_P any_name AS ENUM_P '(' opt_enum_val_list ')'
    5570             :  { 
    5571           0 :  $$ = cat_str(5,mm_strdup("create type"),$3,mm_strdup("as enum ("),$7,mm_strdup(")"));
    5572             : }
    5573             : |  CREATE TYPE_P any_name AS RANGE definition
    5574             :  { 
    5575           0 :  $$ = cat_str(4,mm_strdup("create type"),$3,mm_strdup("as range"),$6);
    5576             : }
    5577             : |  CREATE TEXT_P SEARCH PARSER any_name definition
    5578             :  { 
    5579           0 :  $$ = cat_str(3,mm_strdup("create text search parser"),$5,$6);
    5580             : }
    5581             : |  CREATE TEXT_P SEARCH DICTIONARY any_name definition
    5582             :  { 
    5583           0 :  $$ = cat_str(3,mm_strdup("create text search dictionary"),$5,$6);
    5584             : }
    5585             : |  CREATE TEXT_P SEARCH TEMPLATE any_name definition
    5586             :  { 
    5587           0 :  $$ = cat_str(3,mm_strdup("create text search template"),$5,$6);
    5588             : }
    5589             : |  CREATE TEXT_P SEARCH CONFIGURATION any_name definition
    5590             :  { 
    5591           0 :  $$ = cat_str(3,mm_strdup("create text search configuration"),$5,$6);
    5592             : }
    5593             : |  CREATE COLLATION any_name definition
    5594             :  { 
    5595           0 :  $$ = cat_str(3,mm_strdup("create collation"),$3,$4);
    5596             : }
    5597             : |  CREATE COLLATION IF_P NOT EXISTS any_name definition
    5598             :  { 
    5599           0 :  $$ = cat_str(3,mm_strdup("create collation if not exists"),$6,$7);
    5600             : }
    5601             : |  CREATE COLLATION any_name FROM any_name
    5602             :  { 
    5603           0 :  $$ = cat_str(4,mm_strdup("create collation"),$3,mm_strdup("from"),$5);
    5604             : }
    5605             : |  CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name
    5606             :  { 
    5607           0 :  $$ = cat_str(4,mm_strdup("create collation if not exists"),$6,mm_strdup("from"),$8);
    5608             : }
    5609             : ;
    5610             : 
    5611             : 
    5612             :  definition:
    5613             :  '(' def_list ')'
    5614             :  { 
    5615           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    5616             : }
    5617             : ;
    5618             : 
    5619             : 
    5620             :  def_list:
    5621             :  def_elem
    5622             :  { 
    5623           0 :  $$ = $1;
    5624             : }
    5625             : |  def_list ',' def_elem
    5626             :  { 
    5627           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5628             : }
    5629             : ;
    5630             : 
    5631             : 
    5632             :  def_elem:
    5633             :  ColLabel '=' def_arg
    5634             :  { 
    5635           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    5636             : }
    5637             : |  ColLabel
    5638             :  { 
    5639           0 :  $$ = $1;
    5640             : }
    5641             : ;
    5642             : 
    5643             : 
    5644             :  def_arg:
    5645             :  func_type
    5646             :  { 
    5647           0 :  $$ = $1;
    5648             : }
    5649             : |  reserved_keyword
    5650             :  { 
    5651           0 :  $$ = $1;
    5652             : }
    5653             : |  qual_all_Op
    5654             :  { 
    5655           0 :  $$ = $1;
    5656             : }
    5657             : |  NumericOnly
    5658             :  { 
    5659           0 :  $$ = $1;
    5660             : }
    5661             : |  ecpg_sconst
    5662             :  { 
    5663           0 :  $$ = $1;
    5664             : }
    5665             : |  NONE
    5666             :  { 
    5667           0 :  $$ = mm_strdup("none");
    5668             : }
    5669             : ;
    5670             : 
    5671             : 
    5672             :  old_aggr_definition:
    5673             :  '(' old_aggr_list ')'
    5674             :  { 
    5675           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    5676             : }
    5677             : ;
    5678             : 
    5679             : 
    5680             :  old_aggr_list:
    5681             :  old_aggr_elem
    5682             :  { 
    5683           0 :  $$ = $1;
    5684             : }
    5685             : |  old_aggr_list ',' old_aggr_elem
    5686             :  { 
    5687           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5688             : }
    5689             : ;
    5690             : 
    5691             : 
    5692             :  old_aggr_elem:
    5693             :  ecpg_ident '=' def_arg
    5694             :  { 
    5695           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    5696             : }
    5697             : ;
    5698             : 
    5699             : 
    5700             :  opt_enum_val_list:
    5701             :  enum_val_list
    5702             :  { 
    5703           0 :  $$ = $1;
    5704             : }
    5705             : | 
    5706             :  { 
    5707           0 :  $$=EMPTY; }
    5708             : ;
    5709             : 
    5710             : 
    5711             :  enum_val_list:
    5712             :  ecpg_sconst
    5713             :  { 
    5714           0 :  $$ = $1;
    5715             : }
    5716             : |  enum_val_list ',' ecpg_sconst
    5717             :  { 
    5718           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5719             : }
    5720             : ;
    5721             : 
    5722             : 
    5723             :  AlterEnumStmt:
    5724             :  ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst
    5725             :  { 
    5726           0 :  $$ = cat_str(5,mm_strdup("alter type"),$3,mm_strdup("add value"),$6,$7);
    5727             : }
    5728             : |  ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst BEFORE ecpg_sconst
    5729             :  { 
    5730           0 :  $$ = cat_str(7,mm_strdup("alter type"),$3,mm_strdup("add value"),$6,$7,mm_strdup("before"),$9);
    5731             : }
    5732             : |  ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists ecpg_sconst AFTER ecpg_sconst
    5733             :  { 
    5734           0 :  $$ = cat_str(7,mm_strdup("alter type"),$3,mm_strdup("add value"),$6,$7,mm_strdup("after"),$9);
    5735             : }
    5736             : |  ALTER TYPE_P any_name RENAME VALUE_P ecpg_sconst TO ecpg_sconst
    5737             :  { 
    5738           0 :  $$ = cat_str(6,mm_strdup("alter type"),$3,mm_strdup("rename value"),$6,mm_strdup("to"),$8);
    5739             : }
    5740             : ;
    5741             : 
    5742             : 
    5743             :  opt_if_not_exists:
    5744             :  IF_P NOT EXISTS
    5745             :  { 
    5746           0 :  $$ = mm_strdup("if not exists");
    5747             : }
    5748             : | 
    5749             :  { 
    5750           0 :  $$=EMPTY; }
    5751             : ;
    5752             : 
    5753             : 
    5754             :  CreateOpClassStmt:
    5755             :  CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename USING name opt_opfamily AS opclass_item_list
    5756             :  { 
    5757           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);
    5758             : }
    5759             : ;
    5760             : 
    5761             : 
    5762             :  opclass_item_list:
    5763             :  opclass_item
    5764             :  { 
    5765           0 :  $$ = $1;
    5766             : }
    5767             : |  opclass_item_list ',' opclass_item
    5768             :  { 
    5769           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5770             : }
    5771             : ;
    5772             : 
    5773             : 
    5774             :  opclass_item:
    5775             :  OPERATOR Iconst any_operator opclass_purpose opt_recheck
    5776             :  { 
    5777           0 :  $$ = cat_str(5,mm_strdup("operator"),$2,$3,$4,$5);
    5778             : }
    5779             : |  OPERATOR Iconst operator_with_argtypes opclass_purpose opt_recheck
    5780             :  { 
    5781           0 :  $$ = cat_str(5,mm_strdup("operator"),$2,$3,$4,$5);
    5782             : }
    5783             : |  FUNCTION Iconst function_with_argtypes
    5784             :  { 
    5785           0 :  $$ = cat_str(3,mm_strdup("function"),$2,$3);
    5786             : }
    5787             : |  FUNCTION Iconst '(' type_list ')' function_with_argtypes
    5788             :  { 
    5789           0 :  $$ = cat_str(6,mm_strdup("function"),$2,mm_strdup("("),$4,mm_strdup(")"),$6);
    5790             : }
    5791             : |  STORAGE Typename
    5792             :  { 
    5793           0 :  $$ = cat_str(2,mm_strdup("storage"),$2);
    5794             : }
    5795             : ;
    5796             : 
    5797             : 
    5798             :  opt_default:
    5799             :  DEFAULT
    5800             :  { 
    5801           0 :  $$ = mm_strdup("default");
    5802             : }
    5803             : | 
    5804             :  { 
    5805           0 :  $$=EMPTY; }
    5806             : ;
    5807             : 
    5808             : 
    5809             :  opt_opfamily:
    5810             :  FAMILY any_name
    5811             :  { 
    5812           0 :  $$ = cat_str(2,mm_strdup("family"),$2);
    5813             : }
    5814             : | 
    5815             :  { 
    5816           0 :  $$=EMPTY; }
    5817             : ;
    5818             : 
    5819             : 
    5820             :  opclass_purpose:
    5821             :  FOR SEARCH
    5822             :  { 
    5823           0 :  $$ = mm_strdup("for search");
    5824             : }
    5825             : |  FOR ORDER BY any_name
    5826             :  { 
    5827           0 :  $$ = cat_str(2,mm_strdup("for order by"),$4);
    5828             : }
    5829             : | 
    5830             :  { 
    5831           0 :  $$=EMPTY; }
    5832             : ;
    5833             : 
    5834             : 
    5835             :  opt_recheck:
    5836             :  RECHECK
    5837             :  { 
    5838           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    5839           0 :  $$ = mm_strdup("recheck");
    5840             : }
    5841             : | 
    5842             :  { 
    5843           0 :  $$=EMPTY; }
    5844             : ;
    5845             : 
    5846             : 
    5847             :  CreateOpFamilyStmt:
    5848             :  CREATE OPERATOR FAMILY any_name USING name
    5849             :  { 
    5850           0 :  $$ = cat_str(4,mm_strdup("create operator family"),$4,mm_strdup("using"),$6);
    5851             : }
    5852             : ;
    5853             : 
    5854             : 
    5855             :  AlterOpFamilyStmt:
    5856             :  ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list
    5857             :  { 
    5858           0 :  $$ = cat_str(6,mm_strdup("alter operator family"),$4,mm_strdup("using"),$6,mm_strdup("add"),$8);
    5859             : }
    5860             : |  ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list
    5861             :  { 
    5862           0 :  $$ = cat_str(6,mm_strdup("alter operator family"),$4,mm_strdup("using"),$6,mm_strdup("drop"),$8);
    5863             : }
    5864             : ;
    5865             : 
    5866             : 
    5867             :  opclass_drop_list:
    5868             :  opclass_drop
    5869             :  { 
    5870           0 :  $$ = $1;
    5871             : }
    5872             : |  opclass_drop_list ',' opclass_drop
    5873             :  { 
    5874           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    5875             : }
    5876             : ;
    5877             : 
    5878             : 
    5879             :  opclass_drop:
    5880             :  OPERATOR Iconst '(' type_list ')'
    5881             :  { 
    5882           0 :  $$ = cat_str(5,mm_strdup("operator"),$2,mm_strdup("("),$4,mm_strdup(")"));
    5883             : }
    5884             : |  FUNCTION Iconst '(' type_list ')'
    5885             :  { 
    5886           0 :  $$ = cat_str(5,mm_strdup("function"),$2,mm_strdup("("),$4,mm_strdup(")"));
    5887             : }
    5888             : ;
    5889             : 
    5890             : 
    5891             :  DropOpClassStmt:
    5892             :  DROP OPERATOR CLASS any_name USING name opt_drop_behavior
    5893             :  { 
    5894           0 :  $$ = cat_str(5,mm_strdup("drop operator class"),$4,mm_strdup("using"),$6,$7);
    5895             : }
    5896             : |  DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior
    5897             :  { 
    5898           0 :  $$ = cat_str(5,mm_strdup("drop operator class if exists"),$6,mm_strdup("using"),$8,$9);
    5899             : }
    5900             : ;
    5901             : 
    5902             : 
    5903             :  DropOpFamilyStmt:
    5904             :  DROP OPERATOR FAMILY any_name USING name opt_drop_behavior
    5905             :  { 
    5906           0 :  $$ = cat_str(5,mm_strdup("drop operator family"),$4,mm_strdup("using"),$6,$7);
    5907             : }
    5908             : |  DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior
    5909             :  { 
    5910           0 :  $$ = cat_str(5,mm_strdup("drop operator family if exists"),$6,mm_strdup("using"),$8,$9);
    5911             : }
    5912             : ;
    5913             : 
    5914             : 
    5915             :  DropOwnedStmt:
    5916             :  DROP OWNED BY role_list opt_drop_behavior
    5917             :  { 
    5918           0 :  $$ = cat_str(3,mm_strdup("drop owned by"),$4,$5);
    5919             : }
    5920             : ;
    5921             : 
    5922             : 
    5923             :  ReassignOwnedStmt:
    5924             :  REASSIGN OWNED BY role_list TO RoleSpec
    5925             :  { 
    5926           0 :  $$ = cat_str(4,mm_strdup("reassign owned by"),$4,mm_strdup("to"),$6);
    5927             : }
    5928             : ;
    5929             : 
    5930             : 
    5931             :  DropStmt:
    5932             :  DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior
    5933             :  { 
    5934           2 :  $$ = cat_str(5,mm_strdup("drop"),$2,mm_strdup("if exists"),$5,$6);
    5935             : }
    5936             : |  DROP object_type_any_name any_name_list opt_drop_behavior
    5937             :  { 
    5938          68 :  $$ = cat_str(4,mm_strdup("drop"),$2,$3,$4);
    5939             : }
    5940             : |  DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior
    5941             :  { 
    5942           0 :  $$ = cat_str(5,mm_strdup("drop"),$2,mm_strdup("if exists"),$5,$6);
    5943             : }
    5944             : |  DROP drop_type_name name_list opt_drop_behavior
    5945             :  { 
    5946           0 :  $$ = cat_str(4,mm_strdup("drop"),$2,$3,$4);
    5947             : }
    5948             : |  DROP object_type_name_on_any_name name ON any_name opt_drop_behavior
    5949             :  { 
    5950           2 :  $$ = cat_str(6,mm_strdup("drop"),$2,$3,mm_strdup("on"),$5,$6);
    5951             : }
    5952             : |  DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior
    5953             :  { 
    5954           0 :  $$ = cat_str(7,mm_strdup("drop"),$2,mm_strdup("if exists"),$5,mm_strdup("on"),$7,$8);
    5955             : }
    5956             : |  DROP TYPE_P type_name_list opt_drop_behavior
    5957             :  { 
    5958           0 :  $$ = cat_str(3,mm_strdup("drop type"),$3,$4);
    5959             : }
    5960             : |  DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior
    5961             :  { 
    5962           0 :  $$ = cat_str(3,mm_strdup("drop type if exists"),$5,$6);
    5963             : }
    5964             : |  DROP DOMAIN_P type_name_list opt_drop_behavior
    5965             :  { 
    5966           0 :  $$ = cat_str(3,mm_strdup("drop domain"),$3,$4);
    5967             : }
    5968             : |  DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior
    5969             :  { 
    5970           0 :  $$ = cat_str(3,mm_strdup("drop domain if exists"),$5,$6);
    5971             : }
    5972             : |  DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior
    5973             :  { 
    5974           0 :  $$ = cat_str(3,mm_strdup("drop index concurrently"),$4,$5);
    5975             : }
    5976             : |  DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior
    5977             :  { 
    5978           0 :  $$ = cat_str(3,mm_strdup("drop index concurrently if exists"),$6,$7);
    5979             : }
    5980             : ;
    5981             : 
    5982             : 
    5983             :  object_type_any_name:
    5984             :  TABLE
    5985             :  { 
    5986          70 :  $$ = mm_strdup("table");
    5987             : }
    5988             : |  SEQUENCE
    5989             :  { 
    5990           0 :  $$ = mm_strdup("sequence");
    5991             : }
    5992             : |  VIEW
    5993             :  { 
    5994           0 :  $$ = mm_strdup("view");
    5995             : }
    5996             : |  MATERIALIZED VIEW
    5997             :  { 
    5998           0 :  $$ = mm_strdup("materialized view");
    5999             : }
    6000             : |  INDEX
    6001             :  { 
    6002           0 :  $$ = mm_strdup("index");
    6003             : }
    6004             : |  FOREIGN TABLE
    6005             :  { 
    6006           0 :  $$ = mm_strdup("foreign table");
    6007             : }
    6008             : |  COLLATION
    6009             :  { 
    6010           0 :  $$ = mm_strdup("collation");
    6011             : }
    6012             : |  CONVERSION_P
    6013             :  { 
    6014           0 :  $$ = mm_strdup("conversion");
    6015             : }
    6016             : |  STATISTICS
    6017             :  { 
    6018           0 :  $$ = mm_strdup("statistics");
    6019             : }
    6020             : |  TEXT_P SEARCH PARSER
    6021             :  { 
    6022           0 :  $$ = mm_strdup("text search parser");
    6023             : }
    6024             : |  TEXT_P SEARCH DICTIONARY
    6025             :  { 
    6026           0 :  $$ = mm_strdup("text search dictionary");
    6027             : }
    6028             : |  TEXT_P SEARCH TEMPLATE
    6029             :  { 
    6030           0 :  $$ = mm_strdup("text search template");
    6031             : }
    6032             : |  TEXT_P SEARCH CONFIGURATION
    6033             :  { 
    6034           0 :  $$ = mm_strdup("text search configuration");
    6035             : }
    6036             : ;
    6037             : 
    6038             : 
    6039             :  object_type_name:
    6040             :  drop_type_name
    6041             :  { 
    6042           0 :  $$ = $1;
    6043             : }
    6044             : |  DATABASE
    6045             :  { 
    6046           0 :  $$ = mm_strdup("database");
    6047             : }
    6048             : |  ROLE
    6049             :  { 
    6050           0 :  $$ = mm_strdup("role");
    6051             : }
    6052             : |  SUBSCRIPTION
    6053             :  { 
    6054           0 :  $$ = mm_strdup("subscription");
    6055             : }
    6056             : |  TABLESPACE
    6057             :  { 
    6058           0 :  $$ = mm_strdup("tablespace");
    6059             : }
    6060             : ;
    6061             : 
    6062             : 
    6063             :  drop_type_name:
    6064             :  ACCESS METHOD
    6065             :  { 
    6066           0 :  $$ = mm_strdup("access method");
    6067             : }
    6068             : |  EVENT TRIGGER
    6069             :  { 
    6070           0 :  $$ = mm_strdup("event trigger");
    6071             : }
    6072             : |  EXTENSION
    6073             :  { 
    6074           0 :  $$ = mm_strdup("extension");
    6075             : }
    6076             : |  FOREIGN DATA_P WRAPPER
    6077             :  { 
    6078           0 :  $$ = mm_strdup("foreign data wrapper");
    6079             : }
    6080             : |  opt_procedural LANGUAGE
    6081             :  { 
    6082           0 :  $$ = cat_str(2,$1,mm_strdup("language"));
    6083             : }
    6084             : |  PUBLICATION
    6085             :  { 
    6086           0 :  $$ = mm_strdup("publication");
    6087             : }
    6088             : |  SCHEMA
    6089             :  { 
    6090           0 :  $$ = mm_strdup("schema");
    6091             : }
    6092             : |  SERVER
    6093             :  { 
    6094           0 :  $$ = mm_strdup("server");
    6095             : }
    6096             : ;
    6097             : 
    6098             : 
    6099             :  object_type_name_on_any_name:
    6100             :  POLICY
    6101             :  { 
    6102           0 :  $$ = mm_strdup("policy");
    6103             : }
    6104             : |  RULE
    6105             :  { 
    6106           0 :  $$ = mm_strdup("rule");
    6107             : }
    6108             : |  TRIGGER
    6109             :  { 
    6110           2 :  $$ = mm_strdup("trigger");
    6111             : }
    6112             : ;
    6113             : 
    6114             : 
    6115             :  any_name_list:
    6116             :  any_name
    6117             :  { 
    6118          70 :  $$ = $1;
    6119             : }
    6120             : |  any_name_list ',' any_name
    6121             :  { 
    6122           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    6123             : }
    6124             : ;
    6125             : 
    6126             : 
    6127             :  any_name:
    6128             :  ColId
    6129             :  { 
    6130          74 :  $$ = $1;
    6131             : }
    6132             : |  ColId attrs
    6133             :  { 
    6134           0 :  $$ = cat_str(2,$1,$2);
    6135             : }
    6136             : ;
    6137             : 
    6138             : 
    6139             :  attrs:
    6140             :  '.' attr_name
    6141             :  { 
    6142           0 :  $$ = cat_str(2,mm_strdup("."),$2);
    6143             : }
    6144             : |  attrs '.' attr_name
    6145             :  { 
    6146           0 :  $$ = cat_str(3,$1,mm_strdup("."),$3);
    6147             : }
    6148             : ;
    6149             : 
    6150             : 
    6151             :  type_name_list:
    6152             :  Typename
    6153             :  { 
    6154           0 :  $$ = $1;
    6155             : }
    6156             : |  type_name_list ',' Typename
    6157             :  { 
    6158           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    6159             : }
    6160             : ;
    6161             : 
    6162             : 
    6163             :  TruncateStmt:
    6164             :  TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior
    6165             :  { 
    6166          44 :  $$ = cat_str(5,mm_strdup("truncate"),$2,$3,$4,$5);
    6167             : }
    6168             : ;
    6169             : 
    6170             : 
    6171             :  opt_restart_seqs:
    6172             :  CONTINUE_P IDENTITY_P
    6173             :  { 
    6174           0 :  $$ = mm_strdup("continue identity");
    6175             : }
    6176             : |  RESTART IDENTITY_P
    6177             :  { 
    6178           0 :  $$ = mm_strdup("restart identity");
    6179             : }
    6180             : | 
    6181             :  { 
    6182          44 :  $$=EMPTY; }
    6183             : ;
    6184             : 
    6185             : 
    6186             :  CommentStmt:
    6187             :  COMMENT ON object_type_any_name any_name IS comment_text
    6188             :  { 
    6189           0 :  $$ = cat_str(5,mm_strdup("comment on"),$3,$4,mm_strdup("is"),$6);
    6190             : }
    6191             : |  COMMENT ON COLUMN any_name IS comment_text
    6192             :  { 
    6193           0 :  $$ = cat_str(4,mm_strdup("comment on column"),$4,mm_strdup("is"),$6);
    6194             : }
    6195             : |  COMMENT ON object_type_name name IS comment_text
    6196             :  { 
    6197           0 :  $$ = cat_str(5,mm_strdup("comment on"),$3,$4,mm_strdup("is"),$6);
    6198             : }
    6199             : |  COMMENT ON TYPE_P Typename IS comment_text
    6200             :  { 
    6201           0 :  $$ = cat_str(4,mm_strdup("comment on type"),$4,mm_strdup("is"),$6);
    6202             : }
    6203             : |  COMMENT ON DOMAIN_P Typename IS comment_text
    6204             :  { 
    6205           0 :  $$ = cat_str(4,mm_strdup("comment on domain"),$4,mm_strdup("is"),$6);
    6206             : }
    6207             : |  COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text
    6208             :  { 
    6209           0 :  $$ = cat_str(4,mm_strdup("comment on aggregate"),$4,mm_strdup("is"),$6);
    6210             : }
    6211             : |  COMMENT ON FUNCTION function_with_argtypes IS comment_text
    6212             :  { 
    6213           0 :  $$ = cat_str(4,mm_strdup("comment on function"),$4,mm_strdup("is"),$6);
    6214             : }
    6215             : |  COMMENT ON OPERATOR operator_with_argtypes IS comment_text
    6216             :  { 
    6217           0 :  $$ = cat_str(4,mm_strdup("comment on operator"),$4,mm_strdup("is"),$6);
    6218             : }
    6219             : |  COMMENT ON CONSTRAINT name ON any_name IS comment_text
    6220             :  { 
    6221           0 :  $$ = cat_str(6,mm_strdup("comment on constraint"),$4,mm_strdup("on"),$6,mm_strdup("is"),$8);
    6222             : }
    6223             : |  COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text
    6224             :  { 
    6225           0 :  $$ = cat_str(6,mm_strdup("comment on constraint"),$4,mm_strdup("on domain"),$7,mm_strdup("is"),$9);
    6226             : }
    6227             : |  COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text
    6228             :  { 
    6229           0 :  $$ = cat_str(7,mm_strdup("comment on"),$3,$4,mm_strdup("on"),$6,mm_strdup("is"),$8);
    6230             : }
    6231             : |  COMMENT ON PROCEDURE procedure_with_argtypes IS comment_text
    6232             :  { 
    6233           0 :  $$ = cat_str(4,mm_strdup("comment on procedure"),$4,mm_strdup("is"),$6);
    6234             : }
    6235             : |  COMMENT ON ROUTINE procedure_with_argtypes IS comment_text
    6236             :  { 
    6237           0 :  $$ = cat_str(4,mm_strdup("comment on routine"),$4,mm_strdup("is"),$6);
    6238             : }
    6239             : |  COMMENT ON TRANSFORM FOR Typename LANGUAGE name IS comment_text
    6240             :  { 
    6241           0 :  $$ = cat_str(6,mm_strdup("comment on transform for"),$5,mm_strdup("language"),$7,mm_strdup("is"),$9);
    6242             : }
    6243             : |  COMMENT ON OPERATOR CLASS any_name USING name IS comment_text
    6244             :  { 
    6245           0 :  $$ = cat_str(6,mm_strdup("comment on operator class"),$5,mm_strdup("using"),$7,mm_strdup("is"),$9);
    6246             : }
    6247             : |  COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text
    6248             :  { 
    6249           0 :  $$ = cat_str(6,mm_strdup("comment on operator family"),$5,mm_strdup("using"),$7,mm_strdup("is"),$9);
    6250             : }
    6251             : |  COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
    6252             :  { 
    6253           0 :  $$ = cat_str(4,mm_strdup("comment on large object"),$5,mm_strdup("is"),$7);
    6254             : }
    6255             : |  COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
    6256             :  { 
    6257           0 :  $$ = cat_str(6,mm_strdup("comment on cast ("),$5,mm_strdup("as"),$7,mm_strdup(") is"),$10);
    6258             : }
    6259             : ;
    6260             : 
    6261             : 
    6262             :  comment_text:
    6263             :  ecpg_sconst
    6264             :  { 
    6265           0 :  $$ = $1;
    6266             : }
    6267             : |  NULL_P
    6268             :  { 
    6269           0 :  $$ = mm_strdup("null");
    6270             : }
    6271             : ;
    6272             : 
    6273             : 
    6274             :  SecLabelStmt:
    6275             :  SECURITY LABEL opt_provider ON object_type_any_name any_name IS security_label
    6276             :  { 
    6277           0 :  $$ = cat_str(7,mm_strdup("security label"),$3,mm_strdup("on"),$5,$6,mm_strdup("is"),$8);
    6278             : }
    6279             : |  SECURITY LABEL opt_provider ON COLUMN any_name IS security_label
    6280             :  { 
    6281           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on column"),$6,mm_strdup("is"),$8);
    6282             : }
    6283             : |  SECURITY LABEL opt_provider ON object_type_name name IS security_label
    6284             :  { 
    6285           0 :  $$ = cat_str(7,mm_strdup("security label"),$3,mm_strdup("on"),$5,$6,mm_strdup("is"),$8);
    6286             : }
    6287             : |  SECURITY LABEL opt_provider ON TYPE_P Typename IS security_label
    6288             :  { 
    6289           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on type"),$6,mm_strdup("is"),$8);
    6290             : }
    6291             : |  SECURITY LABEL opt_provider ON DOMAIN_P Typename IS security_label
    6292             :  { 
    6293           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on domain"),$6,mm_strdup("is"),$8);
    6294             : }
    6295             : |  SECURITY LABEL opt_provider ON AGGREGATE aggregate_with_argtypes IS security_label
    6296             :  { 
    6297           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on aggregate"),$6,mm_strdup("is"),$8);
    6298             : }
    6299             : |  SECURITY LABEL opt_provider ON FUNCTION function_with_argtypes IS security_label
    6300             :  { 
    6301           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on function"),$6,mm_strdup("is"),$8);
    6302             : }
    6303             : |  SECURITY LABEL opt_provider ON LARGE_P OBJECT_P NumericOnly IS security_label
    6304             :  { 
    6305           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on large object"),$7,mm_strdup("is"),$9);
    6306             : }
    6307             : |  SECURITY LABEL opt_provider ON PROCEDURE procedure_with_argtypes IS security_label
    6308             :  { 
    6309           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on procedure"),$6,mm_strdup("is"),$8);
    6310             : }
    6311             : |  SECURITY LABEL opt_provider ON ROUTINE function_with_argtypes IS security_label
    6312             :  { 
    6313           0 :  $$ = cat_str(6,mm_strdup("security label"),$3,mm_strdup("on routine"),$6,mm_strdup("is"),$8);
    6314             : }
    6315             : ;
    6316             : 
    6317             : 
    6318             :  opt_provider:
    6319             :  FOR NonReservedWord_or_Sconst
    6320             :  { 
    6321           0 :  $$ = cat_str(2,mm_strdup("for"),$2);
    6322             : }
    6323             : | 
    6324             :  { 
    6325           0 :  $$=EMPTY; }
    6326             : ;
    6327             : 
    6328             : 
    6329             :  security_label:
    6330             :  ecpg_sconst
    6331             :  { 
    6332           0 :  $$ = $1;
    6333             : }
    6334             : |  NULL_P
    6335             :  { 
    6336           0 :  $$ = mm_strdup("null");
    6337             : }
    6338             : ;
    6339             : 
    6340             : 
    6341             :  FetchStmt:
    6342             :  FETCH fetch_args
    6343             :  { 
    6344          14 :  $$ = cat_str(2,mm_strdup("fetch"),$2);
    6345             : }
    6346             : |  MOVE fetch_args
    6347             :  { 
    6348          10 :  $$ = cat_str(2,mm_strdup("move"),$2);
    6349             : }
    6350             :     | FETCH fetch_args ecpg_fetch_into
    6351             :     {
    6352          86 :         $$ = cat2_str(mm_strdup("fetch"), $2);
    6353             :     }
    6354             :     | FETCH FORWARD cursor_name opt_ecpg_fetch_into
    6355             :     {
    6356           4 :         char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
    6357           4 :         add_additional_variables($3, false);
    6358           4 :         $$ = cat_str(2, mm_strdup("fetch forward"), cursor_marker);
    6359             :     }
    6360             :     | FETCH FORWARD from_in cursor_name opt_ecpg_fetch_into
    6361             :     {
    6362           2 :         char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
    6363           2 :         add_additional_variables($4, false);
    6364           2 :         $$ = cat_str(2, mm_strdup("fetch forward from"), cursor_marker);
    6365             :     }
    6366             :     | FETCH BACKWARD cursor_name opt_ecpg_fetch_into
    6367             :     {
    6368           0 :         char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
    6369           0 :         add_additional_variables($3, false);
    6370           0 :         $$ = cat_str(2, mm_strdup("fetch backward"), cursor_marker);
    6371             :     }
    6372             :     | FETCH BACKWARD from_in cursor_name opt_ecpg_fetch_into
    6373             :     {
    6374           0 :         char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
    6375           0 :         add_additional_variables($4, false);
    6376           0 :         $$ = cat_str(2, mm_strdup("fetch backward from"), cursor_marker);
    6377             :     }
    6378             :     | MOVE FORWARD cursor_name
    6379             :     {
    6380           0 :         char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
    6381           0 :         add_additional_variables($3, false);
    6382           0 :         $$ = cat_str(2, mm_strdup("move forward"), cursor_marker);
    6383             :     }
    6384             :     | MOVE FORWARD from_in cursor_name
    6385             :     {
    6386           0 :         char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
    6387           0 :         add_additional_variables($4, false);
    6388           0 :         $$ = cat_str(2, mm_strdup("move forward from"), cursor_marker);
    6389             :     }
    6390             :     | MOVE BACKWARD cursor_name
    6391             :     {
    6392           0 :         char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
    6393           0 :         add_additional_variables($3, false);
    6394           0 :         $$ = cat_str(2, mm_strdup("move backward"), cursor_marker);
    6395             :     }
    6396             :     | MOVE BACKWARD from_in cursor_name
    6397             :     {
    6398           0 :         char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
    6399           0 :         add_additional_variables($4, false);
    6400           0 :         $$ = cat_str(2, mm_strdup("move backward from"), cursor_marker);
    6401             :     }
    6402             : ;
    6403             : 
    6404             : 
    6405             :  fetch_args:
    6406             :  cursor_name
    6407             :  { 
    6408          24 :         add_additional_variables($1, false);
    6409          24 :         if ($1[0] == ':')
    6410             :         {
    6411           6 :             free($1);
    6412           6 :             $1 = mm_strdup("$0");
    6413             :         }
    6414             : 
    6415          24 :  $$ = $1;
    6416             : }
    6417             : |  from_in cursor_name
    6418             :  { 
    6419          22 :         add_additional_variables($2, false);
    6420          22 :         if ($2[0] == ':')
    6421             :         {
    6422           6 :             free($2);
    6423           6 :             $2 = mm_strdup("$0");
    6424             :         }
    6425             : 
    6426          22 :  $$ = cat_str(2,$1,$2);
    6427             : }
    6428             : |  NEXT opt_from_in cursor_name
    6429             :  { 
    6430           4 :         add_additional_variables($3, false);
    6431           4 :         if ($3[0] == ':')
    6432             :         {
    6433           0 :             free($3);
    6434           0 :             $3 = mm_strdup("$0");
    6435             :         }
    6436             : 
    6437           4 :  $$ = cat_str(3,mm_strdup("next"),$2,$3);
    6438             : }
    6439             : |  PRIOR opt_from_in cursor_name
    6440             :  { 
    6441           0 :         add_additional_variables($3, false);
    6442           0 :         if ($3[0] == ':')
    6443             :         {
    6444           0 :             free($3);
    6445           0 :             $3 = mm_strdup("$0");
    6446             :         }
    6447             : 
    6448           0 :  $$ = cat_str(3,mm_strdup("prior"),$2,$3);
    6449             : }
    6450             : |  FIRST_P opt_from_in cursor_name
    6451             :  { 
    6452           0 :         add_additional_variables($3, false);
    6453           0 :         if ($3[0] == ':')
    6454             :         {
    6455           0 :             free($3);
    6456           0 :             $3 = mm_strdup("$0");
    6457             :         }
    6458             : 
    6459           0 :  $$ = cat_str(3,mm_strdup("first"),$2,$3);
    6460             : }
    6461             : |  LAST_P opt_from_in cursor_name
    6462             :  { 
    6463           0 :         add_additional_variables($3, false);
    6464           0 :         if ($3[0] == ':')
    6465             :         {
    6466           0 :             free($3);
    6467           0 :             $3 = mm_strdup("$0");
    6468             :         }
    6469             : 
    6470           0 :  $$ = cat_str(3,mm_strdup("last"),$2,$3);
    6471             : }
    6472             : |  ABSOLUTE_P SignedIconst opt_from_in cursor_name
    6473             :  { 
    6474           8 :         add_additional_variables($4, false);
    6475           8 :         if ($4[0] == ':')
    6476             :         {
    6477           8 :             free($4);
    6478           8 :             $4 = mm_strdup("$0");
    6479             :         }
    6480           8 :         if ($2[0] == '$')
    6481             :         {
    6482           0 :             free($2);
    6483           0 :             $2 = mm_strdup("$0");
    6484             :         }
    6485             : 
    6486           8 :  $$ = cat_str(4,mm_strdup("absolute"),$2,$3,$4);
    6487             : }
    6488             : |  RELATIVE_P SignedIconst opt_from_in cursor_name
    6489             :  { 
    6490           0 :         add_additional_variables($4, false);
    6491           0 :         if ($4[0] == ':')
    6492             :         {
    6493           0 :             free($4);
    6494           0 :             $4 = mm_strdup("$0");
    6495             :         }
    6496           0 :         if ($2[0] == '$')
    6497             :         {
    6498           0 :             free($2);
    6499           0 :             $2 = mm_strdup("$0");
    6500             :         }
    6501             : 
    6502           0 :  $$ = cat_str(4,mm_strdup("relative"),$2,$3,$4);
    6503             : }
    6504             : |  SignedIconst opt_from_in cursor_name
    6505             :  { 
    6506          48 :         add_additional_variables($3, false);
    6507          48 :         if ($3[0] == ':')
    6508             :         {
    6509          32 :             free($3);
    6510          32 :             $3 = mm_strdup("$0");
    6511             :         }
    6512          48 :         if ($1[0] == '$')
    6513             :         {
    6514          18 :             free($1);
    6515          18 :             $1 = mm_strdup("$0");
    6516             :         }
    6517             : 
    6518          48 :  $$ = cat_str(3,$1,$2,$3);
    6519             : }
    6520             : |  ALL opt_from_in cursor_name
    6521             :  { 
    6522           2 :         add_additional_variables($3, false);
    6523           2 :         if ($3[0] == ':')
    6524             :         {
    6525           0 :             free($3);
    6526           0 :             $3 = mm_strdup("$0");
    6527             :         }
    6528             : 
    6529           2 :  $$ = cat_str(3,mm_strdup("all"),$2,$3);
    6530             : }
    6531             : |  FORWARD SignedIconst opt_from_in cursor_name
    6532             :  { 
    6533           0 :         add_additional_variables($4, false);
    6534           0 :         if ($4[0] == ':')
    6535             :         {
    6536           0 :             free($4);
    6537           0 :             $4 = mm_strdup("$0");
    6538             :         }
    6539           0 :         if ($2[0] == '$')
    6540             :         {
    6541           0 :             free($2);
    6542           0 :             $2 = mm_strdup("$0");
    6543             :         }
    6544             : 
    6545           0 :  $$ = cat_str(4,mm_strdup("forward"),$2,$3,$4);
    6546             : }
    6547             : |  FORWARD ALL opt_from_in cursor_name
    6548             :  { 
    6549           0 :         add_additional_variables($4, false);
    6550           0 :         if ($4[0] == ':')
    6551             :         {
    6552           0 :             free($4);
    6553           0 :             $4 = mm_strdup("$0");
    6554             :         }
    6555             : 
    6556           0 :  $$ = cat_str(3,mm_strdup("forward all"),$3,$4);
    6557             : }
    6558             : |  BACKWARD SignedIconst opt_from_in cursor_name
    6559             :  { 
    6560           2 :         add_additional_variables($4, false);
    6561           2 :         if ($4[0] == ':')
    6562             :         {
    6563           0 :             free($4);
    6564           0 :             $4 = mm_strdup("$0");
    6565             :         }
    6566           2 :         if ($2[0] == '$')
    6567             :         {
    6568           0 :             free($2);
    6569           0 :             $2 = mm_strdup("$0");
    6570             :         }
    6571             : 
    6572           2 :  $$ = cat_str(4,mm_strdup("backward"),$2,$3,$4);
    6573             : }
    6574             : |  BACKWARD ALL opt_from_in cursor_name
    6575             :  { 
    6576           0 :         add_additional_variables($4, false);
    6577           0 :         if ($4[0] == ':')
    6578             :         {
    6579           0 :             free($4);
    6580           0 :             $4 = mm_strdup("$0");
    6581             :         }
    6582             : 
    6583           0 :  $$ = cat_str(3,mm_strdup("backward all"),$3,$4);
    6584             : }
    6585             : ;
    6586             : 
    6587             : 
    6588             :  from_in:
    6589             :  FROM
    6590             :  { 
    6591          44 :  $$ = mm_strdup("from");
    6592             : }
    6593             : |  IN_P
    6594             :  { 
    6595          22 :  $$ = mm_strdup("in");
    6596             : }
    6597             : ;
    6598             : 
    6599             : 
    6600             :  opt_from_in:
    6601             :  from_in
    6602             :  { 
    6603          42 :  $$ = $1;
    6604             : }
    6605             : | 
    6606             :  { 
    6607          22 :  $$=EMPTY; }
    6608             : ;
    6609             : 
    6610             : 
    6611             :  GrantStmt:
    6612             :  GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option
    6613             :  { 
    6614           0 :  $$ = cat_str(7,mm_strdup("grant"),$2,mm_strdup("on"),$4,mm_strdup("to"),$6,$7);
    6615             : }
    6616             : ;
    6617             : 
    6618             : 
    6619             :  RevokeStmt:
    6620             :  REVOKE privileges ON privilege_target FROM grantee_list opt_drop_behavior
    6621             :  { 
    6622           0 :  $$ = cat_str(7,mm_strdup("revoke"),$2,mm_strdup("on"),$4,mm_strdup("from"),$6,$7);
    6623             : }
    6624             : |  REVOKE GRANT OPTION FOR privileges ON privilege_target FROM grantee_list opt_drop_behavior
    6625             :  { 
    6626           0 :  $$ = cat_str(7,mm_strdup("revoke grant option for"),$5,mm_strdup("on"),$7,mm_strdup("from"),$9,$10);
    6627             : }
    6628             : ;
    6629             : 
    6630             : 
    6631             :  privileges:
    6632             :  privilege_list
    6633             :  { 
    6634           0 :  $$ = $1;
    6635             : }
    6636             : |  ALL
    6637             :  { 
    6638           0 :  $$ = mm_strdup("all");
    6639             : }
    6640             : |  ALL PRIVILEGES
    6641             :  { 
    6642           0 :  $$ = mm_strdup("all privileges");
    6643             : }
    6644             : |  ALL '(' columnList ')'
    6645             :  { 
    6646           0 :  $$ = cat_str(3,mm_strdup("all ("),$3,mm_strdup(")"));
    6647             : }
    6648             : |  ALL PRIVILEGES '(' columnList ')'
    6649             :  { 
    6650           0 :  $$ = cat_str(3,mm_strdup("all privileges ("),$4,mm_strdup(")"));
    6651             : }
    6652             : ;
    6653             : 
    6654             : 
    6655             :  privilege_list:
    6656             :  privilege
    6657             :  { 
    6658           0 :  $$ = $1;
    6659             : }
    6660             : |  privilege_list ',' privilege
    6661             :  { 
    6662           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    6663             : }
    6664             : ;
    6665             : 
    6666             : 
    6667             :  privilege:
    6668             :  SELECT opt_column_list
    6669             :  { 
    6670           0 :  $$ = cat_str(2,mm_strdup("select"),$2);
    6671             : }
    6672             : |  REFERENCES opt_column_list
    6673             :  { 
    6674           0 :  $$ = cat_str(2,mm_strdup("references"),$2);
    6675             : }
    6676             : |  CREATE opt_column_list
    6677             :  { 
    6678           0 :  $$ = cat_str(2,mm_strdup("create"),$2);
    6679             : }
    6680             : |  ColId opt_column_list
    6681             :  { 
    6682           0 :  $$ = cat_str(2,$1,$2);
    6683             : }
    6684             : ;
    6685             : 
    6686             : 
    6687             :  privilege_target:
    6688             :  qualified_name_list
    6689             :  { 
    6690           0 :  $$ = $1;
    6691             : }
    6692             : |  TABLE qualified_name_list
    6693             :  { 
    6694           0 :  $$ = cat_str(2,mm_strdup("table"),$2);
    6695             : }
    6696             : |  SEQUENCE qualified_name_list
    6697             :  { 
    6698           0 :  $$ = cat_str(2,mm_strdup("sequence"),$2);
    6699             : }
    6700             : |  FOREIGN DATA_P WRAPPER name_list
    6701             :  { 
    6702           0 :  $$ = cat_str(2,mm_strdup("foreign data wrapper"),$4);
    6703             : }
    6704             : |  FOREIGN SERVER name_list
    6705             :  { 
    6706           0 :  $$ = cat_str(2,mm_strdup("foreign server"),$3);
    6707             : }
    6708             : |  FUNCTION function_with_argtypes_list
    6709             :  { 
    6710           0 :  $$ = cat_str(2,mm_strdup("function"),$2);
    6711             : }
    6712             : |  PROCEDURE procedure_with_argtypes_list
    6713             :  { 
    6714           0 :  $$ = cat_str(2,mm_strdup("procedure"),$2);
    6715             : }
    6716             : |  ROUTINE procedure_with_argtypes_list
    6717             :  { 
    6718           0 :  $$ = cat_str(2,mm_strdup("routine"),$2);
    6719             : }
    6720             : |  DATABASE name_list
    6721             :  { 
    6722           0 :  $$ = cat_str(2,mm_strdup("database"),$2);
    6723             : }
    6724             : |  DOMAIN_P any_name_list
    6725             :  { 
    6726           0 :  $$ = cat_str(2,mm_strdup("domain"),$2);
    6727             : }
    6728             : |  LANGUAGE name_list
    6729             :  { 
    6730           0 :  $$ = cat_str(2,mm_strdup("language"),$2);
    6731             : }
    6732             : |  LARGE_P OBJECT_P NumericOnly_list
    6733             :  { 
    6734           0 :  $$ = cat_str(2,mm_strdup("large object"),$3);
    6735             : }
    6736             : |  SCHEMA name_list
    6737             :  { 
    6738           0 :  $$ = cat_str(2,mm_strdup("schema"),$2);
    6739             : }
    6740             : |  TABLESPACE name_list
    6741             :  { 
    6742           0 :  $$ = cat_str(2,mm_strdup("tablespace"),$2);
    6743             : }
    6744             : |  TYPE_P any_name_list
    6745             :  { 
    6746           0 :  $$ = cat_str(2,mm_strdup("type"),$2);
    6747             : }
    6748             : |  ALL TABLES IN_P SCHEMA name_list
    6749             :  { 
    6750           0 :  $$ = cat_str(2,mm_strdup("all tables in schema"),$5);
    6751             : }
    6752             : |  ALL SEQUENCES IN_P SCHEMA name_list
    6753             :  { 
    6754           0 :  $$ = cat_str(2,mm_strdup("all sequences in schema"),$5);
    6755             : }
    6756             : |  ALL FUNCTIONS IN_P SCHEMA name_list
    6757             :  { 
    6758           0 :  $$ = cat_str(2,mm_strdup("all functions in schema"),$5);
    6759             : }
    6760             : |  ALL PROCEDURES IN_P SCHEMA name_list
    6761             :  { 
    6762           0 :  $$ = cat_str(2,mm_strdup("all procedures in schema"),$5);
    6763             : }
    6764             : |  ALL ROUTINES IN_P SCHEMA name_list
    6765             :  { 
    6766           0 :  $$ = cat_str(2,mm_strdup("all routines in schema"),$5);
    6767             : }
    6768             : ;
    6769             : 
    6770             : 
    6771             :  grantee_list:
    6772             :  grantee
    6773             :  { 
    6774           0 :  $$ = $1;
    6775             : }
    6776             : |  grantee_list ',' grantee
    6777             :  { 
    6778           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    6779             : }
    6780             : ;
    6781             : 
    6782             : 
    6783             :  grantee:
    6784             :  RoleSpec
    6785             :  { 
    6786           0 :  $$ = $1;
    6787             : }
    6788             : |  GROUP_P RoleSpec
    6789             :  { 
    6790           0 :  $$ = cat_str(2,mm_strdup("group"),$2);
    6791             : }
    6792             : ;
    6793             : 
    6794             : 
    6795             :  opt_grant_grant_option:
    6796             :  WITH GRANT OPTION
    6797             :  { 
    6798           0 :  $$ = mm_strdup("with grant option");
    6799             : }
    6800             : | 
    6801             :  { 
    6802           0 :  $$=EMPTY; }
    6803             : ;
    6804             : 
    6805             : 
    6806             :  GrantRoleStmt:
    6807             :  GRANT privilege_list TO role_list opt_grant_admin_option opt_granted_by
    6808             :  { 
    6809           0 :  $$ = cat_str(6,mm_strdup("grant"),$2,mm_strdup("to"),$4,$5,$6);
    6810             : }
    6811             : ;
    6812             : 
    6813             : 
    6814             :  RevokeRoleStmt:
    6815             :  REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior
    6816             :  { 
    6817           0 :  $$ = cat_str(6,mm_strdup("revoke"),$2,mm_strdup("from"),$4,$5,$6);
    6818             : }
    6819             : |  REVOKE ADMIN OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior
    6820             :  { 
    6821           0 :  $$ = cat_str(6,mm_strdup("revoke admin option for"),$5,mm_strdup("from"),$7,$8,$9);
    6822             : }
    6823             : ;
    6824             : 
    6825             : 
    6826             :  opt_grant_admin_option:
    6827             :  WITH ADMIN OPTION
    6828             :  { 
    6829           0 :  $$ = mm_strdup("with admin option");
    6830             : }
    6831             : | 
    6832             :  { 
    6833           0 :  $$=EMPTY; }
    6834             : ;
    6835             : 
    6836             : 
    6837             :  opt_granted_by:
    6838             :  GRANTED BY RoleSpec
    6839             :  { 
    6840           0 :  $$ = cat_str(2,mm_strdup("granted by"),$3);
    6841             : }
    6842             : | 
    6843             :  { 
    6844           0 :  $$=EMPTY; }
    6845             : ;
    6846             : 
    6847             : 
    6848             :  AlterDefaultPrivilegesStmt:
    6849             :  ALTER DEFAULT PRIVILEGES DefACLOptionList DefACLAction
    6850             :  { 
    6851           0 :  $$ = cat_str(3,mm_strdup("alter default privileges"),$4,$5);
    6852             : }
    6853             : ;
    6854             : 
    6855             : 
    6856             :  DefACLOptionList:
    6857             :  DefACLOptionList DefACLOption
    6858             :  { 
    6859           0 :  $$ = cat_str(2,$1,$2);
    6860             : }
    6861             : | 
    6862             :  { 
    6863           0 :  $$=EMPTY; }
    6864             : ;
    6865             : 
    6866             : 
    6867             :  DefACLOption:
    6868             :  IN_P SCHEMA name_list
    6869             :  { 
    6870           0 :  $$ = cat_str(2,mm_strdup("in schema"),$3);
    6871             : }
    6872             : |  FOR ROLE role_list
    6873             :  { 
    6874           0 :  $$ = cat_str(2,mm_strdup("for role"),$3);
    6875             : }
    6876             : |  FOR USER role_list
    6877             :  { 
    6878           0 :  $$ = cat_str(2,mm_strdup("for user"),$3);
    6879             : }
    6880             : ;
    6881             : 
    6882             : 
    6883             :  DefACLAction:
    6884             :  GRANT privileges ON defacl_privilege_target TO grantee_list opt_grant_grant_option
    6885             :  { 
    6886           0 :  $$ = cat_str(7,mm_strdup("grant"),$2,mm_strdup("on"),$4,mm_strdup("to"),$6,$7);
    6887             : }
    6888             : |  REVOKE privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior
    6889             :  { 
    6890           0 :  $$ = cat_str(7,mm_strdup("revoke"),$2,mm_strdup("on"),$4,mm_strdup("from"),$6,$7);
    6891             : }
    6892             : |  REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior
    6893             :  { 
    6894           0 :  $$ = cat_str(7,mm_strdup("revoke grant option for"),$5,mm_strdup("on"),$7,mm_strdup("from"),$9,$10);
    6895             : }
    6896             : ;
    6897             : 
    6898             : 
    6899             :  defacl_privilege_target:
    6900             :  TABLES
    6901             :  { 
    6902           0 :  $$ = mm_strdup("tables");
    6903             : }
    6904             : |  FUNCTIONS
    6905             :  { 
    6906           0 :  $$ = mm_strdup("functions");
    6907             : }
    6908             : |  ROUTINES
    6909             :  { 
    6910           0 :  $$ = mm_strdup("routines");
    6911             : }
    6912             : |  SEQUENCES
    6913             :  { 
    6914           0 :  $$ = mm_strdup("sequences");
    6915             : }
    6916             : |  TYPES_P
    6917             :  { 
    6918           0 :  $$ = mm_strdup("types");
    6919             : }
    6920             : |  SCHEMAS
    6921             :  { 
    6922           0 :  $$ = mm_strdup("schemas");
    6923             : }
    6924             : ;
    6925             : 
    6926             : 
    6927             :  IndexStmt:
    6928             :  CREATE opt_unique INDEX opt_concurrently opt_index_name ON relation_expr access_method_clause '(' index_params ')' opt_include opt_reloptions OptTableSpace where_clause
    6929             :  { 
    6930           0 :  $$ = cat_str(15,mm_strdup("create"),$2,mm_strdup("index"),$4,$5,mm_strdup("on"),$7,$8,mm_strdup("("),$10,mm_strdup(")"),$12,$13,$14,$15);
    6931             : }
    6932             : |  CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name ON relation_expr access_method_clause '(' index_params ')' opt_include opt_reloptions OptTableSpace where_clause
    6933             :  { 
    6934           0 :  $$ = cat_str(16,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);
    6935             : }
    6936             : ;
    6937             : 
    6938             : 
    6939             :  opt_unique:
    6940             :  UNIQUE
    6941             :  { 
    6942           0 :  $$ = mm_strdup("unique");
    6943             : }
    6944             : | 
    6945             :  { 
    6946           0 :  $$=EMPTY; }
    6947             : ;
    6948             : 
    6949             : 
    6950             :  opt_concurrently:
    6951             :  CONCURRENTLY
    6952             :  { 
    6953           0 :  $$ = mm_strdup("concurrently");
    6954             : }
    6955             : | 
    6956             :  { 
    6957           0 :  $$=EMPTY; }
    6958             : ;
    6959             : 
    6960             : 
    6961             :  opt_index_name:
    6962             :  name
    6963             :  { 
    6964           0 :  $$ = $1;
    6965             : }
    6966             : | 
    6967             :  { 
    6968           0 :  $$=EMPTY; }
    6969             : ;
    6970             : 
    6971             : 
    6972             :  access_method_clause:
    6973             :  USING name
    6974             :  { 
    6975           0 :  $$ = cat_str(2,mm_strdup("using"),$2);
    6976             : }
    6977             : | 
    6978             :  { 
    6979           0 :  $$=EMPTY; }
    6980             : ;
    6981             : 
    6982             : 
    6983             :  index_params:
    6984             :  index_elem
    6985             :  { 
    6986           0 :  $$ = $1;
    6987             : }
    6988             : |  index_params ',' index_elem
    6989             :  { 
    6990           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    6991             : }
    6992             : ;
    6993             : 
    6994             : 
    6995             :  index_elem_options:
    6996             :  opt_collate opt_class opt_asc_desc opt_nulls_order
    6997             :  { 
    6998           0 :  $$ = cat_str(4,$1,$2,$3,$4);
    6999             : }
    7000             : |  opt_collate any_name reloptions opt_asc_desc opt_nulls_order
    7001             :  { 
    7002           0 :  $$ = cat_str(5,$1,$2,$3,$4,$5);
    7003             : }
    7004             : ;
    7005             : 
    7006             : 
    7007             :  index_elem:
    7008             :  ColId index_elem_options
    7009             :  { 
    7010           0 :  $$ = cat_str(2,$1,$2);
    7011             : }
    7012             : |  func_expr_windowless index_elem_options
    7013             :  { 
    7014           0 :  $$ = cat_str(2,$1,$2);
    7015             : }
    7016             : |  '(' a_expr ')' index_elem_options
    7017             :  { 
    7018           0 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(")"),$4);
    7019             : }
    7020             : ;
    7021             : 
    7022             : 
    7023             :  opt_include:
    7024             :  INCLUDE '(' index_including_params ')'
    7025             :  { 
    7026           0 :  $$ = cat_str(3,mm_strdup("include ("),$3,mm_strdup(")"));
    7027             : }
    7028             : | 
    7029             :  { 
    7030           0 :  $$=EMPTY; }
    7031             : ;
    7032             : 
    7033             : 
    7034             :  index_including_params:
    7035             :  index_elem
    7036             :  { 
    7037           0 :  $$ = $1;
    7038             : }
    7039             : |  index_including_params ',' index_elem
    7040             :  { 
    7041           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7042             : }
    7043             : ;
    7044             : 
    7045             : 
    7046             :  opt_collate:
    7047             :  COLLATE any_name
    7048             :  { 
    7049           0 :  $$ = cat_str(2,mm_strdup("collate"),$2);
    7050             : }
    7051             : | 
    7052             :  { 
    7053           0 :  $$=EMPTY; }
    7054             : ;
    7055             : 
    7056             : 
    7057             :  opt_class:
    7058             :  any_name
    7059             :  { 
    7060           0 :  $$ = $1;
    7061             : }
    7062             : | 
    7063             :  { 
    7064           0 :  $$=EMPTY; }
    7065             : ;
    7066             : 
    7067             : 
    7068             :  opt_asc_desc:
    7069             :  ASC
    7070             :  { 
    7071           2 :  $$ = mm_strdup("asc");
    7072             : }
    7073             : |  DESC
    7074             :  { 
    7075           0 :  $$ = mm_strdup("desc");
    7076             : }
    7077             : | 
    7078             :  { 
    7079          10 :  $$=EMPTY; }
    7080             : ;
    7081             : 
    7082             : 
    7083             :  opt_nulls_order:
    7084             :  NULLS_LA FIRST_P
    7085             :  { 
    7086           0 :  $$ = mm_strdup("nulls first");
    7087             : }
    7088             : |  NULLS_LA LAST_P
    7089             :  { 
    7090           4 :  $$ = mm_strdup("nulls last");
    7091             : }
    7092             : | 
    7093             :  { 
    7094           8 :  $$=EMPTY; }
    7095             : ;
    7096             : 
    7097             : 
    7098             :  CreateFunctionStmt:
    7099             :  CREATE opt_or_replace FUNCTION func_name func_args_with_defaults RETURNS func_return createfunc_opt_list
    7100             :  { 
    7101           2 :  $$ = cat_str(8,mm_strdup("create"),$2,mm_strdup("function"),$4,$5,mm_strdup("returns"),$7,$8);
    7102             : }
    7103             : |  CREATE opt_or_replace FUNCTION func_name func_args_with_defaults RETURNS TABLE '(' table_func_column_list ')' createfunc_opt_list
    7104             :  { 
    7105           0 :  $$ = cat_str(9,mm_strdup("create"),$2,mm_strdup("function"),$4,$5,mm_strdup("returns table ("),$9,mm_strdup(")"),$11);
    7106             : }
    7107             : |  CREATE opt_or_replace FUNCTION func_name func_args_with_defaults createfunc_opt_list
    7108             :  { 
    7109           0 :  $$ = cat_str(6,mm_strdup("create"),$2,mm_strdup("function"),$4,$5,$6);
    7110             : }
    7111             : |  CREATE opt_or_replace PROCEDURE func_name func_args_with_defaults createfunc_opt_list
    7112             :  { 
    7113           0 :  $$ = cat_str(6,mm_strdup("create"),$2,mm_strdup("procedure"),$4,$5,$6);
    7114             : }
    7115             : ;
    7116             : 
    7117             : 
    7118             :  opt_or_replace:
    7119             :  OR REPLACE
    7120             :  { 
    7121           0 :  $$ = mm_strdup("or replace");
    7122             : }
    7123             : | 
    7124             :  { 
    7125           4 :  $$=EMPTY; }
    7126             : ;
    7127             : 
    7128             : 
    7129             :  func_args:
    7130             :  '(' func_args_list ')'
    7131             :  { 
    7132           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    7133             : }
    7134             : |  '(' ')'
    7135             :  { 
    7136           2 :  $$ = mm_strdup("( )");
    7137             : }
    7138             : ;
    7139             : 
    7140             : 
    7141             :  func_args_list:
    7142             :  func_arg
    7143             :  { 
    7144           0 :  $$ = $1;
    7145             : }
    7146             : |  func_args_list ',' func_arg
    7147             :  { 
    7148           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7149             : }
    7150             : ;
    7151             : 
    7152             : 
    7153             :  function_with_argtypes_list:
    7154             :  function_with_argtypes
    7155             :  { 
    7156           2 :  $$ = $1;
    7157             : }
    7158             : |  function_with_argtypes_list ',' function_with_argtypes
    7159             :  { 
    7160           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7161             : }
    7162             : ;
    7163             : 
    7164             : 
    7165             :  procedure_with_argtypes_list:
    7166             :  procedure_with_argtypes
    7167             :  { 
    7168           0 :  $$ = $1;
    7169             : }
    7170             : |  procedure_with_argtypes_list ',' procedure_with_argtypes
    7171             :  { 
    7172           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7173             : }
    7174             : ;
    7175             : 
    7176             : 
    7177             :  function_with_argtypes:
    7178             :  func_name func_args
    7179             :  { 
    7180           2 :  $$ = cat_str(2,$1,$2);
    7181             : }
    7182             : |  function_with_argtypes_common
    7183             :  { 
    7184           0 :  $$ = $1;
    7185             : }
    7186             : ;
    7187             : 
    7188             : 
    7189             :  function_with_argtypes_common:
    7190             :  type_func_name_keyword
    7191             :  { 
    7192           0 :  $$ = $1;
    7193             : }
    7194             : |  ColId
    7195             :  { 
    7196           0 :  $$ = $1;
    7197             : }
    7198             : |  ColId indirection
    7199             :  { 
    7200           0 :  $$ = cat_str(2,$1,$2);
    7201             : }
    7202             : ;
    7203             : 
    7204             : 
    7205             :  procedure_with_argtypes:
    7206             :  func_name func_args
    7207             :  { 
    7208           0 :  $$ = cat_str(2,$1,$2);
    7209             : }
    7210             : |  function_with_argtypes_common
    7211             :  { 
    7212           0 :  $$ = $1;
    7213             : }
    7214             : ;
    7215             : 
    7216             : 
    7217             :  func_args_with_defaults:
    7218             :  '(' func_args_with_defaults_list ')'
    7219             :  { 
    7220           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    7221             : }
    7222             : |  '(' ')'
    7223             :  { 
    7224           2 :  $$ = mm_strdup("( )");
    7225             : }
    7226             : ;
    7227             : 
    7228             : 
    7229             :  func_args_with_defaults_list:
    7230             :  func_arg_with_default
    7231             :  { 
    7232           0 :  $$ = $1;
    7233             : }
    7234             : |  func_args_with_defaults_list ',' func_arg_with_default
    7235             :  { 
    7236           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7237             : }
    7238             : ;
    7239             : 
    7240             : 
    7241             :  func_arg:
    7242             :  arg_class param_name func_type
    7243             :  { 
    7244           0 :  $$ = cat_str(3,$1,$2,$3);
    7245             : }
    7246             : |  param_name arg_class func_type
    7247             :  { 
    7248           0 :  $$ = cat_str(3,$1,$2,$3);
    7249             : }
    7250             : |  param_name func_type
    7251             :  { 
    7252           0 :  $$ = cat_str(2,$1,$2);
    7253             : }
    7254             : |  arg_class func_type
    7255             :  { 
    7256           0 :  $$ = cat_str(2,$1,$2);
    7257             : }
    7258             : |  func_type
    7259             :  { 
    7260           0 :  $$ = $1;
    7261             : }
    7262             : ;
    7263             : 
    7264             : 
    7265             :  arg_class:
    7266             :  IN_P
    7267             :  { 
    7268           0 :  $$ = mm_strdup("in");
    7269             : }
    7270             : |  OUT_P
    7271             :  { 
    7272           0 :  $$ = mm_strdup("out");
    7273             : }
    7274             : |  INOUT
    7275             :  { 
    7276           0 :  $$ = mm_strdup("inout");
    7277             : }
    7278             : |  IN_P OUT_P
    7279             :  { 
    7280           0 :  $$ = mm_strdup("in out");
    7281             : }
    7282             : |  VARIADIC
    7283             :  { 
    7284           0 :  $$ = mm_strdup("variadic");
    7285             : }
    7286             : ;
    7287             : 
    7288             : 
    7289             :  param_name:
    7290             :  type_function_name
    7291             :  { 
    7292           0 :  $$ = $1;
    7293             : }
    7294             : ;
    7295             : 
    7296             : 
    7297             :  func_return:
    7298             :  func_type
    7299             :  { 
    7300           2 :  $$ = $1;
    7301             : }
    7302             : ;
    7303             : 
    7304             : 
    7305             :  func_type:
    7306             :  Typename
    7307             :  { 
    7308           2 :  $$ = $1;
    7309             : }
    7310             : |  type_function_name attrs '%' TYPE_P
    7311             :  { 
    7312           0 :  $$ = cat_str(3,$1,$2,mm_strdup("% type"));
    7313             : }
    7314             : |  SETOF type_function_name attrs '%' TYPE_P
    7315             :  { 
    7316           0 :  $$ = cat_str(4,mm_strdup("setof"),$2,$3,mm_strdup("% type"));
    7317             : }
    7318             : ;
    7319             : 
    7320             : 
    7321             :  func_arg_with_default:
    7322             :  func_arg
    7323             :  { 
    7324           0 :  $$ = $1;
    7325             : }
    7326             : |  func_arg DEFAULT a_expr
    7327             :  { 
    7328           0 :  $$ = cat_str(3,$1,mm_strdup("default"),$3);
    7329             : }
    7330             : |  func_arg '=' a_expr
    7331             :  { 
    7332           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    7333             : }
    7334             : ;
    7335             : 
    7336             : 
    7337             :  aggr_arg:
    7338             :  func_arg
    7339             :  { 
    7340           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    7341           0 :  $$ = $1;
    7342             : }
    7343             : ;
    7344             : 
    7345             : 
    7346             :  aggr_args:
    7347             :  '(' '*' ')'
    7348             :  { 
    7349           0 :  $$ = mm_strdup("( * )");
    7350             : }
    7351             : |  '(' aggr_args_list ')'
    7352             :  { 
    7353           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    7354             : }
    7355             : |  '(' ORDER BY aggr_args_list ')'
    7356             :  { 
    7357           0 :  $$ = cat_str(3,mm_strdup("( order by"),$4,mm_strdup(")"));
    7358             : }
    7359             : |  '(' aggr_args_list ORDER BY aggr_args_list ')'
    7360             :  { 
    7361           0 :  $$ = cat_str(5,mm_strdup("("),$2,mm_strdup("order by"),$5,mm_strdup(")"));
    7362             : }
    7363             : ;
    7364             : 
    7365             : 
    7366             :  aggr_args_list:
    7367             :  aggr_arg
    7368             :  { 
    7369           0 :  $$ = $1;
    7370             : }
    7371             : |  aggr_args_list ',' aggr_arg
    7372             :  { 
    7373           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7374             : }
    7375             : ;
    7376             : 
    7377             : 
    7378             :  aggregate_with_argtypes:
    7379             :  func_name aggr_args
    7380             :  { 
    7381           0 :  $$ = cat_str(2,$1,$2);
    7382             : }
    7383             : ;
    7384             : 
    7385             : 
    7386             :  aggregate_with_argtypes_list:
    7387             :  aggregate_with_argtypes
    7388             :  { 
    7389           0 :  $$ = $1;
    7390             : }
    7391             : |  aggregate_with_argtypes_list ',' aggregate_with_argtypes
    7392             :  { 
    7393           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7394             : }
    7395             : ;
    7396             : 
    7397             : 
    7398             :  createfunc_opt_list:
    7399             :  createfunc_opt_item
    7400             :  { 
    7401           2 :  $$ = $1;
    7402             : }
    7403             : |  createfunc_opt_list createfunc_opt_item
    7404             :  { 
    7405           2 :  $$ = cat_str(2,$1,$2);
    7406             : }
    7407             : ;
    7408             : 
    7409             : 
    7410             :  common_func_opt_item:
    7411             :  CALLED ON NULL_P INPUT_P
    7412             :  { 
    7413           0 :  $$ = mm_strdup("called on null input");
    7414             : }
    7415             : |  RETURNS NULL_P ON NULL_P INPUT_P
    7416             :  { 
    7417           0 :  $$ = mm_strdup("returns null on null input");
    7418             : }
    7419             : |  STRICT_P
    7420             :  { 
    7421           0 :  $$ = mm_strdup("strict");
    7422             : }
    7423             : |  IMMUTABLE
    7424             :  { 
    7425           0 :  $$ = mm_strdup("immutable");
    7426             : }
    7427             : |  STABLE
    7428             :  { 
    7429           0 :  $$ = mm_strdup("stable");
    7430             : }
    7431             : |  VOLATILE
    7432             :  { 
    7433           0 :  $$ = mm_strdup("volatile");
    7434             : }
    7435             : |  EXTERNAL SECURITY DEFINER
    7436             :  { 
    7437           0 :  $$ = mm_strdup("external security definer");
    7438             : }
    7439             : |  EXTERNAL SECURITY INVOKER
    7440             :  { 
    7441           0 :  $$ = mm_strdup("external security invoker");
    7442             : }
    7443             : |  SECURITY DEFINER
    7444             :  { 
    7445           0 :  $$ = mm_strdup("security definer");
    7446             : }
    7447             : |  SECURITY INVOKER
    7448             :  { 
    7449           0 :  $$ = mm_strdup("security invoker");
    7450             : }
    7451             : |  LEAKPROOF
    7452             :  { 
    7453           0 :  $$ = mm_strdup("leakproof");
    7454             : }
    7455             : |  NOT LEAKPROOF
    7456             :  { 
    7457           0 :  $$ = mm_strdup("not leakproof");
    7458             : }
    7459             : |  COST NumericOnly
    7460             :  { 
    7461           0 :  $$ = cat_str(2,mm_strdup("cost"),$2);
    7462             : }
    7463             : |  ROWS NumericOnly
    7464             :  { 
    7465           0 :  $$ = cat_str(2,mm_strdup("rows"),$2);
    7466             : }
    7467             : |  SUPPORT any_name
    7468             :  { 
    7469           0 :  $$ = cat_str(2,mm_strdup("support"),$2);
    7470             : }
    7471             : |  FunctionSetResetClause
    7472             :  { 
    7473           0 :  $$ = $1;
    7474             : }
    7475             : |  PARALLEL ColId
    7476             :  { 
    7477           0 :  $$ = cat_str(2,mm_strdup("parallel"),$2);
    7478             : }
    7479             : ;
    7480             : 
    7481             : 
    7482             :  createfunc_opt_item:
    7483             :  AS func_as
    7484             :  { 
    7485           2 :  $$ = cat_str(2,mm_strdup("as"),$2);
    7486             : }
    7487             : |  LANGUAGE NonReservedWord_or_Sconst
    7488             :  { 
    7489           2 :  $$ = cat_str(2,mm_strdup("language"),$2);
    7490             : }
    7491             : |  TRANSFORM transform_type_list
    7492             :  { 
    7493           0 :  $$ = cat_str(2,mm_strdup("transform"),$2);
    7494             : }
    7495             : |  WINDOW
    7496             :  { 
    7497           0 :  $$ = mm_strdup("window");
    7498             : }
    7499             : |  common_func_opt_item
    7500             :  { 
    7501           0 :  $$ = $1;
    7502             : }
    7503             : ;
    7504             : 
    7505             : 
    7506             :  func_as:
    7507             :  ecpg_sconst
    7508             :  { 
    7509           2 :  $$ = $1;
    7510             : }
    7511             : |  ecpg_sconst ',' ecpg_sconst
    7512             :  { 
    7513           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7514             : }
    7515             : ;
    7516             : 
    7517             : 
    7518             :  transform_type_list:
    7519             :  FOR TYPE_P Typename
    7520             :  { 
    7521           0 :  $$ = cat_str(2,mm_strdup("for type"),$3);
    7522             : }
    7523             : |  transform_type_list ',' FOR TYPE_P Typename
    7524             :  { 
    7525           0 :  $$ = cat_str(3,$1,mm_strdup(", for type"),$5);
    7526             : }
    7527             : ;
    7528             : 
    7529             : 
    7530             :  opt_definition:
    7531             :  WITH definition
    7532             :  { 
    7533           0 :  $$ = cat_str(2,mm_strdup("with"),$2);
    7534             : }
    7535             : | 
    7536             :  { 
    7537          20 :  $$=EMPTY; }
    7538             : ;
    7539             : 
    7540             : 
    7541             :  table_func_column:
    7542             :  param_name func_type
    7543             :  { 
    7544           0 :  $$ = cat_str(2,$1,$2);
    7545             : }
    7546             : ;
    7547             : 
    7548             : 
    7549             :  table_func_column_list:
    7550             :  table_func_column
    7551             :  { 
    7552           0 :  $$ = $1;
    7553             : }
    7554             : |  table_func_column_list ',' table_func_column
    7555             :  { 
    7556           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7557             : }
    7558             : ;
    7559             : 
    7560             : 
    7561             :  AlterFunctionStmt:
    7562             :  ALTER FUNCTION function_with_argtypes alterfunc_opt_list opt_restrict
    7563             :  { 
    7564           0 :  $$ = cat_str(4,mm_strdup("alter function"),$3,$4,$5);
    7565             : }
    7566             : |  ALTER PROCEDURE procedure_with_argtypes alterfunc_opt_list opt_restrict
    7567             :  { 
    7568           0 :  $$ = cat_str(4,mm_strdup("alter procedure"),$3,$4,$5);
    7569             : }
    7570             : |  ALTER ROUTINE procedure_with_argtypes alterfunc_opt_list opt_restrict
    7571             :  { 
    7572           0 :  $$ = cat_str(4,mm_strdup("alter routine"),$3,$4,$5);
    7573             : }
    7574             : ;
    7575             : 
    7576             : 
    7577             :  alterfunc_opt_list:
    7578             :  common_func_opt_item
    7579             :  { 
    7580           0 :  $$ = $1;
    7581             : }
    7582             : |  alterfunc_opt_list common_func_opt_item
    7583             :  { 
    7584           0 :  $$ = cat_str(2,$1,$2);
    7585             : }
    7586             : ;
    7587             : 
    7588             : 
    7589             :  opt_restrict:
    7590             :  RESTRICT
    7591             :  { 
    7592           0 :  $$ = mm_strdup("restrict");
    7593             : }
    7594             : | 
    7595             :  { 
    7596           0 :  $$=EMPTY; }
    7597             : ;
    7598             : 
    7599             : 
    7600             :  RemoveFuncStmt:
    7601             :  DROP FUNCTION function_with_argtypes_list opt_drop_behavior
    7602             :  { 
    7603           2 :  $$ = cat_str(3,mm_strdup("drop function"),$3,$4);
    7604             : }
    7605             : |  DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior
    7606             :  { 
    7607           0 :  $$ = cat_str(3,mm_strdup("drop function if exists"),$5,$6);
    7608             : }
    7609             : |  DROP PROCEDURE procedure_with_argtypes_list opt_drop_behavior
    7610             :  { 
    7611           0 :  $$ = cat_str(3,mm_strdup("drop procedure"),$3,$4);
    7612             : }
    7613             : |  DROP PROCEDURE IF_P EXISTS procedure_with_argtypes_list opt_drop_behavior
    7614             :  { 
    7615           0 :  $$ = cat_str(3,mm_strdup("drop procedure if exists"),$5,$6);
    7616             : }
    7617             : |  DROP ROUTINE procedure_with_argtypes_list opt_drop_behavior
    7618             :  { 
    7619           0 :  $$ = cat_str(3,mm_strdup("drop routine"),$3,$4);
    7620             : }
    7621             : |  DROP ROUTINE IF_P EXISTS procedure_with_argtypes_list opt_drop_behavior
    7622             :  { 
    7623           0 :  $$ = cat_str(3,mm_strdup("drop routine if exists"),$5,$6);
    7624             : }
    7625             : ;
    7626             : 
    7627             : 
    7628             :  RemoveAggrStmt:
    7629             :  DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior
    7630             :  { 
    7631           0 :  $$ = cat_str(3,mm_strdup("drop aggregate"),$3,$4);
    7632             : }
    7633             : |  DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior
    7634             :  { 
    7635           0 :  $$ = cat_str(3,mm_strdup("drop aggregate if exists"),$5,$6);
    7636             : }
    7637             : ;
    7638             : 
    7639             : 
    7640             :  RemoveOperStmt:
    7641             :  DROP OPERATOR operator_with_argtypes_list opt_drop_behavior
    7642             :  { 
    7643           0 :  $$ = cat_str(3,mm_strdup("drop operator"),$3,$4);
    7644             : }
    7645             : |  DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior
    7646             :  { 
    7647           0 :  $$ = cat_str(3,mm_strdup("drop operator if exists"),$5,$6);
    7648             : }
    7649             : ;
    7650             : 
    7651             : 
    7652             :  oper_argtypes:
    7653             :  '(' Typename ')'
    7654             :  { 
    7655           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    7656             : }
    7657             : |  '(' Typename ',' Typename ')'
    7658             :  { 
    7659           0 :  $$ = cat_str(5,mm_strdup("("),$2,mm_strdup(","),$4,mm_strdup(")"));
    7660             : }
    7661             : |  '(' NONE ',' Typename ')'
    7662             :  { 
    7663           0 :  $$ = cat_str(3,mm_strdup("( none ,"),$4,mm_strdup(")"));
    7664             : }
    7665             : |  '(' Typename ',' NONE ')'
    7666             :  { 
    7667           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(", none )"));
    7668             : }
    7669             : ;
    7670             : 
    7671             : 
    7672             :  any_operator:
    7673             :  all_Op
    7674             :  { 
    7675           0 :  $$ = $1;
    7676             : }
    7677             : |  ColId '.' any_operator
    7678             :  { 
    7679           0 :  $$ = cat_str(3,$1,mm_strdup("."),$3);
    7680             : }
    7681             : ;
    7682             : 
    7683             : 
    7684             :  operator_with_argtypes_list:
    7685             :  operator_with_argtypes
    7686             :  { 
    7687           0 :  $$ = $1;
    7688             : }
    7689             : |  operator_with_argtypes_list ',' operator_with_argtypes
    7690             :  { 
    7691           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7692             : }
    7693             : ;
    7694             : 
    7695             : 
    7696             :  operator_with_argtypes:
    7697             :  any_operator oper_argtypes
    7698             :  { 
    7699           0 :  $$ = cat_str(2,$1,$2);
    7700             : }
    7701             : ;
    7702             : 
    7703             : 
    7704             :  DoStmt:
    7705             :  DO dostmt_opt_list
    7706             :  { 
    7707           0 :  $$ = cat_str(2,mm_strdup("do"),$2);
    7708             : }
    7709             : ;
    7710             : 
    7711             : 
    7712             :  dostmt_opt_list:
    7713             :  dostmt_opt_item
    7714             :  { 
    7715           0 :  $$ = $1;
    7716             : }
    7717             : |  dostmt_opt_list dostmt_opt_item
    7718             :  { 
    7719           0 :  $$ = cat_str(2,$1,$2);
    7720             : }
    7721             : ;
    7722             : 
    7723             : 
    7724             :  dostmt_opt_item:
    7725             :  ecpg_sconst
    7726             :  { 
    7727           0 :  $$ = $1;
    7728             : }
    7729             : |  LANGUAGE NonReservedWord_or_Sconst
    7730             :  { 
    7731           0 :  $$ = cat_str(2,mm_strdup("language"),$2);
    7732             : }
    7733             : ;
    7734             : 
    7735             : 
    7736             :  CreateCastStmt:
    7737             :  CREATE CAST '(' Typename AS Typename ')' WITH FUNCTION function_with_argtypes cast_context
    7738             :  { 
    7739           0 :  $$ = cat_str(7,mm_strdup("create cast ("),$4,mm_strdup("as"),$6,mm_strdup(") with function"),$10,$11);
    7740             : }
    7741             : |  CREATE CAST '(' Typename AS Typename ')' WITHOUT FUNCTION cast_context
    7742             :  { 
    7743           0 :  $$ = cat_str(6,mm_strdup("create cast ("),$4,mm_strdup("as"),$6,mm_strdup(") without function"),$10);
    7744             : }
    7745             : |  CREATE CAST '(' Typename AS Typename ')' WITH INOUT cast_context
    7746             :  { 
    7747           0 :  $$ = cat_str(6,mm_strdup("create cast ("),$4,mm_strdup("as"),$6,mm_strdup(") with inout"),$10);
    7748             : }
    7749             : ;
    7750             : 
    7751             : 
    7752             :  cast_context:
    7753             :  AS IMPLICIT_P
    7754             :  { 
    7755           0 :  $$ = mm_strdup("as implicit");
    7756             : }
    7757             : |  AS ASSIGNMENT
    7758             :  { 
    7759           0 :  $$ = mm_strdup("as assignment");
    7760             : }
    7761             : | 
    7762             :  { 
    7763           0 :  $$=EMPTY; }
    7764             : ;
    7765             : 
    7766             : 
    7767             :  DropCastStmt:
    7768             :  DROP CAST opt_if_exists '(' Typename AS Typename ')' opt_drop_behavior
    7769             :  { 
    7770           0 :  $$ = cat_str(8,mm_strdup("drop cast"),$3,mm_strdup("("),$5,mm_strdup("as"),$7,mm_strdup(")"),$9);
    7771             : }
    7772             : ;
    7773             : 
    7774             : 
    7775             :  opt_if_exists:
    7776             :  IF_P EXISTS
    7777             :  { 
    7778           0 :  $$ = mm_strdup("if exists");
    7779             : }
    7780             : | 
    7781             :  { 
    7782           0 :  $$=EMPTY; }
    7783             : ;
    7784             : 
    7785             : 
    7786             :  CreateTransformStmt:
    7787             :  CREATE opt_or_replace TRANSFORM FOR Typename LANGUAGE name '(' transform_element_list ')'
    7788             :  { 
    7789           0 :  $$ = cat_str(9,mm_strdup("create"),$2,mm_strdup("transform for"),$5,mm_strdup("language"),$7,mm_strdup("("),$9,mm_strdup(")"));
    7790             : }
    7791             : ;
    7792             : 
    7793             : 
    7794             :  transform_element_list:
    7795             :  FROM SQL_P WITH FUNCTION function_with_argtypes ',' TO SQL_P WITH FUNCTION function_with_argtypes
    7796             :  { 
    7797           0 :  $$ = cat_str(4,mm_strdup("from sql with function"),$5,mm_strdup(", to sql with function"),$11);
    7798             : }
    7799             : |  TO SQL_P WITH FUNCTION function_with_argtypes ',' FROM SQL_P WITH FUNCTION function_with_argtypes
    7800             :  { 
    7801           0 :  $$ = cat_str(4,mm_strdup("to sql with function"),$5,mm_strdup(", from sql with function"),$11);
    7802             : }
    7803             : |  FROM SQL_P WITH FUNCTION function_with_argtypes
    7804             :  { 
    7805           0 :  $$ = cat_str(2,mm_strdup("from sql with function"),$5);
    7806             : }
    7807             : |  TO SQL_P WITH FUNCTION function_with_argtypes
    7808             :  { 
    7809           0 :  $$ = cat_str(2,mm_strdup("to sql with function"),$5);
    7810             : }
    7811             : ;
    7812             : 
    7813             : 
    7814             :  DropTransformStmt:
    7815             :  DROP TRANSFORM opt_if_exists FOR Typename LANGUAGE name opt_drop_behavior
    7816             :  { 
    7817           0 :  $$ = cat_str(7,mm_strdup("drop transform"),$3,mm_strdup("for"),$5,mm_strdup("language"),$7,$8);
    7818             : }
    7819             : ;
    7820             : 
    7821             : 
    7822             :  ReindexStmt:
    7823             :  REINDEX reindex_target_type opt_concurrently qualified_name
    7824             :  { 
    7825           0 :  $$ = cat_str(4,mm_strdup("reindex"),$2,$3,$4);
    7826             : }
    7827             : |  REINDEX reindex_target_multitable opt_concurrently name
    7828             :  { 
    7829           0 :  $$ = cat_str(4,mm_strdup("reindex"),$2,$3,$4);
    7830             : }
    7831             : |  REINDEX '(' reindex_option_list ')' reindex_target_type opt_concurrently qualified_name
    7832             :  { 
    7833           0 :  $$ = cat_str(6,mm_strdup("reindex ("),$3,mm_strdup(")"),$5,$6,$7);
    7834             : }
    7835             : |  REINDEX '(' reindex_option_list ')' reindex_target_multitable opt_concurrently name
    7836             :  { 
    7837           0 :  $$ = cat_str(6,mm_strdup("reindex ("),$3,mm_strdup(")"),$5,$6,$7);
    7838             : }
    7839             : ;
    7840             : 
    7841             : 
    7842             :  reindex_target_type:
    7843             :  INDEX
    7844             :  { 
    7845           0 :  $$ = mm_strdup("index");
    7846             : }
    7847             : |  TABLE
    7848             :  { 
    7849           0 :  $$ = mm_strdup("table");
    7850             : }
    7851             : ;
    7852             : 
    7853             : 
    7854             :  reindex_target_multitable:
    7855             :  SCHEMA
    7856             :  { 
    7857           0 :  $$ = mm_strdup("schema");
    7858             : }
    7859             : |  SYSTEM_P
    7860             :  { 
    7861           0 :  $$ = mm_strdup("system");
    7862             : }
    7863             : |  DATABASE
    7864             :  { 
    7865           0 :  $$ = mm_strdup("database");
    7866             : }
    7867             : ;
    7868             : 
    7869             : 
    7870             :  reindex_option_list:
    7871             :  reindex_option_elem
    7872             :  { 
    7873           0 :  $$ = $1;
    7874             : }
    7875             : |  reindex_option_list ',' reindex_option_elem
    7876             :  { 
    7877           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    7878             : }
    7879             : ;
    7880             : 
    7881             : 
    7882             :  reindex_option_elem:
    7883             :  VERBOSE
    7884             :  { 
    7885           0 :  $$ = mm_strdup("verbose");
    7886             : }
    7887             : ;
    7888             : 
    7889             : 
    7890             :  AlterTblSpcStmt:
    7891             :  ALTER TABLESPACE name SET reloptions
    7892             :  { 
    7893           0 :  $$ = cat_str(4,mm_strdup("alter tablespace"),$3,mm_strdup("set"),$5);
    7894             : }
    7895             : |  ALTER TABLESPACE name RESET reloptions
    7896             :  { 
    7897           0 :  $$ = cat_str(4,mm_strdup("alter tablespace"),$3,mm_strdup("reset"),$5);
    7898             : }
    7899             : ;
    7900             : 
    7901             : 
    7902             :  RenameStmt:
    7903             :  ALTER AGGREGATE aggregate_with_argtypes RENAME TO name
    7904             :  { 
    7905           0 :  $$ = cat_str(4,mm_strdup("alter aggregate"),$3,mm_strdup("rename to"),$6);
    7906             : }
    7907             : |  ALTER COLLATION any_name RENAME TO name
    7908             :  { 
    7909           0 :  $$ = cat_str(4,mm_strdup("alter collation"),$3,mm_strdup("rename to"),$6);
    7910             : }
    7911             : |  ALTER CONVERSION_P any_name RENAME TO name
    7912             :  { 
    7913           0 :  $$ = cat_str(4,mm_strdup("alter conversion"),$3,mm_strdup("rename to"),$6);
    7914             : }
    7915             : |  ALTER DATABASE name RENAME TO name
    7916             :  { 
    7917           0 :  $$ = cat_str(4,mm_strdup("alter database"),$3,mm_strdup("rename to"),$6);
    7918             : }
    7919             : |  ALTER DOMAIN_P any_name RENAME TO name
    7920             :  { 
    7921           0 :  $$ = cat_str(4,mm_strdup("alter domain"),$3,mm_strdup("rename to"),$6);
    7922             : }
    7923             : |  ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name
    7924             :  { 
    7925           0 :  $$ = cat_str(6,mm_strdup("alter domain"),$3,mm_strdup("rename constraint"),$6,mm_strdup("to"),$8);
    7926             : }
    7927             : |  ALTER FOREIGN DATA_P WRAPPER name RENAME TO name
    7928             :  { 
    7929           0 :  $$ = cat_str(4,mm_strdup("alter foreign data wrapper"),$5,mm_strdup("rename to"),$8);
    7930             : }
    7931             : |  ALTER FUNCTION function_with_argtypes RENAME TO name
    7932             :  { 
    7933           0 :  $$ = cat_str(4,mm_strdup("alter function"),$3,mm_strdup("rename to"),$6);
    7934             : }
    7935             : |  ALTER GROUP_P RoleId RENAME TO RoleId
    7936             :  { 
    7937           0 :  $$ = cat_str(4,mm_strdup("alter group"),$3,mm_strdup("rename to"),$6);
    7938             : }
    7939             : |  ALTER opt_procedural LANGUAGE name RENAME TO name
    7940             :  { 
    7941           0 :  $$ = cat_str(6,mm_strdup("alter"),$2,mm_strdup("language"),$4,mm_strdup("rename to"),$7);
    7942             : }
    7943             : |  ALTER OPERATOR CLASS any_name USING name RENAME TO name
    7944             :  { 
    7945           0 :  $$ = cat_str(6,mm_strdup("alter operator class"),$4,mm_strdup("using"),$6,mm_strdup("rename to"),$9);
    7946             : }
    7947             : |  ALTER OPERATOR FAMILY any_name USING name RENAME TO name
    7948             :  { 
    7949           0 :  $$ = cat_str(6,mm_strdup("alter operator family"),$4,mm_strdup("using"),$6,mm_strdup("rename to"),$9);
    7950             : }
    7951             : |  ALTER POLICY name ON qualified_name RENAME TO name
    7952             :  { 
    7953           0 :  $$ = cat_str(6,mm_strdup("alter policy"),$3,mm_strdup("on"),$5,mm_strdup("rename to"),$8);
    7954             : }
    7955             : |  ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name
    7956             :  { 
    7957           0 :  $$ = cat_str(6,mm_strdup("alter policy if exists"),$5,mm_strdup("on"),$7,mm_strdup("rename to"),$10);
    7958             : }
    7959             : |  ALTER PROCEDURE procedure_with_argtypes RENAME TO name
    7960             :  { 
    7961           0 :  $$ = cat_str(4,mm_strdup("alter procedure"),$3,mm_strdup("rename to"),$6);
    7962             : }
    7963             : |  ALTER PUBLICATION name RENAME TO name
    7964             :  { 
    7965           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("rename to"),$6);
    7966             : }
    7967             : |  ALTER ROUTINE procedure_with_argtypes RENAME TO name
    7968             :  { 
    7969           0 :  $$ = cat_str(4,mm_strdup("alter routine"),$3,mm_strdup("rename to"),$6);
    7970             : }
    7971             : |  ALTER SCHEMA name RENAME TO name
    7972             :  { 
    7973           0 :  $$ = cat_str(4,mm_strdup("alter schema"),$3,mm_strdup("rename to"),$6);
    7974             : }
    7975             : |  ALTER SERVER name RENAME TO name
    7976             :  { 
    7977           0 :  $$ = cat_str(4,mm_strdup("alter server"),$3,mm_strdup("rename to"),$6);
    7978             : }
    7979             : |  ALTER SUBSCRIPTION name RENAME TO name
    7980             :  { 
    7981           0 :  $$ = cat_str(4,mm_strdup("alter subscription"),$3,mm_strdup("rename to"),$6);
    7982             : }
    7983             : |  ALTER TABLE relation_expr RENAME TO name
    7984             :  { 
    7985           0 :  $$ = cat_str(4,mm_strdup("alter table"),$3,mm_strdup("rename to"),$6);
    7986             : }
    7987             : |  ALTER TABLE IF_P EXISTS relation_expr RENAME TO name
    7988             :  { 
    7989           0 :  $$ = cat_str(4,mm_strdup("alter table if exists"),$5,mm_strdup("rename to"),$8);
    7990             : }
    7991             : |  ALTER SEQUENCE qualified_name RENAME TO name
    7992             :  { 
    7993           0 :  $$ = cat_str(4,mm_strdup("alter sequence"),$3,mm_strdup("rename to"),$6);
    7994             : }
    7995             : |  ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name
    7996             :  { 
    7997           0 :  $$ = cat_str(4,mm_strdup("alter sequence if exists"),$5,mm_strdup("rename to"),$8);
    7998             : }
    7999             : |  ALTER VIEW qualified_name RENAME TO name
    8000             :  { 
    8001           0 :  $$ = cat_str(4,mm_strdup("alter view"),$3,mm_strdup("rename to"),$6);
    8002             : }
    8003             : |  ALTER VIEW IF_P EXISTS qualified_name RENAME TO name
    8004             :  { 
    8005           0 :  $$ = cat_str(4,mm_strdup("alter view if exists"),$5,mm_strdup("rename to"),$8);
    8006             : }
    8007             : |  ALTER MATERIALIZED VIEW qualified_name RENAME TO name
    8008             :  { 
    8009           0 :  $$ = cat_str(4,mm_strdup("alter materialized view"),$4,mm_strdup("rename to"),$7);
    8010             : }
    8011             : |  ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name
    8012             :  { 
    8013           0 :  $$ = cat_str(4,mm_strdup("alter materialized view if exists"),$6,mm_strdup("rename to"),$9);
    8014             : }
    8015             : |  ALTER INDEX qualified_name RENAME TO name
    8016             :  { 
    8017           0 :  $$ = cat_str(4,mm_strdup("alter index"),$3,mm_strdup("rename to"),$6);
    8018             : }
    8019             : |  ALTER INDEX IF_P EXISTS qualified_name RENAME TO name
    8020             :  { 
    8021           0 :  $$ = cat_str(4,mm_strdup("alter index if exists"),$5,mm_strdup("rename to"),$8);
    8022             : }
    8023             : |  ALTER FOREIGN TABLE relation_expr RENAME TO name
    8024             :  { 
    8025           0 :  $$ = cat_str(4,mm_strdup("alter foreign table"),$4,mm_strdup("rename to"),$7);
    8026             : }
    8027             : |  ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name
    8028             :  { 
    8029           0 :  $$ = cat_str(4,mm_strdup("alter foreign table if exists"),$6,mm_strdup("rename to"),$9);
    8030             : }
    8031             : |  ALTER TABLE relation_expr RENAME opt_column name TO name
    8032             :  { 
    8033           0 :  $$ = cat_str(7,mm_strdup("alter table"),$3,mm_strdup("rename"),$5,$6,mm_strdup("to"),$8);
    8034             : }
    8035             : |  ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
    8036             :  { 
    8037           0 :  $$ = cat_str(7,mm_strdup("alter table if exists"),$5,mm_strdup("rename"),$7,$8,mm_strdup("to"),$10);
    8038             : }
    8039             : |  ALTER VIEW qualified_name RENAME opt_column name TO name
    8040             :  { 
    8041           0 :  $$ = cat_str(7,mm_strdup("alter view"),$3,mm_strdup("rename"),$5,$6,mm_strdup("to"),$8);
    8042             : }
    8043             : |  ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
    8044             :  { 
    8045           0 :  $$ = cat_str(7,mm_strdup("alter view if exists"),$5,mm_strdup("rename"),$7,$8,mm_strdup("to"),$10);
    8046             : }
    8047             : |  ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name
    8048             :  { 
    8049           0 :  $$ = cat_str(7,mm_strdup("alter materialized view"),$4,mm_strdup("rename"),$6,$7,mm_strdup("to"),$9);
    8050             : }
    8051             : |  ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
    8052             :  { 
    8053           0 :  $$ = cat_str(7,mm_strdup("alter materialized view if exists"),$6,mm_strdup("rename"),$8,$9,mm_strdup("to"),$11);
    8054             : }
    8055             : |  ALTER TABLE relation_expr RENAME CONSTRAINT name TO name
    8056             :  { 
    8057           0 :  $$ = cat_str(6,mm_strdup("alter table"),$3,mm_strdup("rename constraint"),$6,mm_strdup("to"),$8);
    8058             : }
    8059             : |  ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name
    8060             :  { 
    8061           0 :  $$ = cat_str(6,mm_strdup("alter table if exists"),$5,mm_strdup("rename constraint"),$8,mm_strdup("to"),$10);
    8062             : }
    8063             : |  ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name
    8064             :  { 
    8065           0 :  $$ = cat_str(7,mm_strdup("alter foreign table"),$4,mm_strdup("rename"),$6,$7,mm_strdup("to"),$9);
    8066             : }
    8067             : |  ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
    8068             :  { 
    8069           0 :  $$ = cat_str(7,mm_strdup("alter foreign table if exists"),$6,mm_strdup("rename"),$8,$9,mm_strdup("to"),$11);
    8070             : }
    8071             : |  ALTER RULE name ON qualified_name RENAME TO name
    8072             :  { 
    8073           0 :  $$ = cat_str(6,mm_strdup("alter rule"),$3,mm_strdup("on"),$5,mm_strdup("rename to"),$8);
    8074             : }
    8075             : |  ALTER TRIGGER name ON qualified_name RENAME TO name
    8076             :  { 
    8077           0 :  $$ = cat_str(6,mm_strdup("alter trigger"),$3,mm_strdup("on"),$5,mm_strdup("rename to"),$8);
    8078             : }
    8079             : |  ALTER EVENT TRIGGER name RENAME TO name
    8080             :  { 
    8081           0 :  $$ = cat_str(4,mm_strdup("alter event trigger"),$4,mm_strdup("rename to"),$7);
    8082             : }
    8083             : |  ALTER ROLE RoleId RENAME TO RoleId
    8084             :  { 
    8085           0 :  $$ = cat_str(4,mm_strdup("alter role"),$3,mm_strdup("rename to"),$6);
    8086             : }
    8087             : |  ALTER USER RoleId RENAME TO RoleId
    8088             :  { 
    8089           0 :  $$ = cat_str(4,mm_strdup("alter user"),$3,mm_strdup("rename to"),$6);
    8090             : }
    8091             : |  ALTER TABLESPACE name RENAME TO name
    8092             :  { 
    8093           0 :  $$ = cat_str(4,mm_strdup("alter tablespace"),$3,mm_strdup("rename to"),$6);
    8094             : }
    8095             : |  ALTER STATISTICS any_name RENAME TO name
    8096             :  { 
    8097           0 :  $$ = cat_str(4,mm_strdup("alter statistics"),$3,mm_strdup("rename to"),$6);
    8098             : }
    8099             : |  ALTER TEXT_P SEARCH PARSER any_name RENAME TO name
    8100             :  { 
    8101           0 :  $$ = cat_str(4,mm_strdup("alter text search parser"),$5,mm_strdup("rename to"),$8);
    8102             : }
    8103             : |  ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name
    8104             :  { 
    8105           0 :  $$ = cat_str(4,mm_strdup("alter text search dictionary"),$5,mm_strdup("rename to"),$8);
    8106             : }
    8107             : |  ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name
    8108             :  { 
    8109           0 :  $$ = cat_str(4,mm_strdup("alter text search template"),$5,mm_strdup("rename to"),$8);
    8110             : }
    8111             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name
    8112             :  { 
    8113           0 :  $$ = cat_str(4,mm_strdup("alter text search configuration"),$5,mm_strdup("rename to"),$8);
    8114             : }
    8115             : |  ALTER TYPE_P any_name RENAME TO name
    8116             :  { 
    8117           0 :  $$ = cat_str(4,mm_strdup("alter type"),$3,mm_strdup("rename to"),$6);
    8118             : }
    8119             : |  ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior
    8120             :  { 
    8121           0 :  $$ = cat_str(7,mm_strdup("alter type"),$3,mm_strdup("rename attribute"),$6,mm_strdup("to"),$8,$9);
    8122             : }
    8123             : ;
    8124             : 
    8125             : 
    8126             :  opt_column:
    8127             :  COLUMN
    8128             :  { 
    8129           2 :  $$ = mm_strdup("column");
    8130             : }
    8131             : | 
    8132             :  { 
    8133           2 :  $$=EMPTY; }
    8134             : ;
    8135             : 
    8136             : 
    8137             :  opt_set_data:
    8138             :  SET DATA_P
    8139             :  { 
    8140           2 :  $$ = mm_strdup("set data");
    8141             : }
    8142             : | 
    8143             :  { 
    8144           2 :  $$=EMPTY; }
    8145             : ;
    8146             : 
    8147             : 
    8148             :  AlterObjectDependsStmt:
    8149             :  ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name
    8150             :  { 
    8151           0 :  $$ = cat_str(5,mm_strdup("alter function"),$3,$4,mm_strdup("depends on extension"),$8);
    8152             : }
    8153             : |  ALTER PROCEDURE procedure_with_argtypes opt_no DEPENDS ON EXTENSION name
    8154             :  { 
    8155           0 :  $$ = cat_str(5,mm_strdup("alter procedure"),$3,$4,mm_strdup("depends on extension"),$8);
    8156             : }
    8157             : |  ALTER ROUTINE procedure_with_argtypes opt_no DEPENDS ON EXTENSION name
    8158             :  { 
    8159           0 :  $$ = cat_str(5,mm_strdup("alter routine"),$3,$4,mm_strdup("depends on extension"),$8);
    8160             : }
    8161             : |  ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name
    8162             :  { 
    8163           0 :  $$ = cat_str(7,mm_strdup("alter trigger"),$3,mm_strdup("on"),$5,$6,mm_strdup("depends on extension"),$10);
    8164             : }
    8165             : |  ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name
    8166             :  { 
    8167           0 :  $$ = cat_str(5,mm_strdup("alter materialized view"),$4,$5,mm_strdup("depends on extension"),$9);
    8168             : }
    8169             : |  ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name
    8170             :  { 
    8171           0 :  $$ = cat_str(5,mm_strdup("alter index"),$3,$4,mm_strdup("depends on extension"),$8);
    8172             : }
    8173             : ;
    8174             : 
    8175             : 
    8176             :  opt_no:
    8177             :  NO
    8178             :  { 
    8179           0 :  $$ = mm_strdup("no");
    8180             : }
    8181             : | 
    8182             :  { 
    8183           0 :  $$=EMPTY; }
    8184             : ;
    8185             : 
    8186             : 
    8187             :  AlterObjectSchemaStmt:
    8188             :  ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name
    8189             :  { 
    8190           0 :  $$ = cat_str(4,mm_strdup("alter aggregate"),$3,mm_strdup("set schema"),$6);
    8191             : }
    8192             : |  ALTER COLLATION any_name SET SCHEMA name
    8193             :  { 
    8194           0 :  $$ = cat_str(4,mm_strdup("alter collation"),$3,mm_strdup("set schema"),$6);
    8195             : }
    8196             : |  ALTER CONVERSION_P any_name SET SCHEMA name
    8197             :  { 
    8198           0 :  $$ = cat_str(4,mm_strdup("alter conversion"),$3,mm_strdup("set schema"),$6);
    8199             : }
    8200             : |  ALTER DOMAIN_P any_name SET SCHEMA name
    8201             :  { 
    8202           0 :  $$ = cat_str(4,mm_strdup("alter domain"),$3,mm_strdup("set schema"),$6);
    8203             : }
    8204             : |  ALTER EXTENSION name SET SCHEMA name
    8205             :  { 
    8206           0 :  $$ = cat_str(4,mm_strdup("alter extension"),$3,mm_strdup("set schema"),$6);
    8207             : }
    8208             : |  ALTER FUNCTION function_with_argtypes SET SCHEMA name
    8209             :  { 
    8210           0 :  $$ = cat_str(4,mm_strdup("alter function"),$3,mm_strdup("set schema"),$6);
    8211             : }
    8212             : |  ALTER OPERATOR operator_with_argtypes SET SCHEMA name
    8213             :  { 
    8214           0 :  $$ = cat_str(4,mm_strdup("alter operator"),$3,mm_strdup("set schema"),$6);
    8215             : }
    8216             : |  ALTER OPERATOR CLASS any_name USING name SET SCHEMA name
    8217             :  { 
    8218           0 :  $$ = cat_str(6,mm_strdup("alter operator class"),$4,mm_strdup("using"),$6,mm_strdup("set schema"),$9);
    8219             : }
    8220             : |  ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name
    8221             :  { 
    8222           0 :  $$ = cat_str(6,mm_strdup("alter operator family"),$4,mm_strdup("using"),$6,mm_strdup("set schema"),$9);
    8223             : }
    8224             : |  ALTER PROCEDURE procedure_with_argtypes SET SCHEMA name
    8225             :  { 
    8226           0 :  $$ = cat_str(4,mm_strdup("alter procedure"),$3,mm_strdup("set schema"),$6);
    8227             : }
    8228             : |  ALTER ROUTINE procedure_with_argtypes SET SCHEMA name
    8229             :  { 
    8230           0 :  $$ = cat_str(4,mm_strdup("alter routine"),$3,mm_strdup("set schema"),$6);
    8231             : }
    8232             : |  ALTER TABLE relation_expr SET SCHEMA name
    8233             :  { 
    8234           0 :  $$ = cat_str(4,mm_strdup("alter table"),$3,mm_strdup("set schema"),$6);
    8235             : }
    8236             : |  ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name
    8237             :  { 
    8238           0 :  $$ = cat_str(4,mm_strdup("alter table if exists"),$5,mm_strdup("set schema"),$8);
    8239             : }
    8240             : |  ALTER STATISTICS any_name SET SCHEMA name
    8241             :  { 
    8242           0 :  $$ = cat_str(4,mm_strdup("alter statistics"),$3,mm_strdup("set schema"),$6);
    8243             : }
    8244             : |  ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name
    8245             :  { 
    8246           0 :  $$ = cat_str(4,mm_strdup("alter text search parser"),$5,mm_strdup("set schema"),$8);
    8247             : }
    8248             : |  ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name
    8249             :  { 
    8250           0 :  $$ = cat_str(4,mm_strdup("alter text search dictionary"),$5,mm_strdup("set schema"),$8);
    8251             : }
    8252             : |  ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name
    8253             :  { 
    8254           0 :  $$ = cat_str(4,mm_strdup("alter text search template"),$5,mm_strdup("set schema"),$8);
    8255             : }
    8256             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name
    8257             :  { 
    8258           0 :  $$ = cat_str(4,mm_strdup("alter text search configuration"),$5,mm_strdup("set schema"),$8);
    8259             : }
    8260             : |  ALTER SEQUENCE qualified_name SET SCHEMA name
    8261             :  { 
    8262           0 :  $$ = cat_str(4,mm_strdup("alter sequence"),$3,mm_strdup("set schema"),$6);
    8263             : }
    8264             : |  ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name
    8265             :  { 
    8266           0 :  $$ = cat_str(4,mm_strdup("alter sequence if exists"),$5,mm_strdup("set schema"),$8);
    8267             : }
    8268             : |  ALTER VIEW qualified_name SET SCHEMA name
    8269             :  { 
    8270           0 :  $$ = cat_str(4,mm_strdup("alter view"),$3,mm_strdup("set schema"),$6);
    8271             : }
    8272             : |  ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name
    8273             :  { 
    8274           0 :  $$ = cat_str(4,mm_strdup("alter view if exists"),$5,mm_strdup("set schema"),$8);
    8275             : }
    8276             : |  ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name
    8277             :  { 
    8278           0 :  $$ = cat_str(4,mm_strdup("alter materialized view"),$4,mm_strdup("set schema"),$7);
    8279             : }
    8280             : |  ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name
    8281             :  { 
    8282           0 :  $$ = cat_str(4,mm_strdup("alter materialized view if exists"),$6,mm_strdup("set schema"),$9);
    8283             : }
    8284             : |  ALTER FOREIGN TABLE relation_expr SET SCHEMA name
    8285             :  { 
    8286           0 :  $$ = cat_str(4,mm_strdup("alter foreign table"),$4,mm_strdup("set schema"),$7);
    8287             : }
    8288             : |  ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name
    8289             :  { 
    8290           0 :  $$ = cat_str(4,mm_strdup("alter foreign table if exists"),$6,mm_strdup("set schema"),$9);
    8291             : }
    8292             : |  ALTER TYPE_P any_name SET SCHEMA name
    8293             :  { 
    8294           0 :  $$ = cat_str(4,mm_strdup("alter type"),$3,mm_strdup("set schema"),$6);
    8295             : }
    8296             : ;
    8297             : 
    8298             : 
    8299             :  AlterOperatorStmt:
    8300             :  ALTER OPERATOR operator_with_argtypes SET '(' operator_def_list ')'
    8301             :  { 
    8302           0 :  $$ = cat_str(5,mm_strdup("alter operator"),$3,mm_strdup("set ("),$6,mm_strdup(")"));
    8303             : }
    8304             : ;
    8305             : 
    8306             : 
    8307             :  operator_def_list:
    8308             :  operator_def_elem
    8309             :  { 
    8310           0 :  $$ = $1;
    8311             : }
    8312             : |  operator_def_list ',' operator_def_elem
    8313             :  { 
    8314           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    8315             : }
    8316             : ;
    8317             : 
    8318             : 
    8319             :  operator_def_elem:
    8320             :  ColLabel '=' NONE
    8321             :  { 
    8322           0 :  $$ = cat_str(2,$1,mm_strdup("= none"));
    8323             : }
    8324             : |  ColLabel '=' operator_def_arg
    8325             :  { 
    8326           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    8327             : }
    8328             : ;
    8329             : 
    8330             : 
    8331             :  operator_def_arg:
    8332             :  func_type
    8333             :  { 
    8334           0 :  $$ = $1;
    8335             : }
    8336             : |  reserved_keyword
    8337             :  { 
    8338           0 :  $$ = $1;
    8339             : }
    8340             : |  qual_all_Op
    8341             :  { 
    8342           0 :  $$ = $1;
    8343             : }
    8344             : |  NumericOnly
    8345             :  { 
    8346           0 :  $$ = $1;
    8347             : }
    8348             : |  ecpg_sconst
    8349             :  { 
    8350           0 :  $$ = $1;
    8351             : }
    8352             : ;
    8353             : 
    8354             : 
    8355             :  AlterTypeStmt:
    8356             :  ALTER TYPE_P any_name SET '(' operator_def_list ')'
    8357             :  { 
    8358           0 :  $$ = cat_str(5,mm_strdup("alter type"),$3,mm_strdup("set ("),$6,mm_strdup(")"));
    8359             : }
    8360             : ;
    8361             : 
    8362             : 
    8363             :  AlterOwnerStmt:
    8364             :  ALTER AGGREGATE aggregate_with_argtypes OWNER TO RoleSpec
    8365             :  { 
    8366           0 :  $$ = cat_str(4,mm_strdup("alter aggregate"),$3,mm_strdup("owner to"),$6);
    8367             : }
    8368             : |  ALTER COLLATION any_name OWNER TO RoleSpec
    8369             :  { 
    8370           0 :  $$ = cat_str(4,mm_strdup("alter collation"),$3,mm_strdup("owner to"),$6);
    8371             : }
    8372             : |  ALTER CONVERSION_P any_name OWNER TO RoleSpec
    8373             :  { 
    8374           0 :  $$ = cat_str(4,mm_strdup("alter conversion"),$3,mm_strdup("owner to"),$6);
    8375             : }
    8376             : |  ALTER DATABASE name OWNER TO RoleSpec
    8377             :  { 
    8378           0 :  $$ = cat_str(4,mm_strdup("alter database"),$3,mm_strdup("owner to"),$6);
    8379             : }
    8380             : |  ALTER DOMAIN_P any_name OWNER TO RoleSpec
    8381             :  { 
    8382           0 :  $$ = cat_str(4,mm_strdup("alter domain"),$3,mm_strdup("owner to"),$6);
    8383             : }
    8384             : |  ALTER FUNCTION function_with_argtypes OWNER TO RoleSpec
    8385             :  { 
    8386           0 :  $$ = cat_str(4,mm_strdup("alter function"),$3,mm_strdup("owner to"),$6);
    8387             : }
    8388             : |  ALTER opt_procedural LANGUAGE name OWNER TO RoleSpec
    8389             :  { 
    8390           0 :  $$ = cat_str(6,mm_strdup("alter"),$2,mm_strdup("language"),$4,mm_strdup("owner to"),$7);
    8391             : }
    8392             : |  ALTER LARGE_P OBJECT_P NumericOnly OWNER TO RoleSpec
    8393             :  { 
    8394           0 :  $$ = cat_str(4,mm_strdup("alter large object"),$4,mm_strdup("owner to"),$7);
    8395             : }
    8396             : |  ALTER OPERATOR operator_with_argtypes OWNER TO RoleSpec
    8397             :  { 
    8398           0 :  $$ = cat_str(4,mm_strdup("alter operator"),$3,mm_strdup("owner to"),$6);
    8399             : }
    8400             : |  ALTER OPERATOR CLASS any_name USING name OWNER TO RoleSpec
    8401             :  { 
    8402           0 :  $$ = cat_str(6,mm_strdup("alter operator class"),$4,mm_strdup("using"),$6,mm_strdup("owner to"),$9);
    8403             : }
    8404             : |  ALTER OPERATOR FAMILY any_name USING name OWNER TO RoleSpec
    8405             :  { 
    8406           0 :  $$ = cat_str(6,mm_strdup("alter operator family"),$4,mm_strdup("using"),$6,mm_strdup("owner to"),$9);
    8407             : }
    8408             : |  ALTER PROCEDURE procedure_with_argtypes OWNER TO RoleSpec
    8409             :  { 
    8410           0 :  $$ = cat_str(4,mm_strdup("alter procedure"),$3,mm_strdup("owner to"),$6);
    8411             : }
    8412             : |  ALTER ROUTINE procedure_with_argtypes OWNER TO RoleSpec
    8413             :  { 
    8414           0 :  $$ = cat_str(4,mm_strdup("alter routine"),$3,mm_strdup("owner to"),$6);
    8415             : }
    8416             : |  ALTER SCHEMA name OWNER TO RoleSpec
    8417             :  { 
    8418           0 :  $$ = cat_str(4,mm_strdup("alter schema"),$3,mm_strdup("owner to"),$6);
    8419             : }
    8420             : |  ALTER TYPE_P any_name OWNER TO RoleSpec
    8421             :  { 
    8422           0 :  $$ = cat_str(4,mm_strdup("alter type"),$3,mm_strdup("owner to"),$6);
    8423             : }
    8424             : |  ALTER TABLESPACE name OWNER TO RoleSpec
    8425             :  { 
    8426           0 :  $$ = cat_str(4,mm_strdup("alter tablespace"),$3,mm_strdup("owner to"),$6);
    8427             : }
    8428             : |  ALTER STATISTICS any_name OWNER TO RoleSpec
    8429             :  { 
    8430           0 :  $$ = cat_str(4,mm_strdup("alter statistics"),$3,mm_strdup("owner to"),$6);
    8431             : }
    8432             : |  ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO RoleSpec
    8433             :  { 
    8434           0 :  $$ = cat_str(4,mm_strdup("alter text search dictionary"),$5,mm_strdup("owner to"),$8);
    8435             : }
    8436             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO RoleSpec
    8437             :  { 
    8438           0 :  $$ = cat_str(4,mm_strdup("alter text search configuration"),$5,mm_strdup("owner to"),$8);
    8439             : }
    8440             : |  ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleSpec
    8441             :  { 
    8442           0 :  $$ = cat_str(4,mm_strdup("alter foreign data wrapper"),$5,mm_strdup("owner to"),$8);
    8443             : }
    8444             : |  ALTER SERVER name OWNER TO RoleSpec
    8445             :  { 
    8446           0 :  $$ = cat_str(4,mm_strdup("alter server"),$3,mm_strdup("owner to"),$6);
    8447             : }
    8448             : |  ALTER EVENT TRIGGER name OWNER TO RoleSpec
    8449             :  { 
    8450           0 :  $$ = cat_str(4,mm_strdup("alter event trigger"),$4,mm_strdup("owner to"),$7);
    8451             : }
    8452             : |  ALTER PUBLICATION name OWNER TO RoleSpec
    8453             :  { 
    8454           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("owner to"),$6);
    8455             : }
    8456             : |  ALTER SUBSCRIPTION name OWNER TO RoleSpec
    8457             :  { 
    8458           0 :  $$ = cat_str(4,mm_strdup("alter subscription"),$3,mm_strdup("owner to"),$6);
    8459             : }
    8460             : ;
    8461             : 
    8462             : 
    8463             :  CreatePublicationStmt:
    8464             :  CREATE PUBLICATION name opt_publication_for_tables opt_definition
    8465             :  { 
    8466           0 :  $$ = cat_str(4,mm_strdup("create publication"),$3,$4,$5);
    8467             : }
    8468             : ;
    8469             : 
    8470             : 
    8471             :  opt_publication_for_tables:
    8472             :  publication_for_tables
    8473             :  { 
    8474           0 :  $$ = $1;
    8475             : }
    8476             : | 
    8477             :  { 
    8478           0 :  $$=EMPTY; }
    8479             : ;
    8480             : 
    8481             : 
    8482             :  publication_for_tables:
    8483             :  FOR TABLE relation_expr_list
    8484             :  { 
    8485           0 :  $$ = cat_str(2,mm_strdup("for table"),$3);
    8486             : }
    8487             : |  FOR ALL TABLES
    8488             :  { 
    8489           0 :  $$ = mm_strdup("for all tables");
    8490             : }
    8491             : ;
    8492             : 
    8493             : 
    8494             :  AlterPublicationStmt:
    8495             :  ALTER PUBLICATION name SET definition
    8496             :  { 
    8497           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("set"),$5);
    8498             : }
    8499             : |  ALTER PUBLICATION name ADD_P TABLE relation_expr_list
    8500             :  { 
    8501           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("add table"),$6);
    8502             : }
    8503             : |  ALTER PUBLICATION name SET TABLE relation_expr_list
    8504             :  { 
    8505           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("set table"),$6);
    8506             : }
    8507             : |  ALTER PUBLICATION name DROP TABLE relation_expr_list
    8508             :  { 
    8509           0 :  $$ = cat_str(4,mm_strdup("alter publication"),$3,mm_strdup("drop table"),$6);
    8510             : }
    8511             : ;
    8512             : 
    8513             : 
    8514             :  CreateSubscriptionStmt:
    8515             :  CREATE SUBSCRIPTION name CONNECTION ecpg_sconst PUBLICATION publication_name_list opt_definition
    8516             :  { 
    8517           0 :  $$ = cat_str(7,mm_strdup("create subscription"),$3,mm_strdup("connection"),$5,mm_strdup("publication"),$7,$8);
    8518             : }
    8519             : ;
    8520             : 
    8521             : 
    8522             :  publication_name_list:
    8523             :  publication_name_item
    8524             :  { 
    8525           0 :  $$ = $1;
    8526             : }
    8527             : |  publication_name_list ',' publication_name_item
    8528             :  { 
    8529           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    8530             : }
    8531             : ;
    8532             : 
    8533             : 
    8534             :  publication_name_item:
    8535             :  ColLabel
    8536             :  { 
    8537           0 :  $$ = $1;
    8538             : }
    8539             : ;
    8540             : 
    8541             : 
    8542             :  AlterSubscriptionStmt:
    8543             :  ALTER SUBSCRIPTION name SET definition
    8544             :  { 
    8545           0 :  $$ = cat_str(4,mm_strdup("alter subscription"),$3,mm_strdup("set"),$5);
    8546             : }
    8547             : |  ALTER SUBSCRIPTION name CONNECTION ecpg_sconst
    8548             :  { 
    8549           0 :  $$ = cat_str(4,mm_strdup("alter subscription"),$3,mm_strdup("connection"),$5);
    8550             : }
    8551             : |  ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition
    8552             :  { 
    8553           0 :  $$ = cat_str(4,mm_strdup("alter subscription"),$3,mm_strdup("refresh publication"),$6);
    8554             : }
    8555             : |  ALTER SUBSCRIPTION name SET PUBLICATION publication_name_list opt_definition
    8556             :  { 
    8557           0 :  $$ = cat_str(5,mm_strdup("alter subscription"),$3,mm_strdup("set publication"),$6,$7);
    8558             : }
    8559             : |  ALTER SUBSCRIPTION name ENABLE_P
    8560             :  { 
    8561           0 :  $$ = cat_str(3,mm_strdup("alter subscription"),$3,mm_strdup("enable"));
    8562             : }
    8563             : |  ALTER SUBSCRIPTION name DISABLE_P
    8564             :  { 
    8565           0 :  $$ = cat_str(3,mm_strdup("alter subscription"),$3,mm_strdup("disable"));
    8566             : }
    8567             : ;
    8568             : 
    8569             : 
    8570             :  DropSubscriptionStmt:
    8571             :  DROP SUBSCRIPTION name opt_drop_behavior
    8572             :  { 
    8573           0 :  $$ = cat_str(3,mm_strdup("drop subscription"),$3,$4);
    8574             : }
    8575             : |  DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior
    8576             :  { 
    8577           0 :  $$ = cat_str(3,mm_strdup("drop subscription if exists"),$5,$6);
    8578             : }
    8579             : ;
    8580             : 
    8581             : 
    8582             :  RuleStmt:
    8583             :  CREATE opt_or_replace RULE name AS ON event TO qualified_name where_clause DO opt_instead RuleActionList
    8584             :  { 
    8585           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);
    8586             : }
    8587             : ;
    8588             : 
    8589             : 
    8590             :  RuleActionList:
    8591             :  NOTHING
    8592             :  { 
    8593           0 :  $$ = mm_strdup("nothing");
    8594             : }
    8595             : |  RuleActionStmt
    8596             :  { 
    8597           0 :  $$ = $1;
    8598             : }
    8599             : |  '(' RuleActionMulti ')'
    8600             :  { 
    8601           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    8602             : }
    8603             : ;
    8604             : 
    8605             : 
    8606             :  RuleActionMulti:
    8607             :  RuleActionMulti ';' RuleActionStmtOrEmpty
    8608             :  { 
    8609           0 :  $$ = cat_str(3,$1,mm_strdup(";"),$3);
    8610             : }
    8611             : |  RuleActionStmtOrEmpty
    8612             :  { 
    8613           0 :  $$ = $1;
    8614             : }
    8615             : ;
    8616             : 
    8617             : 
    8618             :  RuleActionStmt:
    8619             :  SelectStmt
    8620             :  { 
    8621           0 :  $$ = $1;
    8622             : }
    8623             : |  InsertStmt
    8624             :  { 
    8625           0 :  $$ = $1;
    8626             : }
    8627             : |  UpdateStmt
    8628             :  { 
    8629           0 :  $$ = $1;
    8630             : }
    8631             : |  DeleteStmt
    8632             :  { 
    8633           0 :  $$ = $1;
    8634             : }
    8635             : |  NotifyStmt
    8636             :  { 
    8637           0 :  $$ = $1;
    8638             : }
    8639             : ;
    8640             : 
    8641             : 
    8642             :  RuleActionStmtOrEmpty:
    8643             :  RuleActionStmt
    8644             :  { 
    8645           0 :  $$ = $1;
    8646             : }
    8647             : | 
    8648             :  { 
    8649           0 :  $$=EMPTY; }
    8650             : ;
    8651             : 
    8652             : 
    8653             :  event:
    8654             :  SELECT
    8655             :  { 
    8656           0 :  $$ = mm_strdup("select");
    8657             : }
    8658             : |  UPDATE
    8659             :  { 
    8660           0 :  $$ = mm_strdup("update");
    8661             : }
    8662             : |  DELETE_P
    8663             :  { 
    8664           0 :  $$ = mm_strdup("delete");
    8665             : }
    8666             : |  INSERT
    8667             :  { 
    8668           0 :  $$ = mm_strdup("insert");
    8669             : }
    8670             : ;
    8671             : 
    8672             : 
    8673             :  opt_instead:
    8674             :  INSTEAD
    8675             :  { 
    8676           0 :  $$ = mm_strdup("instead");
    8677             : }
    8678             : |  ALSO
    8679             :  { 
    8680           0 :  $$ = mm_strdup("also");
    8681             : }
    8682             : | 
    8683             :  { 
    8684           0 :  $$=EMPTY; }
    8685             : ;
    8686             : 
    8687             : 
    8688             :  NotifyStmt:
    8689             :  NOTIFY ColId notify_payload
    8690             :  { 
    8691           0 :  $$ = cat_str(3,mm_strdup("notify"),$2,$3);
    8692             : }
    8693             : ;
    8694             : 
    8695             : 
    8696             :  notify_payload:
    8697             :  ',' ecpg_sconst
    8698             :  { 
    8699           0 :  $$ = cat_str(2,mm_strdup(","),$2);
    8700             : }
    8701             : | 
    8702             :  { 
    8703           0 :  $$=EMPTY; }
    8704             : ;
    8705             : 
    8706             : 
    8707             :  ListenStmt:
    8708             :  LISTEN ColId
    8709             :  { 
    8710           0 :  $$ = cat_str(2,mm_strdup("listen"),$2);
    8711             : }
    8712             : ;
    8713             : 
    8714             : 
    8715             :  UnlistenStmt:
    8716             :  UNLISTEN ColId
    8717             :  { 
    8718           0 :  $$ = cat_str(2,mm_strdup("unlisten"),$2);
    8719             : }
    8720             : |  UNLISTEN '*'
    8721             :  { 
    8722           0 :  $$ = mm_strdup("unlisten *");
    8723             : }
    8724             : ;
    8725             : 
    8726             : 
    8727             :  TransactionStmt:
    8728             :  ABORT_P opt_transaction opt_transaction_chain
    8729             :  { 
    8730           0 :  $$ = cat_str(3,mm_strdup("abort"),$2,$3);
    8731             : }
    8732             : |  BEGIN_P opt_transaction transaction_mode_list_or_empty
    8733             :  { 
    8734          16 :  $$ = cat_str(3,mm_strdup("begin"),$2,$3);
    8735             : }
    8736             : |  START TRANSACTION transaction_mode_list_or_empty
    8737             :  { 
    8738           0 :  $$ = cat_str(2,mm_strdup("start transaction"),$3);
    8739             : }
    8740             : |  COMMIT opt_transaction opt_transaction_chain
    8741             :  { 
    8742         116 :  $$ = cat_str(3,mm_strdup("commit"),$2,$3);
    8743             : }
    8744             : |  END_P opt_transaction opt_transaction_chain
    8745             :  { 
    8746           0 :  $$ = cat_str(3,mm_strdup("end"),$2,$3);
    8747             : }
    8748             : |  ROLLBACK opt_transaction opt_transaction_chain
    8749             :  { 
    8750          32 :  $$ = cat_str(3,mm_strdup("rollback"),$2,$3);
    8751             : }
    8752             : |  SAVEPOINT ColId
    8753             :  { 
    8754           0 :  $$ = cat_str(2,mm_strdup("savepoint"),$2);
    8755             : }
    8756             : |  RELEASE SAVEPOINT ColId
    8757             :  { 
    8758           0 :  $$ = cat_str(2,mm_strdup("release savepoint"),$3);
    8759             : }
    8760             : |  RELEASE ColId
    8761             :  { 
    8762           0 :  $$ = cat_str(2,mm_strdup("release"),$2);
    8763             : }
    8764             : |  ROLLBACK opt_transaction TO SAVEPOINT ColId
    8765             :  { 
    8766           0 :  $$ = cat_str(4,mm_strdup("rollback"),$2,mm_strdup("to savepoint"),$5);
    8767             : }
    8768             : |  ROLLBACK opt_transaction TO ColId
    8769             :  { 
    8770           0 :  $$ = cat_str(4,mm_strdup("rollback"),$2,mm_strdup("to"),$4);
    8771             : }
    8772             : |  PREPARE TRANSACTION ecpg_sconst
    8773             :  { 
    8774           2 :  $$ = cat_str(2,mm_strdup("prepare transaction"),$3);
    8775             : }
    8776             : |  COMMIT PREPARED ecpg_sconst
    8777             :  { 
    8778           2 :  $$ = cat_str(2,mm_strdup("commit prepared"),$3);
    8779             : }
    8780             : |  ROLLBACK PREPARED ecpg_sconst
    8781             :  { 
    8782           0 :  $$ = cat_str(2,mm_strdup("rollback prepared"),$3);
    8783             : }
    8784             : ;
    8785             : 
    8786             : 
    8787             :  opt_transaction:
    8788             :  WORK
    8789             :  { 
    8790          22 :  $$ = mm_strdup("work");
    8791             : }
    8792             : |  TRANSACTION
    8793             :  { 
    8794           0 :  $$ = mm_strdup("transaction");
    8795             : }
    8796             : | 
    8797             :  { 
    8798         142 :  $$=EMPTY; }
    8799             : ;
    8800             : 
    8801             : 
    8802             :  transaction_mode_item:
    8803             :  ISOLATION LEVEL iso_level
    8804             :  { 
    8805           2 :  $$ = cat_str(2,mm_strdup("isolation level"),$3);
    8806             : }
    8807             : |  READ ONLY
    8808             :  { 
    8809           0 :  $$ = mm_strdup("read only");
    8810             : }
    8811             : |  READ WRITE
    8812             :  { 
    8813           0 :  $$ = mm_strdup("read write");
    8814             : }
    8815             : |  DEFERRABLE
    8816             :  { 
    8817           0 :  $$ = mm_strdup("deferrable");
    8818             : }
    8819             : |  NOT DEFERRABLE
    8820             :  { 
    8821           0 :  $$ = mm_strdup("not deferrable");
    8822             : }
    8823             : ;
    8824             : 
    8825             : 
    8826             :  transaction_mode_list:
    8827             :  transaction_mode_item
    8828             :  { 
    8829           2 :  $$ = $1;
    8830             : }
    8831             : |  transaction_mode_list ',' transaction_mode_item
    8832             :  { 
    8833           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    8834             : }
    8835             : |  transaction_mode_list transaction_mode_item
    8836             :  { 
    8837           0 :  $$ = cat_str(2,$1,$2);
    8838             : }
    8839             : ;
    8840             : 
    8841             : 
    8842             :  transaction_mode_list_or_empty:
    8843             :  transaction_mode_list
    8844             :  { 
    8845           0 :  $$ = $1;
    8846             : }
    8847             : | 
    8848             :  { 
    8849          16 :  $$=EMPTY; }
    8850             : ;
    8851             : 
    8852             : 
    8853             :  opt_transaction_chain:
    8854             :  AND CHAIN
    8855             :  { 
    8856           0 :  $$ = mm_strdup("and chain");
    8857             : }
    8858             : |  AND NO CHAIN
    8859             :  { 
    8860           0 :  $$ = mm_strdup("and no chain");
    8861             : }
    8862             : | 
    8863             :  { 
    8864         148 :  $$=EMPTY; }
    8865             : ;
    8866             : 
    8867             : 
    8868             :  ViewStmt:
    8869             :  CREATE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option
    8870             :  { 
    8871           0 :  $$ = cat_str(9,mm_strdup("create"),$2,mm_strdup("view"),$4,$5,$6,mm_strdup("as"),$8,$9);
    8872             : }
    8873             : |  CREATE OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions AS SelectStmt opt_check_option
    8874             :  { 
    8875           0 :  $$ = cat_str(9,mm_strdup("create or replace"),$4,mm_strdup("view"),$6,$7,$8,mm_strdup("as"),$10,$11);
    8876             : }
    8877             : |  CREATE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option
    8878             :  { 
    8879           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    8880           0 :  $$ = cat_str(11,mm_strdup("create"),$2,mm_strdup("recursive view"),$5,mm_strdup("("),$7,mm_strdup(")"),$9,mm_strdup("as"),$11,$12);
    8881             : }
    8882             : |  CREATE OR REPLACE OptTemp RECURSIVE VIEW qualified_name '(' columnList ')' opt_reloptions AS SelectStmt opt_check_option
    8883             :  { 
    8884           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
    8885           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);
    8886             : }
    8887             : ;
    8888             : 
    8889             : 
    8890             :  opt_check_option:
    8891             :  WITH CHECK OPTION
    8892             :  { 
    8893           0 :  $$ = mm_strdup("with check option");
    8894             : }
    8895             : |  WITH CASCADED CHECK OPTION
    8896             :  { 
    8897           0 :  $$ = mm_strdup("with cascaded check option");
    8898             : }
    8899             : |  WITH LOCAL CHECK OPTION
    8900             :  { 
    8901           0 :  $$ = mm_strdup("with local check option");
    8902             : }
    8903             : | 
    8904             :  { 
    8905           0 :  $$=EMPTY; }
    8906             : ;
    8907             : 
    8908             : 
    8909             :  LoadStmt:
    8910             :  LOAD file_name
    8911             :  { 
    8912           0 :  $$ = cat_str(2,mm_strdup("load"),$2);
    8913             : }
    8914             : ;
    8915             : 
    8916             : 
    8917             :  CreatedbStmt:
    8918             :  CREATE DATABASE name opt_with createdb_opt_list
    8919             :  { 
    8920           0 :  $$ = cat_str(4,mm_strdup("create database"),$3,$4,$5);
    8921             : }
    8922             : ;
    8923             : 
    8924             : 
    8925             :  createdb_opt_list:
    8926             :  createdb_opt_items
    8927             :  { 
    8928           0 :  $$ = $1;
    8929             : }
    8930             : | 
    8931             :  { 
    8932           0 :  $$=EMPTY; }
    8933             : ;
    8934             : 
    8935             : 
    8936             :  createdb_opt_items:
    8937             :  createdb_opt_item
    8938             :  { 
    8939           0 :  $$ = $1;
    8940             : }
    8941             : |  createdb_opt_items createdb_opt_item
    8942             :  { 
    8943           0 :  $$ = cat_str(2,$1,$2);
    8944             : }
    8945             : ;
    8946             : 
    8947             : 
    8948             :  createdb_opt_item:
    8949             :  createdb_opt_name opt_equal SignedIconst
    8950             :  { 
    8951           0 :  $$ = cat_str(3,$1,$2,$3);
    8952             : }
    8953             : |  createdb_opt_name opt_equal opt_boolean_or_string
    8954             :  { 
    8955           0 :  $$ = cat_str(3,$1,$2,$3);
    8956             : }
    8957             : |  createdb_opt_name opt_equal DEFAULT
    8958             :  { 
    8959           0 :  $$ = cat_str(3,$1,$2,mm_strdup("default"));
    8960             : }
    8961             : ;
    8962             : 
    8963             : 
    8964             :  createdb_opt_name:
    8965             :  ecpg_ident
    8966             :  { 
    8967           0 :  $$ = $1;
    8968             : }
    8969             : |  CONNECTION LIMIT
    8970             :  { 
    8971           0 :  $$ = mm_strdup("connection limit");
    8972             : }
    8973             : |  ENCODING
    8974             :  { 
    8975           0 :  $$ = mm_strdup("encoding");
    8976             : }
    8977             : |  LOCATION
    8978             :  { 
    8979           0 :  $$ = mm_strdup("location");
    8980             : }
    8981             : |  OWNER
    8982             :  { 
    8983           0 :  $$ = mm_strdup("owner");
    8984             : }
    8985             : |  TABLESPACE
    8986             :  { 
    8987           0 :  $$ = mm_strdup("tablespace");
    8988             : }
    8989             : |  TEMPLATE
    8990             :  { 
    8991           0 :  $$ = mm_strdup("template");
    8992             : }
    8993             : ;
    8994             : 
    8995             : 
    8996             :  opt_equal:
    8997             :  '='
    8998             :  { 
    8999           0 :  $$ = mm_strdup("=");
    9000             : }
    9001             : | 
    9002             :  { 
    9003           0 :  $$=EMPTY; }
    9004             : ;
    9005             : 
    9006             : 
    9007             :  AlterDatabaseStmt:
    9008             :  ALTER DATABASE name WITH createdb_opt_list
    9009             :  { 
    9010           0 :  $$ = cat_str(4,mm_strdup("alter database"),$3,mm_strdup("with"),$5);
    9011             : }
    9012             : |  ALTER DATABASE name createdb_opt_list
    9013             :  { 
    9014           0 :  $$ = cat_str(3,mm_strdup("alter database"),$3,$4);
    9015             : }
    9016             : |  ALTER DATABASE name SET TABLESPACE name
    9017             :  { 
    9018           0 :  $$ = cat_str(4,mm_strdup("alter database"),$3,mm_strdup("set tablespace"),$6);
    9019             : }
    9020             : ;
    9021             : 
    9022             : 
    9023             :  AlterDatabaseSetStmt:
    9024             :  ALTER DATABASE name SetResetClause
    9025             :  { 
    9026           0 :  $$ = cat_str(3,mm_strdup("alter database"),$3,$4);
    9027             : }
    9028             : ;
    9029             : 
    9030             : 
    9031             :  DropdbStmt:
    9032             :  DROP DATABASE name
    9033             :  { 
    9034           0 :  $$ = cat_str(2,mm_strdup("drop database"),$3);
    9035             : }
    9036             : |  DROP DATABASE IF_P EXISTS name
    9037             :  { 
    9038           0 :  $$ = cat_str(2,mm_strdup("drop database if exists"),$5);
    9039             : }
    9040             : |  DROP DATABASE name opt_with '(' drop_option_list ')'
    9041             :  { 
    9042           0 :  $$ = cat_str(6,mm_strdup("drop database"),$3,$4,mm_strdup("("),$6,mm_strdup(")"));
    9043             : }
    9044             : |  DROP DATABASE IF_P EXISTS name opt_with '(' drop_option_list ')'
    9045             :  { 
    9046           0 :  $$ = cat_str(6,mm_strdup("drop database if exists"),$5,$6,mm_strdup("("),$8,mm_strdup(")"));
    9047             : }
    9048             : ;
    9049             : 
    9050             : 
    9051             :  drop_option_list:
    9052             :  drop_option
    9053             :  { 
    9054           0 :  $$ = $1;
    9055             : }
    9056             : |  drop_option_list ',' drop_option
    9057             :  { 
    9058           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9059             : }
    9060             : ;
    9061             : 
    9062             : 
    9063             :  drop_option:
    9064             :  FORCE
    9065             :  { 
    9066           0 :  $$ = mm_strdup("force");
    9067             : }
    9068             : ;
    9069             : 
    9070             : 
    9071             :  AlterSystemStmt:
    9072             :  ALTER SYSTEM_P SET generic_set
    9073             :  { 
    9074           0 :  $$ = cat_str(2,mm_strdup("alter system set"),$4);
    9075             : }
    9076             : |  ALTER SYSTEM_P RESET generic_reset
    9077             :  { 
    9078           0 :  $$ = cat_str(2,mm_strdup("alter system reset"),$4);
    9079             : }
    9080             : ;
    9081             : 
    9082             : 
    9083             :  CreateDomainStmt:
    9084             :  CREATE DOMAIN_P any_name opt_as Typename ColQualList
    9085             :  { 
    9086           0 :  $$ = cat_str(5,mm_strdup("create domain"),$3,$4,$5,$6);
    9087             : }
    9088             : ;
    9089             : 
    9090             : 
    9091             :  AlterDomainStmt:
    9092             :  ALTER DOMAIN_P any_name alter_column_default
    9093             :  { 
    9094           0 :  $$ = cat_str(3,mm_strdup("alter domain"),$3,$4);
    9095             : }
    9096             : |  ALTER DOMAIN_P any_name DROP NOT NULL_P
    9097             :  { 
    9098           0 :  $$ = cat_str(3,mm_strdup("alter domain"),$3,mm_strdup("drop not null"));
    9099             : }
    9100             : |  ALTER DOMAIN_P any_name SET NOT NULL_P
    9101             :  { 
    9102           0 :  $$ = cat_str(3,mm_strdup("alter domain"),$3,mm_strdup("set not null"));
    9103             : }
    9104             : |  ALTER DOMAIN_P any_name ADD_P TableConstraint
    9105             :  { 
    9106           0 :  $$ = cat_str(4,mm_strdup("alter domain"),$3,mm_strdup("add"),$5);
    9107             : }
    9108             : |  ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
    9109             :  { 
    9110           0 :  $$ = cat_str(5,mm_strdup("alter domain"),$3,mm_strdup("drop constraint"),$6,$7);
    9111             : }
    9112             : |  ALTER DOMAIN_P any_name DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
    9113             :  { 
    9114           0 :  $$ = cat_str(5,mm_strdup("alter domain"),$3,mm_strdup("drop constraint if exists"),$8,$9);
    9115             : }
    9116             : |  ALTER DOMAIN_P any_name VALIDATE CONSTRAINT name
    9117             :  { 
    9118           0 :  $$ = cat_str(4,mm_strdup("alter domain"),$3,mm_strdup("validate constraint"),$6);
    9119             : }
    9120             : ;
    9121             : 
    9122             : 
    9123             :  opt_as:
    9124             :  AS
    9125             :  { 
    9126           0 :  $$ = mm_strdup("as");
    9127             : }
    9128             : | 
    9129             :  { 
    9130           2 :  $$=EMPTY; }
    9131             : ;
    9132             : 
    9133             : 
    9134             :  AlterTSDictionaryStmt:
    9135             :  ALTER TEXT_P SEARCH DICTIONARY any_name definition
    9136             :  { 
    9137           0 :  $$ = cat_str(3,mm_strdup("alter text search dictionary"),$5,$6);
    9138             : }
    9139             : ;
    9140             : 
    9141             : 
    9142             :  AlterTSConfigurationStmt:
    9143             :  ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list
    9144             :  { 
    9145           0 :  $$ = cat_str(6,mm_strdup("alter text search configuration"),$5,mm_strdup("add mapping for"),$9,$10,$11);
    9146             : }
    9147             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list
    9148             :  { 
    9149           0 :  $$ = cat_str(6,mm_strdup("alter text search configuration"),$5,mm_strdup("alter mapping for"),$9,$10,$11);
    9150             : }
    9151             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name
    9152             :  { 
    9153           0 :  $$ = cat_str(6,mm_strdup("alter text search configuration"),$5,mm_strdup("alter mapping replace"),$9,$10,$11);
    9154             : }
    9155             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name
    9156             :  { 
    9157           0 :  $$ = cat_str(8,mm_strdup("alter text search configuration"),$5,mm_strdup("alter mapping for"),$9,mm_strdup("replace"),$11,$12,$13);
    9158             : }
    9159             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
    9160             :  { 
    9161           0 :  $$ = cat_str(4,mm_strdup("alter text search configuration"),$5,mm_strdup("drop mapping for"),$9);
    9162             : }
    9163             : |  ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
    9164             :  { 
    9165           0 :  $$ = cat_str(4,mm_strdup("alter text search configuration"),$5,mm_strdup("drop mapping if exists for"),$11);
    9166             : }
    9167             : ;
    9168             : 
    9169             : 
    9170             :  any_with:
    9171             :  WITH
    9172             :  { 
    9173           0 :  $$ = mm_strdup("with");
    9174             : }
    9175             : |  WITH_LA
    9176             :  { 
    9177           0 :  $$ = mm_strdup("with");
    9178             : }
    9179             : ;
    9180             : 
    9181             : 
    9182             :  CreateConversionStmt:
    9183             :  CREATE opt_default CONVERSION_P any_name FOR ecpg_sconst TO ecpg_sconst FROM any_name
    9184             :  { 
    9185           0 :  $$ = cat_str(10,mm_strdup("create"),$2,mm_strdup("conversion"),$4,mm_strdup("for"),$6,mm_strdup("to"),$8,mm_strdup("from"),$10);
    9186             : }
    9187             : ;
    9188             : 
    9189             : 
    9190             :  ClusterStmt:
    9191             :  CLUSTER opt_verbose qualified_name cluster_index_specification
    9192             :  { 
    9193           0 :  $$ = cat_str(4,mm_strdup("cluster"),$2,$3,$4);
    9194             : }
    9195             : |  CLUSTER opt_verbose
    9196             :  { 
    9197           0 :  $$ = cat_str(2,mm_strdup("cluster"),$2);
    9198             : }
    9199             : |  CLUSTER opt_verbose name ON qualified_name
    9200             :  { 
    9201           0 :  $$ = cat_str(5,mm_strdup("cluster"),$2,$3,mm_strdup("on"),$5);
    9202             : }
    9203             : ;
    9204             : 
    9205             : 
    9206             :  cluster_index_specification:
    9207             :  USING name
    9208             :  { 
    9209           0 :  $$ = cat_str(2,mm_strdup("using"),$2);
    9210             : }
    9211             : | 
    9212             :  { 
    9213           0 :  $$=EMPTY; }
    9214             : ;
    9215             : 
    9216             : 
    9217             :  VacuumStmt:
    9218             :  VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list
    9219             :  { 
    9220           0 :  $$ = cat_str(6,mm_strdup("vacuum"),$2,$3,$4,$5,$6);
    9221             : }
    9222             : |  VACUUM '(' vac_analyze_option_list ')' opt_vacuum_relation_list
    9223             :  { 
    9224           0 :  $$ = cat_str(4,mm_strdup("vacuum ("),$3,mm_strdup(")"),$5);
    9225             : }
    9226             : ;
    9227             : 
    9228             : 
    9229             :  AnalyzeStmt:
    9230             :  analyze_keyword opt_verbose opt_vacuum_relation_list
    9231             :  { 
    9232           0 :  $$ = cat_str(3,$1,$2,$3);
    9233             : }
    9234             : |  analyze_keyword '(' vac_analyze_option_list ')' opt_vacuum_relation_list
    9235             :  { 
    9236           0 :  $$ = cat_str(5,$1,mm_strdup("("),$3,mm_strdup(")"),$5);
    9237             : }
    9238             : ;
    9239             : 
    9240             : 
    9241             :  vac_analyze_option_list:
    9242             :  vac_analyze_option_elem
    9243             :  { 
    9244           0 :  $$ = $1;
    9245             : }
    9246             : |  vac_analyze_option_list ',' vac_analyze_option_elem
    9247             :  { 
    9248           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9249             : }
    9250             : ;
    9251             : 
    9252             : 
    9253             :  analyze_keyword:
    9254             :  ANALYZE
    9255             :  { 
    9256           0 :  $$ = mm_strdup("analyze");
    9257             : }
    9258             : |  ANALYSE
    9259             :  { 
    9260           0 :  $$ = mm_strdup("analyse");
    9261             : }
    9262             : ;
    9263             : 
    9264             : 
    9265             :  vac_analyze_option_elem:
    9266             :  vac_analyze_option_name vac_analyze_option_arg
    9267             :  { 
    9268           0 :  $$ = cat_str(2,$1,$2);
    9269             : }
    9270             : ;
    9271             : 
    9272             : 
    9273             :  vac_analyze_option_name:
    9274             :  NonReservedWord
    9275             :  { 
    9276           0 :  $$ = $1;
    9277             : }
    9278             : |  analyze_keyword
    9279             :  { 
    9280           0 :  $$ = $1;
    9281             : }
    9282             : ;
    9283             : 
    9284             : 
    9285             :  vac_analyze_option_arg:
    9286             :  opt_boolean_or_string
    9287             :  { 
    9288           0 :  $$ = $1;
    9289             : }
    9290             : |  NumericOnly
    9291             :  { 
    9292           0 :  $$ = $1;
    9293             : }
    9294             : | 
    9295             :  { 
    9296           0 :  $$=EMPTY; }
    9297             : ;
    9298             : 
    9299             : 
    9300             :  opt_analyze:
    9301             :  analyze_keyword
    9302             :  { 
    9303           0 :  $$ = $1;
    9304             : }
    9305             : | 
    9306             :  { 
    9307           0 :  $$=EMPTY; }
    9308             : ;
    9309             : 
    9310             : 
    9311             :  opt_verbose:
    9312             :  VERBOSE
    9313             :  { 
    9314           0 :  $$ = mm_strdup("verbose");
    9315             : }
    9316             : | 
    9317             :  { 
    9318           0 :  $$=EMPTY; }
    9319             : ;
    9320             : 
    9321             : 
    9322             :  opt_full:
    9323             :  FULL
    9324             :  { 
    9325           0 :  $$ = mm_strdup("full");
    9326             : }
    9327             : | 
    9328             :  { 
    9329           0 :  $$=EMPTY; }
    9330             : ;
    9331             : 
    9332             : 
    9333             :  opt_freeze:
    9334             :  FREEZE
    9335             :  { 
    9336           0 :  $$ = mm_strdup("freeze");
    9337             : }
    9338             : | 
    9339             :  { 
    9340           0 :  $$=EMPTY; }
    9341             : ;
    9342             : 
    9343             : 
    9344             :  opt_name_list:
    9345             :  '(' name_list ')'
    9346             :  { 
    9347           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    9348             : }
    9349             : | 
    9350             :  { 
    9351           0 :  $$=EMPTY; }
    9352             : ;
    9353             : 
    9354             : 
    9355             :  vacuum_relation:
    9356             :  qualified_name opt_name_list
    9357             :  { 
    9358           0 :  $$ = cat_str(2,$1,$2);
    9359             : }
    9360             : ;
    9361             : 
    9362             : 
    9363             :  vacuum_relation_list:
    9364             :  vacuum_relation
    9365             :  { 
    9366           0 :  $$ = $1;
    9367             : }
    9368             : |  vacuum_relation_list ',' vacuum_relation
    9369             :  { 
    9370           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9371             : }
    9372             : ;
    9373             : 
    9374             : 
    9375             :  opt_vacuum_relation_list:
    9376             :  vacuum_relation_list
    9377             :  { 
    9378           0 :  $$ = $1;
    9379             : }
    9380             : | 
    9381             :  { 
    9382           0 :  $$=EMPTY; }
    9383             : ;
    9384             : 
    9385             : 
    9386             :  ExplainStmt:
    9387             :  EXPLAIN ExplainableStmt
    9388             :  { 
    9389           0 :  $$ = cat_str(2,mm_strdup("explain"),$2);
    9390             : }
    9391             : |  EXPLAIN analyze_keyword opt_verbose ExplainableStmt
    9392             :  { 
    9393           0 :  $$ = cat_str(4,mm_strdup("explain"),$2,$3,$4);
    9394             : }
    9395             : |  EXPLAIN VERBOSE ExplainableStmt
    9396             :  { 
    9397           0 :  $$ = cat_str(2,mm_strdup("explain verbose"),$3);
    9398             : }
    9399             : |  EXPLAIN '(' explain_option_list ')' ExplainableStmt
    9400             :  { 
    9401           0 :  $$ = cat_str(4,mm_strdup("explain ("),$3,mm_strdup(")"),$5);
    9402             : }
    9403             : ;
    9404             : 
    9405             : 
    9406             :  ExplainableStmt:
    9407             :  SelectStmt
    9408             :  { 
    9409           0 :  $$ = $1;
    9410             : }
    9411             : |  InsertStmt
    9412             :  { 
    9413           0 :  $$ = $1;
    9414             : }
    9415             : |  UpdateStmt
    9416             :  { 
    9417           0 :  $$ = $1;
    9418             : }
    9419             : |  DeleteStmt
    9420             :  { 
    9421           0 :  $$ = $1;
    9422             : }
    9423             : |  DeclareCursorStmt
    9424             :  { 
    9425           0 :  $$ = $1;
    9426             : }
    9427             : |  CreateAsStmt
    9428             :  { 
    9429           0 :  $$ = $1;
    9430             : }
    9431             : |  CreateMatViewStmt
    9432             :  { 
    9433           0 :  $$ = $1;
    9434             : }
    9435             : |  RefreshMatViewStmt
    9436             :  { 
    9437           0 :  $$ = $1;
    9438             : }
    9439             : |  ExecuteStmt
    9440             :     {
    9441           0 :         $$ = $1.name;
    9442             :     }
    9443             : ;
    9444             : 
    9445             : 
    9446             :  explain_option_list:
    9447             :  explain_option_elem
    9448             :  { 
    9449           0 :  $$ = $1;
    9450             : }
    9451             : |  explain_option_list ',' explain_option_elem
    9452             :  { 
    9453           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9454             : }
    9455             : ;
    9456             : 
    9457             : 
    9458             :  explain_option_elem:
    9459             :  explain_option_name explain_option_arg
    9460             :  { 
    9461           0 :  $$ = cat_str(2,$1,$2);
    9462             : }
    9463             : ;
    9464             : 
    9465             : 
    9466             :  explain_option_name:
    9467             :  NonReservedWord
    9468             :  { 
    9469           0 :  $$ = $1;
    9470             : }
    9471             : |  analyze_keyword
    9472             :  { 
    9473           0 :  $$ = $1;
    9474             : }
    9475             : ;
    9476             : 
    9477             : 
    9478             :  explain_option_arg:
    9479             :  opt_boolean_or_string
    9480             :  { 
    9481           0 :  $$ = $1;
    9482             : }
    9483             : |  NumericOnly
    9484             :  { 
    9485           0 :  $$ = $1;
    9486             : }
    9487             : | 
    9488             :  { 
    9489           0 :  $$=EMPTY; }
    9490             : ;
    9491             : 
    9492             : 
    9493             :  PrepareStmt:
    9494             : PREPARE prepared_name prep_type_clause AS PreparableStmt
    9495             :     {
    9496          12 :         $$.name = $2;
    9497          12 :         $$.type = $3;
    9498          12 :         $$.stmt = $5;
    9499             :     }
    9500             :     | PREPARE prepared_name FROM execstring
    9501             :     {
    9502          82 :         $$.name = $2;
    9503          82 :         $$.type = NULL;
    9504          82 :         $$.stmt = $4;
    9505             :     }
    9506             : ;
    9507             : 
    9508             : 
    9509             :  prep_type_clause:
    9510             :  '(' type_list ')'
    9511             :  { 
    9512          10 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    9513             : }
    9514             : | 
    9515             :  { 
    9516           2 :  $$=EMPTY; }
    9517             : ;
    9518             : 
    9519             : 
    9520             :  PreparableStmt:
    9521             :  SelectStmt
    9522             :  { 
    9523           0 :  $$ = $1;
    9524             : }
    9525             : |  InsertStmt
    9526             :  { 
    9527          12 :  $$ = $1;
    9528             : }
    9529             : |  UpdateStmt
    9530             :  { 
    9531           0 :  $$ = $1;
    9532             : }
    9533             : |  DeleteStmt
    9534             :  { 
    9535           0 :  $$ = $1;
    9536             : }
    9537             : ;
    9538             : 
    9539             : 
    9540             :  ExecuteStmt:
    9541             : EXECUTE prepared_name execute_param_clause execute_rest
    9542             :     {
    9543          64 :         $$.name = $2;
    9544          64 :         $$.type = $3;
    9545             :     }
    9546             : | CREATE OptTemp TABLE create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
    9547             :     {
    9548           0 :         $$.name = cat_str(8,mm_strdup("create"),$2,mm_strdup("table"),$4,mm_strdup("as execute"),$7,$8,$9);
    9549             :     }
    9550             : | CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
    9551             :     {
    9552           0 :         $$.name = cat_str(8,mm_strdup("create"),$2,mm_strdup("table if not exists"),$7,mm_strdup("as execute"),$10,$11,$12);
    9553             :     }
    9554             : ;
    9555             : 
    9556             : 
    9557             :  execute_param_clause:
    9558             :  '(' expr_list ')'
    9559             :  { 
    9560          18 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    9561             : }
    9562             : | 
    9563             :  { 
    9564          46 :  $$=EMPTY; }
    9565             : ;
    9566             : 
    9567             : 
    9568             :  InsertStmt:
    9569             :  opt_with_clause INSERT INTO insert_target insert_rest opt_on_conflict returning_clause
    9570             :  { 
    9571         228 :  $$ = cat_str(6,$1,mm_strdup("insert into"),$4,$5,$6,$7);
    9572             : }
    9573             : ;
    9574             : 
    9575             : 
    9576             :  insert_target:
    9577             :  qualified_name
    9578             :  { 
    9579         228 :  $$ = $1;
    9580             : }
    9581             : |  qualified_name AS ColId
    9582             :  { 
    9583           0 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
    9584             : }
    9585             : ;
    9586             : 
    9587             : 
    9588             :  insert_rest:
    9589             :  SelectStmt
    9590             :  { 
    9591         124 :  $$ = $1;
    9592             : }
    9593             : |  OVERRIDING override_kind VALUE_P SelectStmt
    9594             :  { 
    9595           0 :  $$ = cat_str(4,mm_strdup("overriding"),$2,mm_strdup("value"),$4);
    9596             : }
    9597             : |  '(' insert_column_list ')' SelectStmt
    9598             :  { 
    9599         104 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(")"),$4);
    9600             : }
    9601             : |  '(' insert_column_list ')' OVERRIDING override_kind VALUE_P SelectStmt
    9602             :  { 
    9603           0 :  $$ = cat_str(6,mm_strdup("("),$2,mm_strdup(") overriding"),$5,mm_strdup("value"),$7);
    9604             : }
    9605             : |  DEFAULT VALUES
    9606             :  { 
    9607           0 :  $$ = mm_strdup("default values");
    9608             : }
    9609             : ;
    9610             : 
    9611             : 
    9612             :  override_kind:
    9613             :  USER
    9614             :  { 
    9615           0 :  $$ = mm_strdup("user");
    9616             : }
    9617             : |  SYSTEM_P
    9618             :  { 
    9619           0 :  $$ = mm_strdup("system");
    9620             : }
    9621             : ;
    9622             : 
    9623             : 
    9624             :  insert_column_list:
    9625             :  insert_column_item
    9626             :  { 
    9627         104 :  $$ = $1;
    9628             : }
    9629             : |  insert_column_list ',' insert_column_item
    9630             :  { 
    9631         242 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9632             : }
    9633             : ;
    9634             : 
    9635             : 
    9636             :  insert_column_item:
    9637             :  ColId opt_indirection
    9638             :  { 
    9639         346 :  $$ = cat_str(2,$1,$2);
    9640             : }
    9641             : ;
    9642             : 
    9643             : 
    9644             :  opt_on_conflict:
    9645             :  ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list where_clause
    9646             :  { 
    9647           0 :  $$ = cat_str(5,mm_strdup("on conflict"),$3,mm_strdup("do update set"),$7,$8);
    9648             : }
    9649             : |  ON CONFLICT opt_conf_expr DO NOTHING
    9650             :  { 
    9651           0 :  $$ = cat_str(3,mm_strdup("on conflict"),$3,mm_strdup("do nothing"));
    9652             : }
    9653             : | 
    9654             :  { 
    9655         228 :  $$=EMPTY; }
    9656             : ;
    9657             : 
    9658             : 
    9659             :  opt_conf_expr:
    9660             :  '(' index_params ')' where_clause
    9661             :  { 
    9662           0 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(")"),$4);
    9663             : }
    9664             : |  ON CONSTRAINT name
    9665             :  { 
    9666           0 :  $$ = cat_str(2,mm_strdup("on constraint"),$3);
    9667             : }
    9668             : | 
    9669             :  { 
    9670           0 :  $$=EMPTY; }
    9671             : ;
    9672             : 
    9673             : 
    9674             :  returning_clause:
    9675             : RETURNING target_list opt_ecpg_into
    9676             :  { 
    9677           4 :  $$ = cat_str(2,mm_strdup("returning"),$2);
    9678             : }
    9679             : | 
    9680             :  { 
    9681         238 :  $$=EMPTY; }
    9682             : ;
    9683             : 
    9684             : 
    9685             :  DeleteStmt:
    9686             :  opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause
    9687             :  { 
    9688           4 :  $$ = cat_str(6,$1,mm_strdup("delete from"),$4,$5,$6,$7);
    9689             : }
    9690             : ;
    9691             : 
    9692             : 
    9693             :  using_clause:
    9694             :  USING from_list
    9695             :  { 
    9696           0 :  $$ = cat_str(2,mm_strdup("using"),$2);
    9697             : }
    9698             : | 
    9699             :  { 
    9700           4 :  $$=EMPTY; }
    9701             : ;
    9702             : 
    9703             : 
    9704             :  LockStmt:
    9705             :  LOCK_P opt_table relation_expr_list opt_lock opt_nowait
    9706             :  { 
    9707           0 :  $$ = cat_str(5,mm_strdup("lock"),$2,$3,$4,$5);
    9708             : }
    9709             : ;
    9710             : 
    9711             : 
    9712             :  opt_lock:
    9713             :  IN_P lock_type MODE
    9714             :  { 
    9715           0 :  $$ = cat_str(3,mm_strdup("in"),$2,mm_strdup("mode"));
    9716             : }
    9717             : | 
    9718             :  { 
    9719           0 :  $$=EMPTY; }
    9720             : ;
    9721             : 
    9722             : 
    9723             :  lock_type:
    9724             :  ACCESS SHARE
    9725             :  { 
    9726           0 :  $$ = mm_strdup("access share");
    9727             : }
    9728             : |  ROW SHARE
    9729             :  { 
    9730           0 :  $$ = mm_strdup("row share");
    9731             : }
    9732             : |  ROW EXCLUSIVE
    9733             :  { 
    9734           0 :  $$ = mm_strdup("row exclusive");
    9735             : }
    9736             : |  SHARE UPDATE EXCLUSIVE
    9737             :  { 
    9738           0 :  $$ = mm_strdup("share update exclusive");
    9739             : }
    9740             : |  SHARE
    9741             :  { 
    9742           0 :  $$ = mm_strdup("share");
    9743             : }
    9744             : |  SHARE ROW EXCLUSIVE
    9745             :  { 
    9746           0 :  $$ = mm_strdup("share row exclusive");
    9747             : }
    9748             : |  EXCLUSIVE
    9749             :  { 
    9750           0 :  $$ = mm_strdup("exclusive");
    9751             : }
    9752             : |  ACCESS EXCLUSIVE
    9753             :  { 
    9754           0 :  $$ = mm_strdup("access exclusive");
    9755             : }
    9756             : ;
    9757             : 
    9758             : 
    9759             :  opt_nowait:
    9760             :  NOWAIT
    9761             :  { 
    9762           0 :  $$ = mm_strdup("nowait");
    9763             : }
    9764             : | 
    9765             :  { 
    9766           0 :  $$=EMPTY; }
    9767             : ;
    9768             : 
    9769             : 
    9770             :  opt_nowait_or_skip:
    9771             :  NOWAIT
    9772             :  { 
    9773           0 :  $$ = mm_strdup("nowait");
    9774             : }
    9775             : |  SKIP LOCKED
    9776             :  { 
    9777           0 :  $$ = mm_strdup("skip locked");
    9778             : }
    9779             : | 
    9780             :  { 
    9781           0 :  $$=EMPTY; }
    9782             : ;
    9783             : 
    9784             : 
    9785             :  UpdateStmt:
    9786             :  opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list from_clause where_or_current_clause returning_clause
    9787             :  { 
    9788          10 :  $$ = cat_str(8,$1,mm_strdup("update"),$3,mm_strdup("set"),$5,$6,$7,$8);
    9789             : }
    9790             : ;
    9791             : 
    9792             : 
    9793             :  set_clause_list:
    9794             :  set_clause
    9795             :  { 
    9796          10 :  $$ = $1;
    9797             : }
    9798             : |  set_clause_list ',' set_clause
    9799             :  { 
    9800           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9801             : }
    9802             : ;
    9803             : 
    9804             : 
    9805             :  set_clause:
    9806             :  set_target '=' a_expr
    9807             :  { 
    9808           8 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
    9809             : }
    9810             : |  '(' set_target_list ')' '=' a_expr
    9811             :  { 
    9812           2 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(") ="),$5);
    9813             : }
    9814             : ;
    9815             : 
    9816             : 
    9817             :  set_target:
    9818             :  ColId opt_indirection
    9819             :  { 
    9820          12 :  $$ = cat_str(2,$1,$2);
    9821             : }
    9822             : ;
    9823             : 
    9824             : 
    9825             :  set_target_list:
    9826             :  set_target
    9827             :  { 
    9828           2 :  $$ = $1;
    9829             : }
    9830             : |  set_target_list ',' set_target
    9831             :  { 
    9832           2 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
    9833             : }
    9834             : ;
    9835             : 
    9836             : 
    9837             :  DeclareCursorStmt:
    9838             :  DECLARE cursor_name cursor_options CURSOR opt_hold FOR SelectStmt
    9839             :     {
    9840             :         struct cursor *ptr, *this;
    9841          34 :         char *cursor_marker = $2[0] == ':' ? mm_strdup("$0") : mm_strdup($2);
    9842             :         char *comment, *c1, *c2;
    9843          34 :         int (* strcmp_fn)(const char *, const char *) = (($2[0] == ':' || $2[0] == '"') ? strcmp : pg_strcasecmp);
    9844             : 
    9845          46 :         for (ptr = cur; ptr != NULL; ptr = ptr->next)
    9846             :         {
    9847          12 :             if (strcmp_fn($2, ptr->name) == 0)
    9848             :             {
    9849           0 :                 if ($2[0] == ':')
    9850           0 :                     mmerror(PARSE_ERROR, ET_ERROR, "using variable \"%s\" in different declare statements is not supported", $2+1);
    9851             :                 else
    9852           0 :                     mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", $2);
    9853             :             }
    9854             :         }
    9855             : 
    9856          34 :         this = (struct cursor *) mm_alloc(sizeof(struct cursor));
    9857             : 
    9858          34 :         this->next = cur;
    9859          34 :         this->name = $2;
    9860          34 :         this->function = (current_function ? mm_strdup(current_function) : NULL);
    9861          34 :         this->connection = connection;
    9862          34 :         this->opened = false;
    9863          34 :         this->command =  cat_str(7, mm_strdup("declare"), cursor_marker, $3, mm_strdup("cursor"), $5, mm_strdup("for"), $7);
    9864          34 :         this->argsinsert = argsinsert;
    9865          34 :         this->argsinsert_oos = NULL;
    9866          34 :         this->argsresult = argsresult;
    9867          34 :         this->argsresult_oos = NULL;
    9868          34 :         argsinsert = argsresult = NULL;
    9869          34 :         cur = this;
    9870             : 
    9871          34 :         c1 = mm_strdup(this->command);
    9872          34 :         if ((c2 = strstr(c1, "*/")) != NULL)
    9873             :         {
    9874             :             /* We put this text into a comment, so we better remove [*][/]. */
    9875           0 :             c2[0] = '.';
    9876           0 :             c2[1] = '.';
    9877             :         }
    9878          34 :         comment = cat_str(3, mm_strdup("/*"), c1, mm_strdup("*/"));
    9879             : 
    9880          34 :         $$ = cat2_str(adjust_outofscope_cursor_vars(this), comment);
    9881             :     }
    9882             : ;
    9883             : 
    9884             : 
    9885             :  cursor_name:
    9886             :  name
    9887             :  { 
    9888         228 :  $$ = $1;
    9889             : }
    9890             :     | char_civar
    9891             :         {
    9892          86 :             char *curname = mm_alloc(strlen($1) + 2);
    9893          86 :             sprintf(curname, ":%s", $1);
    9894          86 :             free($1);
    9895          86 :             $1 = curname;
    9896          86 :             $$ = $1;
    9897             :         }
    9898             : ;
    9899             : 
    9900             : 
    9901             :  cursor_options:
    9902             : 
    9903             :  { 
    9904          64 :  $$=EMPTY; }
    9905             : |  cursor_options NO SCROLL
    9906             :  { 
    9907           0 :  $$ = cat_str(2,$1,mm_strdup("no scroll"));
    9908             : }
    9909             : |  cursor_options SCROLL
    9910             :  { 
    9911           0 :  $$ = cat_str(2,$1,mm_strdup("scroll"));
    9912             : }
    9913             : |  cursor_options BINARY
    9914             :  { 
    9915           4 :  $$ = cat_str(2,$1,mm_strdup("binary"));
    9916             : }
    9917             : |  cursor_options INSENSITIVE
    9918             :  { 
    9919           0 :  $$ = cat_str(2,$1,mm_strdup("insensitive"));
    9920             : }
    9921             : ;
    9922             : 
    9923             : 
    9924             :  opt_hold:
    9925             : 
    9926             :     {
    9927          64 :         if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit)
    9928           0 :             $$ = mm_strdup("with hold");
    9929             :         else
    9930          64 :             $$ = EMPTY;
    9931             :     }
    9932             : |  WITH HOLD
    9933             :  { 
    9934           0 :  $$ = mm_strdup("with hold");
    9935             : }
    9936             : |  WITHOUT HOLD
    9937             :  { 
    9938           0 :  $$ = mm_strdup("without hold");
    9939             : }
    9940             : ;
    9941             : 
    9942             : 
    9943             :  SelectStmt:
    9944             :  select_no_parens %prec UMINUS
    9945             :  { 
    9946         400 :  $$ = $1;
    9947             : }
    9948             : |  select_with_parens %prec UMINUS
    9949             :  { 
    9950           2 :  $$ = $1;
    9951             : }
    9952             : ;
    9953             : 
    9954             : 
    9955             :  select_with_parens:
    9956             :  '(' select_no_parens ')'
    9957             :  { 
    9958           6 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    9959             : }
    9960             : |  '(' select_with_parens ')'
    9961             :  { 
    9962           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
    9963             : }
    9964             : ;
    9965             : 
    9966             : 
    9967             :  select_no_parens:
    9968             :  simple_select
    9969             :  { 
    9970         370 :  $$ = $1;
    9971             : }
    9972             : |  select_clause sort_clause
    9973             :  { 
    9974          10 :  $$ = cat_str(2,$1,$2);
    9975             : }
    9976             : |  select_clause opt_sort_clause for_locking_clause opt_select_limit
    9977             :  { 
    9978           0 :  $$ = cat_str(4,$1,$2,$3,$4);
    9979             : }
    9980             : |  select_clause opt_sort_clause select_limit opt_for_locking_clause
    9981             :  { 
    9982          26 :  $$ = cat_str(4,$1,$2,$3,$4);
    9983             : }
    9984             : |  with_clause select_clause
    9985             :  { 
    9986           0 :  $$ = cat_str(2,$1,$2);
    9987             : }
    9988             : |  with_clause select_clause sort_clause
    9989             :  { 
    9990           0 :  $$ = cat_str(3,$1,$2,$3);
    9991             : }
    9992             : |  with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit
    9993             :  { 
    9994           0 :  $$ = cat_str(5,$1,$2,$3,$4,$5);
    9995             : }
    9996             : |  with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause
    9997             :  { 
    9998           0 :  $$ = cat_str(5,$1,$2,$3,$4,$5);
    9999             : }
   10000             : ;
   10001             : 
   10002             : 
   10003             :  select_clause:
   10004             :  simple_select
   10005             :  { 
   10006          36 :  $$ = $1;
   10007             : }
   10008             : |  select_with_parens
   10009             :  { 
   10010           0 :  $$ = $1;
   10011             : }
   10012             : ;
   10013             : 
   10014             : 
   10015             :  simple_select:
   10016             :  SELECT opt_all_clause opt_target_list into_clause from_clause where_clause group_clause having_clause window_clause
   10017             :  { 
   10018         182 :  $$ = cat_str(9,mm_strdup("select"),$2,$3,$4,$5,$6,$7,$8,$9);
   10019             : }
   10020             : |  SELECT distinct_clause target_list into_clause from_clause where_clause group_clause having_clause window_clause
   10021             :  { 
   10022           0 :  $$ = cat_str(9,mm_strdup("select"),$2,$3,$4,$5,$6,$7,$8,$9);
   10023             : }
   10024             : |  values_clause
   10025             :  { 
   10026         224 :  $$ = $1;
   10027             : }
   10028             : |  TABLE relation_expr
   10029             :  { 
   10030           0 :  $$ = cat_str(2,mm_strdup("table"),$2);
   10031             : }
   10032             : |  select_clause UNION all_or_distinct select_clause
   10033             :  { 
   10034           0 :  $$ = cat_str(4,$1,mm_strdup("union"),$3,$4);
   10035             : }
   10036             : |  select_clause INTERSECT all_or_distinct select_clause
   10037             :  { 
   10038           0 :  $$ = cat_str(4,$1,mm_strdup("intersect"),$3,$4);
   10039             : }
   10040             : |  select_clause EXCEPT all_or_distinct select_clause
   10041             :  { 
   10042           0 :  $$ = cat_str(4,$1,mm_strdup("except"),$3,$4);
   10043             : }
   10044             : ;
   10045             : 
   10046             : 
   10047             :  with_clause:
   10048             :  WITH cte_list
   10049             :  { 
   10050           0 :  $$ = cat_str(2,mm_strdup("with"),$2);
   10051             : }
   10052             : |  WITH_LA cte_list
   10053             :  { 
   10054           0 :  $$ = cat_str(2,mm_strdup("with"),$2);
   10055             : }
   10056             : |  WITH RECURSIVE cte_list
   10057             :  { 
   10058           0 :  $$ = cat_str(2,mm_strdup("with recursive"),$3);
   10059             : }
   10060             : ;
   10061             : 
   10062             : 
   10063             :  cte_list:
   10064             :  common_table_expr
   10065             :  { 
   10066           0 :  $$ = $1;
   10067             : }
   10068             : |  cte_list ',' common_table_expr
   10069             :  { 
   10070           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10071             : }
   10072             : ;
   10073             : 
   10074             : 
   10075             :  common_table_expr:
   10076             :  name opt_name_list AS opt_materialized '(' PreparableStmt ')'
   10077             :  { 
   10078           0 :  $$ = cat_str(7,$1,$2,mm_strdup("as"),$4,mm_strdup("("),$6,mm_strdup(")"));
   10079             : }
   10080             : ;
   10081             : 
   10082             : 
   10083             :  opt_materialized:
   10084             :  MATERIALIZED
   10085             :  { 
   10086           0 :  $$ = mm_strdup("materialized");
   10087             : }
   10088             : |  NOT MATERIALIZED
   10089             :  { 
   10090           0 :  $$ = mm_strdup("not materialized");
   10091             : }
   10092             : | 
   10093             :  { 
   10094           0 :  $$=EMPTY; }
   10095             : ;
   10096             : 
   10097             : 
   10098             :  opt_with_clause:
   10099             :  with_clause
   10100             :  { 
   10101           0 :  $$ = $1;
   10102             : }
   10103             : | 
   10104             :  { 
   10105         242 :  $$=EMPTY; }
   10106             : ;
   10107             : 
   10108             : 
   10109             :  into_clause:
   10110             :  INTO OptTempTableName
   10111             :                     {
   10112           0 :                         FoundInto = 1;
   10113           0 :                         $$= cat2_str(mm_strdup("into"), $2);
   10114             :                     }
   10115         120 :     | ecpg_into { $$ = EMPTY; }
   10116             : | 
   10117             :  { 
   10118          62 :  $$=EMPTY; }
   10119             : ;
   10120             : 
   10121             : 
   10122             :  OptTempTableName:
   10123             :  TEMPORARY opt_table qualified_name
   10124             :  { 
   10125           0 :  $$ = cat_str(3,mm_strdup("temporary"),$2,$3);
   10126             : }
   10127             : |  TEMP opt_table qualified_name
   10128             :  { 
   10129           0 :  $$ = cat_str(3,mm_strdup("temp"),$2,$3);
   10130             : }
   10131             : |  LOCAL TEMPORARY opt_table qualified_name
   10132             :  { 
   10133           0 :  $$ = cat_str(3,mm_strdup("local temporary"),$3,$4);
   10134             : }
   10135             : |  LOCAL TEMP opt_table qualified_name
   10136             :  { 
   10137           0 :  $$ = cat_str(3,mm_strdup("local temp"),$3,$4);
   10138             : }
   10139             : |  GLOBAL TEMPORARY opt_table qualified_name
   10140             :  { 
   10141           0 :  $$ = cat_str(3,mm_strdup("global temporary"),$3,$4);
   10142             : }
   10143             : |  GLOBAL TEMP opt_table qualified_name
   10144             :  { 
   10145           0 :  $$ = cat_str(3,mm_strdup("global temp"),$3,$4);
   10146             : }
   10147             : |  UNLOGGED opt_table qualified_name
   10148             :  { 
   10149           0 :  $$ = cat_str(3,mm_strdup("unlogged"),$2,$3);
   10150             : }
   10151             : |  TABLE qualified_name
   10152             :  { 
   10153           0 :  $$ = cat_str(2,mm_strdup("table"),$2);
   10154             : }
   10155             : |  qualified_name
   10156             :  { 
   10157           0 :  $$ = $1;
   10158             : }
   10159             : ;
   10160             : 
   10161             : 
   10162             :  opt_table:
   10163             :  TABLE
   10164             :  { 
   10165           0 :  $$ = mm_strdup("table");
   10166             : }
   10167             : | 
   10168             :  { 
   10169          44 :  $$=EMPTY; }
   10170             : ;
   10171             : 
   10172             : 
   10173             :  all_or_distinct:
   10174             :  ALL
   10175             :  { 
   10176           0 :  $$ = mm_strdup("all");
   10177             : }
   10178             : |  DISTINCT
   10179             :  { 
   10180           0 :  $$ = mm_strdup("distinct");
   10181             : }
   10182             : | 
   10183             :  { 
   10184           0 :  $$=EMPTY; }
   10185             : ;
   10186             : 
   10187             : 
   10188             :  distinct_clause:
   10189             :  DISTINCT
   10190             :  { 
   10191           0 :  $$ = mm_strdup("distinct");
   10192             : }
   10193             : |  DISTINCT ON '(' expr_list ')'
   10194             :  { 
   10195           0 :  $$ = cat_str(3,mm_strdup("distinct on ("),$4,mm_strdup(")"));
   10196             : }
   10197             : ;
   10198             : 
   10199             : 
   10200             :  opt_all_clause:
   10201             :  ALL
   10202             :  { 
   10203           0 :  $$ = mm_strdup("all");
   10204             : }
   10205             : | 
   10206             :  { 
   10207         182 :  $$=EMPTY; }
   10208             : ;
   10209             : 
   10210             : 
   10211             :  opt_sort_clause:
   10212             :  sort_clause
   10213             :  { 
   10214           2 :  $$ = $1;
   10215             : }
   10216             : | 
   10217             :  { 
   10218          30 :  $$=EMPTY; }
   10219             : ;
   10220             : 
   10221             : 
   10222             :  sort_clause:
   10223             :  ORDER BY sortby_list
   10224             :  { 
   10225          12 :  $$ = cat_str(2,mm_strdup("order by"),$3);
   10226             : }
   10227             : ;
   10228             : 
   10229             : 
   10230             :  sortby_list:
   10231             :  sortby
   10232             :  { 
   10233          12 :  $$ = $1;
   10234             : }
   10235             : |  sortby_list ',' sortby
   10236             :  { 
   10237           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10238             : }
   10239             : ;
   10240             : 
   10241             : 
   10242             :  sortby:
   10243             :  a_expr USING qual_all_Op opt_nulls_order
   10244             :  { 
   10245           0 :  $$ = cat_str(4,$1,mm_strdup("using"),$3,$4);
   10246             : }
   10247             : |  a_expr opt_asc_desc opt_nulls_order
   10248             :  { 
   10249          12 :  $$ = cat_str(3,$1,$2,$3);
   10250             : }
   10251             : ;
   10252             : 
   10253             : 
   10254             :  select_limit:
   10255             :  limit_clause offset_clause
   10256             :  { 
   10257           0 :  $$ = cat_str(2,$1,$2);
   10258             : }
   10259             : |  offset_clause limit_clause
   10260             :  { 
   10261           0 :  $$ = cat_str(2,$1,$2);
   10262             : }
   10263             : |  limit_clause
   10264             :  { 
   10265          26 :  $$ = $1;
   10266             : }
   10267             : |  offset_clause
   10268             :  { 
   10269           0 :  $$ = $1;
   10270             : }
   10271             : ;
   10272             : 
   10273             : 
   10274             :  opt_select_limit:
   10275             :  select_limit
   10276             :  { 
   10277           0 :  $$ = $1;
   10278             : }
   10279             : | 
   10280             :  { 
   10281           0 :  $$=EMPTY; }
   10282             : ;
   10283             : 
   10284             : 
   10285             :  limit_clause:
   10286             :  LIMIT select_limit_value
   10287             :  { 
   10288          26 :  $$ = cat_str(2,mm_strdup("limit"),$2);
   10289             : }
   10290             : |  LIMIT select_limit_value ',' select_offset_value
   10291             :     {
   10292           0 :         mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server");
   10293           0 :         $$ = cat_str(4, mm_strdup("limit"), $2, mm_strdup(","), $4);
   10294             :     }
   10295             : |  FETCH first_or_next select_fetch_first_value row_or_rows ONLY
   10296             :  { 
   10297           0 :  $$ = cat_str(5,mm_strdup("fetch"),$2,$3,$4,mm_strdup("only"));
   10298             : }
   10299             : |  FETCH first_or_next select_fetch_first_value row_or_rows WITH TIES
   10300             :  { 
   10301           0 :  $$ = cat_str(5,mm_strdup("fetch"),$2,$3,$4,mm_strdup("with ties"));
   10302             : }
   10303             : |  FETCH first_or_next row_or_rows ONLY
   10304             :  { 
   10305           0 :  $$ = cat_str(4,mm_strdup("fetch"),$2,$3,mm_strdup("only"));
   10306             : }
   10307             : |  FETCH first_or_next row_or_rows WITH TIES
   10308             :  { 
   10309           0 :  $$ = cat_str(4,mm_strdup("fetch"),$2,$3,mm_strdup("with ties"));
   10310             : }
   10311             : ;
   10312             : 
   10313             : 
   10314             :  offset_clause:
   10315             :  OFFSET select_offset_value
   10316             :  { 
   10317           0 :  $$ = cat_str(2,mm_strdup("offset"),$2);
   10318             : }
   10319             : |  OFFSET select_fetch_first_value row_or_rows
   10320             :  { 
   10321           0 :  $$ = cat_str(3,mm_strdup("offset"),$2,$3);
   10322             : }
   10323             : ;
   10324             : 
   10325             : 
   10326             :  select_limit_value:
   10327             :  a_expr
   10328             :  { 
   10329          26 :  $$ = $1;
   10330             : }
   10331             : |  ALL
   10332             :  { 
   10333           0 :  $$ = mm_strdup("all");
   10334             : }
   10335             : ;
   10336             : 
   10337             : 
   10338             :  select_offset_value:
   10339             :  a_expr
   10340             :  { 
   10341           0 :  $$ = $1;
   10342             : }
   10343             : ;
   10344             : 
   10345             : 
   10346             :  select_fetch_first_value:
   10347             :  c_expr
   10348             :  { 
   10349           0 :  $$ = $1;
   10350             : }
   10351             : |  '+' I_or_F_const
   10352             :  { 
   10353           0 :  $$ = cat_str(2,mm_strdup("+"),$2);
   10354             : }
   10355             : |  '-' I_or_F_const
   10356             :  { 
   10357           0 :  $$ = cat_str(2,mm_strdup("-"),$2);
   10358             : }
   10359             : ;
   10360             : 
   10361             : 
   10362             :  I_or_F_const:
   10363             :  Iconst
   10364             :  { 
   10365           0 :  $$ = $1;
   10366             : }
   10367             : |  ecpg_fconst
   10368             :  { 
   10369           0 :  $$ = $1;
   10370             : }
   10371             : ;
   10372             : 
   10373             : 
   10374             :  row_or_rows:
   10375             :  ROW
   10376             :  { 
   10377           0 :  $$ = mm_strdup("row");
   10378             : }
   10379             : |  ROWS
   10380             :  { 
   10381           0 :  $$ = mm_strdup("rows");
   10382             : }
   10383             : ;
   10384             : 
   10385             : 
   10386             :  first_or_next:
   10387             :  FIRST_P
   10388             :  { 
   10389           0 :  $$ = mm_strdup("first");
   10390             : }
   10391             : |  NEXT
   10392             :  { 
   10393           0 :  $$ = mm_strdup("next");
   10394             : }
   10395             : ;
   10396             : 
   10397             : 
   10398             :  group_clause:
   10399             :  GROUP_P BY group_by_list
   10400             :  { 
   10401           0 :  $$ = cat_str(2,mm_strdup("group by"),$3);
   10402             : }
   10403             : | 
   10404             :  { 
   10405         182 :  $$=EMPTY; }
   10406             : ;
   10407             : 
   10408             : 
   10409             :  group_by_list:
   10410             :  group_by_item
   10411             :  { 
   10412           0 :  $$ = $1;
   10413             : }
   10414             : |  group_by_list ',' group_by_item
   10415             :  { 
   10416           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10417             : }
   10418             : ;
   10419             : 
   10420             : 
   10421             :  group_by_item:
   10422             :  a_expr
   10423             :  { 
   10424           0 :  $$ = $1;
   10425             : }
   10426             : |  empty_grouping_set
   10427             :  { 
   10428           0 :  $$ = $1;
   10429             : }
   10430             : |  cube_clause
   10431             :  { 
   10432           0 :  $$ = $1;
   10433             : }
   10434             : |  rollup_clause
   10435             :  { 
   10436           0 :  $$ = $1;
   10437             : }
   10438             : |  grouping_sets_clause
   10439             :  { 
   10440           0 :  $$ = $1;
   10441             : }
   10442             : ;
   10443             : 
   10444             : 
   10445             :  empty_grouping_set:
   10446             :  '(' ')'
   10447             :  { 
   10448           0 :  $$ = mm_strdup("( )");
   10449             : }
   10450             : ;
   10451             : 
   10452             : 
   10453             :  rollup_clause:
   10454             :  ROLLUP '(' expr_list ')'
   10455             :  { 
   10456           0 :  $$ = cat_str(3,mm_strdup("rollup ("),$3,mm_strdup(")"));
   10457             : }
   10458             : ;
   10459             : 
   10460             : 
   10461             :  cube_clause:
   10462             :  CUBE '(' expr_list ')'
   10463             :  { 
   10464           0 :  $$ = cat_str(3,mm_strdup("cube ("),$3,mm_strdup(")"));
   10465             : }
   10466             : ;
   10467             : 
   10468             : 
   10469             :  grouping_sets_clause:
   10470             :  GROUPING SETS '(' group_by_list ')'
   10471             :  { 
   10472           0 :  $$ = cat_str(3,mm_strdup("grouping sets ("),$4,mm_strdup(")"));
   10473             : }
   10474             : ;
   10475             : 
   10476             : 
   10477             :  having_clause:
   10478             :  HAVING a_expr
   10479             :  { 
   10480           0 :  $$ = cat_str(2,mm_strdup("having"),$2);
   10481             : }
   10482             : | 
   10483             :  { 
   10484         182 :  $$=EMPTY; }
   10485             : ;
   10486             : 
   10487             : 
   10488             :  for_locking_clause:
   10489             :  for_locking_items
   10490             :  { 
   10491           0 :  $$ = $1;
   10492             : }
   10493             : |  FOR READ ONLY
   10494             :  { 
   10495           0 :  $$ = mm_strdup("for read only");
   10496             : }
   10497             : ;
   10498             : 
   10499             : 
   10500             :  opt_for_locking_clause:
   10501             :  for_locking_clause
   10502             :  { 
   10503           0 :  $$ = $1;
   10504             : }
   10505             : | 
   10506             :  { 
   10507          26 :  $$=EMPTY; }
   10508             : ;
   10509             : 
   10510             : 
   10511             :  for_locking_items:
   10512             :  for_locking_item
   10513             :  { 
   10514           0 :  $$ = $1;
   10515             : }
   10516             : |  for_locking_items for_locking_item
   10517             :  { 
   10518           0 :  $$ = cat_str(2,$1,$2);
   10519             : }
   10520             : ;
   10521             : 
   10522             : 
   10523             :  for_locking_item:
   10524             :  for_locking_strength locked_rels_list opt_nowait_or_skip
   10525             :  { 
   10526           0 :  $$ = cat_str(3,$1,$2,$3);
   10527             : }
   10528             : ;
   10529             : 
   10530             : 
   10531             :  for_locking_strength:
   10532             :  FOR UPDATE
   10533             :  { 
   10534           0 :  $$ = mm_strdup("for update");
   10535             : }
   10536             : |  FOR NO KEY UPDATE
   10537             :  { 
   10538           0 :  $$ = mm_strdup("for no key update");
   10539             : }
   10540             : |  FOR SHARE
   10541             :  { 
   10542           0 :  $$ = mm_strdup("for share");
   10543             : }
   10544             : |  FOR KEY SHARE
   10545             :  { 
   10546           0 :  $$ = mm_strdup("for key share");
   10547             : }
   10548             : ;
   10549             : 
   10550             : 
   10551             :  locked_rels_list:
   10552             :  OF qualified_name_list
   10553             :  { 
   10554           0 :  $$ = cat_str(2,mm_strdup("of"),$2);
   10555             : }
   10556             : | 
   10557             :  { 
   10558           0 :  $$=EMPTY; }
   10559             : ;
   10560             : 
   10561             : 
   10562             :  values_clause:
   10563             :  VALUES '(' expr_list ')'
   10564             :  { 
   10565         224 :  $$ = cat_str(3,mm_strdup("values ("),$3,mm_strdup(")"));
   10566             : }
   10567             : |  values_clause ',' '(' expr_list ')'
   10568             :  { 
   10569          16 :  $$ = cat_str(4,$1,mm_strdup(", ("),$4,mm_strdup(")"));
   10570             : }
   10571             : ;
   10572             : 
   10573             : 
   10574             :  from_clause:
   10575             :  FROM from_list
   10576             :  { 
   10577         148 :  $$ = cat_str(2,mm_strdup("from"),$2);
   10578             : }
   10579             : | 
   10580             :  { 
   10581          44 :  $$=EMPTY; }
   10582             : ;
   10583             : 
   10584             : 
   10585             :  from_list:
   10586             :  table_ref
   10587             :  { 
   10588         148 :  $$ = $1;
   10589             : }
   10590             : |  from_list ',' table_ref
   10591             :  { 
   10592           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10593             : }
   10594             : ;
   10595             : 
   10596             : 
   10597             :  table_ref:
   10598             :  relation_expr opt_alias_clause
   10599             :  { 
   10600         146 :  $$ = cat_str(2,$1,$2);
   10601             : }
   10602             : |  relation_expr opt_alias_clause tablesample_clause
   10603             :  { 
   10604           0 :  $$ = cat_str(3,$1,$2,$3);
   10605             : }
   10606             : |  func_table func_alias_clause
   10607             :  { 
   10608           2 :  $$ = cat_str(2,$1,$2);
   10609             : }
   10610             : |  LATERAL_P func_table func_alias_clause
   10611             :  { 
   10612           0 :  $$ = cat_str(3,mm_strdup("lateral"),$2,$3);
   10613             : }
   10614             : |  xmltable opt_alias_clause
   10615             :  { 
   10616           0 :  $$ = cat_str(2,$1,$2);
   10617             : }
   10618             : |  LATERAL_P xmltable opt_alias_clause
   10619             :  { 
   10620           0 :  $$ = cat_str(3,mm_strdup("lateral"),$2,$3);
   10621             : }
   10622             : |  select_with_parens opt_alias_clause
   10623             :  { 
   10624           0 :     if ($2 == NULL)
   10625           0 :         mmerror(PARSE_ERROR, ET_ERROR, "subquery in FROM must have an alias");
   10626             : 
   10627           0 :  $$ = cat_str(2,$1,$2);
   10628             : }
   10629             : |  LATERAL_P select_with_parens opt_alias_clause
   10630             :  { 
   10631           0 :     if ($3 == NULL)
   10632           0 :         mmerror(PARSE_ERROR, ET_ERROR, "subquery in FROM must have an alias");
   10633             : 
   10634           0 :  $$ = cat_str(3,mm_strdup("lateral"),$2,$3);
   10635             : }
   10636             : |  joined_table
   10637             :  { 
   10638           0 :  $$ = $1;
   10639             : }
   10640             : |  '(' joined_table ')' alias_clause
   10641             :  { 
   10642           0 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(")"),$4);
   10643             : }
   10644             : ;
   10645             : 
   10646             : 
   10647             :  joined_table:
   10648             :  '(' joined_table ')'
   10649             :  { 
   10650           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
   10651             : }
   10652             : |  table_ref CROSS JOIN table_ref
   10653             :  { 
   10654           0 :  $$ = cat_str(3,$1,mm_strdup("cross join"),$4);
   10655             : }
   10656             : |  table_ref join_type JOIN table_ref join_qual
   10657             :  { 
   10658           0 :  $$ = cat_str(5,$1,$2,mm_strdup("join"),$4,$5);
   10659             : }
   10660             : |  table_ref JOIN table_ref join_qual
   10661             :  { 
   10662           0 :  $$ = cat_str(4,$1,mm_strdup("join"),$3,$4);
   10663             : }
   10664             : |  table_ref NATURAL join_type JOIN table_ref
   10665             :  { 
   10666           0 :  $$ = cat_str(5,$1,mm_strdup("natural"),$3,mm_strdup("join"),$5);
   10667             : }
   10668             : |  table_ref NATURAL JOIN table_ref
   10669             :  { 
   10670           0 :  $$ = cat_str(3,$1,mm_strdup("natural join"),$4);
   10671             : }
   10672             : ;
   10673             : 
   10674             : 
   10675             :  alias_clause:
   10676             :  AS ColId '(' name_list ')'
   10677             :  { 
   10678           2 :  $$ = cat_str(5,mm_strdup("as"),$2,mm_strdup("("),$4,mm_strdup(")"));
   10679             : }
   10680             : |  AS ColId
   10681             :  { 
   10682           0 :  $$ = cat_str(2,mm_strdup("as"),$2);
   10683             : }
   10684             : |  ColId '(' name_list ')'
   10685             :  { 
   10686           0 :  $$ = cat_str(4,$1,mm_strdup("("),$3,mm_strdup(")"));
   10687             : }
   10688             : |  ColId
   10689             :  { 
   10690           0 :  $$ = $1;
   10691             : }
   10692             : ;
   10693             : 
   10694             : 
   10695             :  opt_alias_clause:
   10696             :  alias_clause
   10697             :  { 
   10698           0 :  $$ = $1;
   10699             : }
   10700             : | 
   10701             :  { 
   10702         146 :  $$=EMPTY; }
   10703             : ;
   10704             : 
   10705             : 
   10706             :  func_alias_clause:
   10707             :  alias_clause
   10708             :  { 
   10709           2 :  $$ = $1;
   10710             : }
   10711             : |  AS '(' TableFuncElementList ')'
   10712             :  { 
   10713           0 :  $$ = cat_str(3,mm_strdup("as ("),$3,mm_strdup(")"));
   10714             : }
   10715             : |  AS ColId '(' TableFuncElementList ')'
   10716             :  { 
   10717           0 :  $$ = cat_str(5,mm_strdup("as"),$2,mm_strdup("("),$4,mm_strdup(")"));
   10718             : }
   10719             : |  ColId '(' TableFuncElementList ')'
   10720             :  { 
   10721           0 :  $$ = cat_str(4,$1,mm_strdup("("),$3,mm_strdup(")"));
   10722             : }
   10723             : | 
   10724             :  { 
   10725           0 :  $$=EMPTY; }
   10726             : ;
   10727             : 
   10728             : 
   10729             :  join_type:
   10730             :  FULL opt_outer
   10731             :  { 
   10732           0 :  $$ = cat_str(2,mm_strdup("full"),$2);
   10733             : }
   10734             : |  LEFT opt_outer
   10735             :  { 
   10736           0 :  $$ = cat_str(2,mm_strdup("left"),$2);
   10737             : }
   10738             : |  RIGHT opt_outer
   10739             :  { 
   10740           0 :  $$ = cat_str(2,mm_strdup("right"),$2);
   10741             : }
   10742             : |  INNER_P
   10743             :  { 
   10744           0 :  $$ = mm_strdup("inner");
   10745             : }
   10746             : ;
   10747             : 
   10748             : 
   10749             :  opt_outer:
   10750             :  OUTER_P
   10751             :  { 
   10752           0 :  $$ = mm_strdup("outer");
   10753             : }
   10754             : | 
   10755             :  { 
   10756           0 :  $$=EMPTY; }
   10757             : ;
   10758             : 
   10759             : 
   10760             :  join_qual:
   10761             :  USING '(' name_list ')'
   10762             :  { 
   10763           0 :  $$ = cat_str(3,mm_strdup("using ("),$3,mm_strdup(")"));
   10764             : }
   10765             : |  ON a_expr
   10766             :  { 
   10767           0 :  $$ = cat_str(2,mm_strdup("on"),$2);
   10768             : }
   10769             : ;
   10770             : 
   10771             : 
   10772             :  relation_expr:
   10773             :  qualified_name
   10774             :  { 
   10775         208 :  $$ = $1;
   10776             : }
   10777             : |  qualified_name '*'
   10778             :  { 
   10779           0 :  $$ = cat_str(2,$1,mm_strdup("*"));
   10780             : }
   10781             : |  ONLY qualified_name
   10782             :  { 
   10783           0 :  $$ = cat_str(2,mm_strdup("only"),$2);
   10784             : }
   10785             : |  ONLY '(' qualified_name ')'
   10786             :  { 
   10787           0 :  $$ = cat_str(3,mm_strdup("only ("),$3,mm_strdup(")"));
   10788             : }
   10789             : ;
   10790             : 
   10791             : 
   10792             :  relation_expr_list:
   10793             :  relation_expr
   10794             :  { 
   10795          44 :  $$ = $1;
   10796             : }
   10797             : |  relation_expr_list ',' relation_expr
   10798             :  { 
   10799           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10800             : }
   10801             : ;
   10802             : 
   10803             : 
   10804             :  relation_expr_opt_alias:
   10805             :  relation_expr %prec UMINUS
   10806             :  { 
   10807          14 :  $$ = $1;
   10808             : }
   10809             : |  relation_expr ColId
   10810             :  { 
   10811           0 :  $$ = cat_str(2,$1,$2);
   10812             : }
   10813             : |  relation_expr AS ColId
   10814             :  { 
   10815           0 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
   10816             : }
   10817             : ;
   10818             : 
   10819             : 
   10820             :  tablesample_clause:
   10821             :  TABLESAMPLE func_name '(' expr_list ')' opt_repeatable_clause
   10822             :  { 
   10823           0 :  $$ = cat_str(6,mm_strdup("tablesample"),$2,mm_strdup("("),$4,mm_strdup(")"),$6);
   10824             : }
   10825             : ;
   10826             : 
   10827             : 
   10828             :  opt_repeatable_clause:
   10829             :  REPEATABLE '(' a_expr ')'
   10830             :  { 
   10831           0 :  $$ = cat_str(3,mm_strdup("repeatable ("),$3,mm_strdup(")"));
   10832             : }
   10833             : | 
   10834             :  { 
   10835           0 :  $$=EMPTY; }
   10836             : ;
   10837             : 
   10838             : 
   10839             :  func_table:
   10840             :  func_expr_windowless opt_ordinality
   10841             :  { 
   10842           2 :  $$ = cat_str(2,$1,$2);
   10843             : }
   10844             : |  ROWS FROM '(' rowsfrom_list ')' opt_ordinality
   10845             :  { 
   10846           0 :  $$ = cat_str(4,mm_strdup("rows from ("),$4,mm_strdup(")"),$6);
   10847             : }
   10848             : ;
   10849             : 
   10850             : 
   10851             :  rowsfrom_item:
   10852             :  func_expr_windowless opt_col_def_list
   10853             :  { 
   10854           0 :  $$ = cat_str(2,$1,$2);
   10855             : }
   10856             : ;
   10857             : 
   10858             : 
   10859             :  rowsfrom_list:
   10860             :  rowsfrom_item
   10861             :  { 
   10862           0 :  $$ = $1;
   10863             : }
   10864             : |  rowsfrom_list ',' rowsfrom_item
   10865             :  { 
   10866           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10867             : }
   10868             : ;
   10869             : 
   10870             : 
   10871             :  opt_col_def_list:
   10872             :  AS '(' TableFuncElementList ')'
   10873             :  { 
   10874           0 :  $$ = cat_str(3,mm_strdup("as ("),$3,mm_strdup(")"));
   10875             : }
   10876             : | 
   10877             :  { 
   10878           0 :  $$=EMPTY; }
   10879             : ;
   10880             : 
   10881             : 
   10882             :  opt_ordinality:
   10883             :  WITH_LA ORDINALITY
   10884             :  { 
   10885           2 :  $$ = mm_strdup("with ordinality");
   10886             : }
   10887             : | 
   10888             :  { 
   10889           0 :  $$=EMPTY; }
   10890             : ;
   10891             : 
   10892             : 
   10893             :  where_clause:
   10894             :  WHERE a_expr
   10895             :  { 
   10896          54 :  $$ = cat_str(2,mm_strdup("where"),$2);
   10897             : }
   10898             : | 
   10899             :  { 
   10900         130 :  $$=EMPTY; }
   10901             : ;
   10902             : 
   10903             : 
   10904             :  where_or_current_clause:
   10905             :  WHERE a_expr
   10906             :  { 
   10907          12 :  $$ = cat_str(2,mm_strdup("where"),$2);
   10908             : }
   10909             : |  WHERE CURRENT_P OF cursor_name
   10910             :     {
   10911           0 :         char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
   10912           0 :         $$ = cat_str(2,mm_strdup("where current of"), cursor_marker);
   10913             :     }
   10914             : | 
   10915             :  { 
   10916           2 :  $$=EMPTY; }
   10917             : ;
   10918             : 
   10919             : 
   10920             :  OptTableFuncElementList:
   10921             :  TableFuncElementList
   10922             :  { 
   10923           0 :  $$ = $1;
   10924             : }
   10925             : | 
   10926             :  { 
   10927           0 :  $$=EMPTY; }
   10928             : ;
   10929             : 
   10930             : 
   10931             :  TableFuncElementList:
   10932             :  TableFuncElement
   10933             :  { 
   10934           0 :  $$ = $1;
   10935             : }
   10936             : |  TableFuncElementList ',' TableFuncElement
   10937             :  { 
   10938           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10939             : }
   10940             : ;
   10941             : 
   10942             : 
   10943             :  TableFuncElement:
   10944             :  ColId Typename opt_collate_clause
   10945             :  { 
   10946           0 :  $$ = cat_str(3,$1,$2,$3);
   10947             : }
   10948             : ;
   10949             : 
   10950             : 
   10951             :  xmltable:
   10952             :  XMLTABLE '(' c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
   10953             :  { 
   10954           0 :  $$ = cat_str(6,mm_strdup("xmltable ("),$3,$4,mm_strdup("columns"),$6,mm_strdup(")"));
   10955             : }
   10956             : |  XMLTABLE '(' XMLNAMESPACES '(' xml_namespace_list ')' ',' c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
   10957             :  { 
   10958           0 :  $$ = cat_str(8,mm_strdup("xmltable ( xmlnamespaces ("),$5,mm_strdup(") ,"),$8,$9,mm_strdup("columns"),$11,mm_strdup(")"));
   10959             : }
   10960             : ;
   10961             : 
   10962             : 
   10963             :  xmltable_column_list:
   10964             :  xmltable_column_el
   10965             :  { 
   10966           0 :  $$ = $1;
   10967             : }
   10968             : |  xmltable_column_list ',' xmltable_column_el
   10969             :  { 
   10970           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   10971             : }
   10972             : ;
   10973             : 
   10974             : 
   10975             :  xmltable_column_el:
   10976             :  ColId Typename
   10977             :  { 
   10978           0 :  $$ = cat_str(2,$1,$2);
   10979             : }
   10980             : |  ColId Typename xmltable_column_option_list
   10981             :  { 
   10982           0 :  $$ = cat_str(3,$1,$2,$3);
   10983             : }
   10984             : |  ColId FOR ORDINALITY
   10985             :  { 
   10986           0 :  $$ = cat_str(2,$1,mm_strdup("for ordinality"));
   10987             : }
   10988             : ;
   10989             : 
   10990             : 
   10991             :  xmltable_column_option_list:
   10992             :  xmltable_column_option_el
   10993             :  { 
   10994           0 :  $$ = $1;
   10995             : }
   10996             : |  xmltable_column_option_list xmltable_column_option_el
   10997             :  { 
   10998           0 :  $$ = cat_str(2,$1,$2);
   10999             : }
   11000             : ;
   11001             : 
   11002             : 
   11003             :  xmltable_column_option_el:
   11004             :  ecpg_ident b_expr
   11005             :  { 
   11006           0 :  $$ = cat_str(2,$1,$2);
   11007             : }
   11008             : |  DEFAULT b_expr
   11009             :  { 
   11010           0 :  $$ = cat_str(2,mm_strdup("default"),$2);
   11011             : }
   11012             : |  NOT NULL_P
   11013             :  { 
   11014           0 :  $$ = mm_strdup("not null");
   11015             : }
   11016             : |  NULL_P
   11017             :  { 
   11018           0 :  $$ = mm_strdup("null");
   11019             : }
   11020             : ;
   11021             : 
   11022             : 
   11023             :  xml_namespace_list:
   11024             :  xml_namespace_el
   11025             :  { 
   11026           0 :  $$ = $1;
   11027             : }
   11028             : |  xml_namespace_list ',' xml_namespace_el
   11029             :  { 
   11030           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   11031             : }
   11032             : ;
   11033             : 
   11034             : 
   11035             :  xml_namespace_el:
   11036             :  b_expr AS ColLabel
   11037             :  { 
   11038           0 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
   11039             : }
   11040             : |  DEFAULT b_expr
   11041             :  { 
   11042           0 :  $$ = cat_str(2,mm_strdup("default"),$2);
   11043             : }
   11044             : ;
   11045             : 
   11046             : 
   11047             :  Typename:
   11048             :  SimpleTypename opt_array_bounds
   11049         338 :     {   $$ = cat2_str($1, $2.str); }
   11050             : |  SETOF SimpleTypename opt_array_bounds
   11051           0 :     {   $$ = cat_str(3, mm_strdup("setof"), $2, $3.str); }
   11052             : |  SimpleTypename ARRAY '[' Iconst ']'
   11053             :  { 
   11054           0 :  $$ = cat_str(4,$1,mm_strdup("array ["),$4,mm_strdup("]"));
   11055             : }
   11056             : |  SETOF SimpleTypename ARRAY '[' Iconst ']'
   11057             :  { 
   11058           0 :  $$ = cat_str(5,mm_strdup("setof"),$2,mm_strdup("array ["),$5,mm_strdup("]"));
   11059             : }
   11060             : |  SimpleTypename ARRAY
   11061             :  { 
   11062           0 :  $$ = cat_str(2,$1,mm_strdup("array"));
   11063             : }
   11064             : |  SETOF SimpleTypename ARRAY
   11065             :  { 
   11066           0 :  $$ = cat_str(3,mm_strdup("setof"),$2,mm_strdup("array"));
   11067             : }
   11068             : ;
   11069             : 
   11070             : 
   11071             :  opt_array_bounds:
   11072             :  opt_array_bounds '[' ']'
   11073             :     {
   11074           6 :         $$.index1 = $1.index1;
   11075           6 :         $$.index2 = $1.index2;
   11076           6 :         if (strcmp($$.index1, "-1") == 0)
   11077           6 :             $$.index1 = mm_strdup("0");
   11078           0 :         else if (strcmp($1.index2, "-1") == 0)
   11079           0 :             $$.index2 = mm_strdup("0");
   11080           6 :         $$.str = cat_str(2, $1.str, mm_strdup("[]"));
   11081             :     }
   11082             :     | opt_array_bounds '[' Iresult ']'
   11083             :     {
   11084         226 :         $$.index1 = $1.index1;
   11085         226 :         $$.index2 = $1.index2;
   11086         226 :         if (strcmp($1.index1, "-1") == 0)
   11087         204 :             $$.index1 = mm_strdup($3);
   11088          22 :         else if (strcmp($1.index2, "-1") == 0)
   11089          22 :             $$.index2 = mm_strdup($3);
   11090         226 :         $$.str = cat_str(4, $1.str, mm_strdup("["), $3, mm_strdup("]"));
   11091             :     }
   11092             : | 
   11093             :     {
   11094        1046 :         $$.index1 = mm_strdup("-1");
   11095        1046 :         $$.index2 = mm_strdup("-1");
   11096        1046 :         $$.str= EMPTY;
   11097             :     }
   11098             : ;
   11099             : 
   11100             : 
   11101             :  SimpleTypename:
   11102             :  GenericType
   11103             :  { 
   11104         106 :  $$ = $1;
   11105             : }
   11106             : |  Numeric
   11107             :  { 
   11108         156 :  $$ = $1;
   11109             : }
   11110             : |  Bit
   11111             :  { 
   11112           0 :  $$ = $1;
   11113             : }
   11114             : |  Character
   11115             :  { 
   11116          60 :  $$ = $1;
   11117             : }
   11118             : |  ConstDatetime
   11119             :  { 
   11120          14 :  $$ = $1;
   11121             : }
   11122             : |  ConstInterval opt_interval
   11123             :  { 
   11124           2 :  $$ = cat_str(2,$1,$2);
   11125             : }
   11126             : |  ConstInterval '(' Iconst ')'
   11127             :  { 
   11128           0 :  $$ = cat_str(4,$1,mm_strdup("("),$3,mm_strdup(")"));
   11129             : }
   11130             : ;
   11131             : 
   11132             : 
   11133             :  ConstTypename:
   11134             :  Numeric
   11135             :  { 
   11136           0 :  $$ = $1;
   11137             : }
   11138             : |  ConstBit
   11139             :  { 
   11140           0 :  $$ = $1;
   11141             : }
   11142             : |  ConstCharacter
   11143             :  { 
   11144           0 :  $$ = $1;
   11145             : }
   11146             : |  ConstDatetime
   11147             :  { 
   11148           0 :  $$ = $1;
   11149             : }
   11150             : ;
   11151             : 
   11152             : 
   11153             :  GenericType:
   11154             :  type_function_name opt_type_modifiers
   11155             :  { 
   11156         106 :  $$ = cat_str(2,$1,$2);
   11157             : }
   11158             : |  type_function_name attrs opt_type_modifiers
   11159             :  { 
   11160           0 :  $$ = cat_str(3,$1,$2,$3);
   11161             : }
   11162             : ;
   11163             : 
   11164             : 
   11165             :  opt_type_modifiers:
   11166             :  '(' expr_list ')'
   11167             :  { 
   11168           6 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
   11169             : }
   11170             : | 
   11171             :  { 
   11172         122 :  $$=EMPTY; }
   11173             : ;
   11174             : 
   11175             : 
   11176             :  Numeric:
   11177             :  INT_P
   11178             :  { 
   11179          86 :  $$ = mm_strdup("int");
   11180             : }
   11181             : |  INTEGER
   11182             :  { 
   11183          18 :  $$ = mm_strdup("integer");
   11184             : }
   11185             : |  SMALLINT
   11186             :  { 
   11187          10 :  $$ = mm_strdup("smallint");
   11188             : }
   11189             : |  BIGINT
   11190             :  { 
   11191           6 :  $$ = mm_strdup("bigint");
   11192             : }
   11193             : |  REAL
   11194             :  { 
   11195           0 :  $$ = mm_strdup("real");
   11196             : }
   11197             : |  FLOAT_P opt_float
   11198             :  { 
   11199           4 :  $$ = cat_str(2,mm_strdup("float"),$2);
   11200             : }
   11201             : |  DOUBLE_P PRECISION
   11202             :  { 
   11203           6 :  $$ = mm_strdup("double precision");
   11204             : }
   11205             : |  DECIMAL_P opt_type_modifiers
   11206             :  { 
   11207           4 :  $$ = cat_str(2,mm_strdup("decimal"),$2);
   11208             : }
   11209             : |  DEC opt_type_modifiers
   11210             :  { 
   11211           0 :  $$ = cat_str(2,mm_strdup("dec"),$2);
   11212             : }
   11213             : |  NUMERIC opt_type_modifiers
   11214             :  { 
   11215          18 :  $$ = cat_str(2,mm_strdup("numeric"),$2);
   11216             : }
   11217             : |  BOOLEAN_P
   11218             :  { 
   11219           4 :  $$ = mm_strdup("boolean");
   11220             : }
   11221             : ;
   11222             : 
   11223             : 
   11224             :  opt_float:
   11225             :  '(' Iconst ')'
   11226             :  { 
   11227           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
   11228             : }
   11229             : | 
   11230             :  { 
   11231           4 :  $$=EMPTY; }
   11232             : ;
   11233             : 
   11234             : 
   11235             :  Bit:
   11236             :  BitWithLength
   11237             :  { 
   11238           0 :  $$ = $1;
   11239             : }
   11240             : |  BitWithoutLength
   11241             :  { 
   11242           0 :  $$ = $1;
   11243             : }
   11244             : ;
   11245             : 
   11246             : 
   11247             :  ConstBit:
   11248             :  BitWithLength
   11249             :  { 
   11250           0 :  $$ = $1;
   11251             : }
   11252             : |  BitWithoutLength
   11253             :  { 
   11254           0 :  $$ = $1;
   11255             : }
   11256             : ;
   11257             : 
   11258             : 
   11259             :  BitWithLength:
   11260             :  BIT opt_varying '(' expr_list ')'
   11261             :  { 
   11262           0 :  $$ = cat_str(5,mm_strdup("bit"),$2,mm_strdup("("),$4,mm_strdup(")"));
   11263             : }
   11264             : ;
   11265             : 
   11266             : 
   11267             :  BitWithoutLength:
   11268             :  BIT opt_varying
   11269             :  { 
   11270           0 :  $$ = cat_str(2,mm_strdup("bit"),$2);
   11271             : }
   11272             : ;
   11273             : 
   11274             : 
   11275             :  Character:
   11276             :  CharacterWithLength
   11277             :  { 
   11278          54 :  $$ = $1;
   11279             : }
   11280             : |  CharacterWithoutLength
   11281             :  { 
   11282           6 :  $$ = $1;
   11283             : }
   11284             : ;
   11285             : 
   11286             : 
   11287             :  ConstCharacter:
   11288             :  CharacterWithLength
   11289             :  { 
   11290           0 :  $$ = $1;
   11291             : }
   11292             : |  CharacterWithoutLength
   11293             :  { 
   11294           0 :  $$ = $1;
   11295             : }
   11296             : ;
   11297             : 
   11298             : 
   11299             :  CharacterWithLength:
   11300             :  character '(' Iconst ')'
   11301             :  { 
   11302          54 :  $$ = cat_str(4,$1,mm_strdup("("),$3,mm_strdup(")"));
   11303             : }
   11304             : ;
   11305             : 
   11306             : 
   11307             :  CharacterWithoutLength:
   11308             :  character
   11309             :  { 
   11310           6 :  $$ = $1;
   11311             : }
   11312             : ;
   11313             : 
   11314             : 
   11315             :  character:
   11316             :  CHARACTER opt_varying
   11317             :  { 
   11318           2 :  $$ = cat_str(2,mm_strdup("character"),$2);
   11319             : }
   11320             : |  CHAR_P opt_varying
   11321             :  { 
   11322          42 :  $$ = cat_str(2,mm_strdup("char"),$2);
   11323             : }
   11324             : |  VARCHAR
   11325             :  { 
   11326          16 :  $$ = mm_strdup("varchar");
   11327             : }
   11328             : |  NATIONAL CHARACTER opt_varying
   11329             :  { 
   11330           0 :  $$ = cat_str(2,mm_strdup("national character"),$3);
   11331             : }
   11332             : |  NATIONAL CHAR_P opt_varying
   11333             :  { 
   11334           0 :  $$ = cat_str(2,mm_strdup("national char"),$3);
   11335             : }
   11336             : |  NCHAR opt_varying
   11337             :  { 
   11338           0 :  $$ = cat_str(2,mm_strdup("nchar"),$2);
   11339             : }
   11340             : ;
   11341             : 
   11342             : 
   11343             :  opt_varying:
   11344             :  VARYING
   11345             :  { 
   11346           0 :  $$ = mm_strdup("varying");
   11347             : }
   11348             : | 
   11349             :  { 
   11350          44 :  $$=EMPTY; }
   11351             : ;
   11352             : 
   11353             : 
   11354             :  ConstDatetime:
   11355             :  TIMESTAMP '(' Iconst ')' opt_timezone
   11356             :  { 
   11357           0 :  $$ = cat_str(4,mm_strdup("timestamp ("),$3,mm_strdup(")"),$5);
   11358             : }
   11359             : |  TIMESTAMP opt_timezone
   11360             :  { 
   11361          14 :  $$ = cat_str(2,mm_strdup("timestamp"),$2);
   11362             : }
   11363             : |  TIME '(' Iconst ')' opt_timezone
   11364             :  { 
   11365           0 :  $$ = cat_str(4,mm_strdup("time ("),$3,mm_strdup(")"),$5);
   11366             : }
   11367             : |  TIME opt_timezone
   11368             :  { 
   11369           0 :  $$ = cat_str(2,mm_strdup("time"),$2);
   11370             : }
   11371             : ;
   11372             : 
   11373             : 
   11374             :  ConstInterval:
   11375             :  INTERVAL
   11376             :  { 
   11377           2 :  $$ = mm_strdup("interval");
   11378             : }
   11379             : ;
   11380             : 
   11381             : 
   11382             :  opt_timezone:
   11383             :  WITH_LA TIME ZONE
   11384             :  { 
   11385           0 :  $$ = mm_strdup("with time zone");
   11386             : }
   11387             : |  WITHOUT TIME ZONE
   11388             :  { 
   11389           2 :  $$ = mm_strdup("without time zone");
   11390             : }
   11391             : | 
   11392             :  { 
   11393          12 :  $$=EMPTY; }
   11394             : ;
   11395             : 
   11396             : 
   11397             :  opt_interval:
   11398             :  YEAR_P
   11399             :  { 
   11400           0 :  $$ = mm_strdup("year");
   11401             : }
   11402             : |  MONTH_P
   11403             :  { 
   11404           0 :  $$ = mm_strdup("month");
   11405             : }
   11406             : |  DAY_P
   11407             :  { 
   11408           0 :  $$ = mm_strdup("day");
   11409             : }
   11410             : |  HOUR_P
   11411             :  { 
   11412           0 :  $$ = mm_strdup("hour");
   11413             : }
   11414             : |  MINUTE_P
   11415             :  { 
   11416           0 :  $$ = mm_strdup("minute");
   11417             : }
   11418             : |  interval_second
   11419             :  { 
   11420           0 :  $$ = $1;
   11421             : }
   11422             : |  YEAR_P TO MONTH_P
   11423             :  { 
   11424           0 :  $$ = mm_strdup("year to month");
   11425             : }
   11426             : |  DAY_P TO HOUR_P
   11427             :  { 
   11428           0 :  $$ = mm_strdup("day to hour");
   11429             : }
   11430             : |  DAY_P TO MINUTE_P
   11431             :  { 
   11432           0 :  $$ = mm_strdup("day to minute");
   11433             : }
   11434             : |  DAY_P TO interval_second
   11435             :  { 
   11436           0 :  $$ = cat_str(2,mm_strdup("day to"),$3);
   11437             : }
   11438             : |  HOUR_P TO MINUTE_P
   11439             :  { 
   11440           0 :  $$ = mm_strdup("hour to minute");
   11441             : }
   11442             : |  HOUR_P TO interval_second
   11443             :  { 
   11444           0 :  $$ = cat_str(2,mm_strdup("hour to"),$3);
   11445             : }
   11446             : |  MINUTE_P TO interval_second
   11447             :  { 
   11448           0 :  $$ = cat_str(2,mm_strdup("minute to"),$3);
   11449             : }
   11450             : | 
   11451             :  { 
   11452         134 :  $$=EMPTY; }
   11453             : ;
   11454             : 
   11455             : 
   11456             :  interval_second:
   11457             :  SECOND_P
   11458             :  { 
   11459           0 :  $$ = mm_strdup("second");
   11460             : }
   11461             : |  SECOND_P '(' Iconst ')'
   11462             :  { 
   11463           0 :  $$ = cat_str(3,mm_strdup("second ("),$3,mm_strdup(")"));
   11464             : }
   11465             : ;
   11466             : 
   11467             : 
   11468             :  a_expr:
   11469             :  c_expr
   11470             :  { 
   11471        1202 :  $$ = $1;
   11472             : }
   11473             : |  a_expr TYPECAST Typename
   11474             :  { 
   11475          12 :  $$ = cat_str(3,$1,mm_strdup("::"),$3);
   11476             : }
   11477             : |  a_expr COLLATE any_name
   11478             :  { 
   11479           2 :  $$ = cat_str(3,$1,mm_strdup("collate"),$3);
   11480             : }
   11481             : |  a_expr AT TIME ZONE a_expr %prec AT
   11482             :  { 
   11483           0 :  $$ = cat_str(3,$1,mm_strdup("at time zone"),$5);
   11484             : }
   11485             : |  '+' a_expr %prec UMINUS
   11486             :  { 
   11487           0 :  $$ = cat_str(2,mm_strdup("+"),$2);
   11488             : }
   11489             : |  '-' a_expr %prec UMINUS
   11490             :  { 
   11491           6 :  $$ = cat_str(2,mm_strdup("-"),$2);
   11492             : }
   11493             : |  a_expr '+' a_expr
   11494             :  { 
   11495          12 :  $$ = cat_str(3,$1,mm_strdup("+"),$3);
   11496             : }
   11497             : |  a_expr '-' a_expr
   11498             :  { 
   11499           2 :  $$ = cat_str(3,$1,mm_strdup("-"),$3);
   11500             : }
   11501             : |  a_expr '*' a_expr
   11502             :  { 
   11503           0 :  $$ = cat_str(3,$1,mm_strdup("*"),$3);
   11504             : }
   11505             : |  a_expr '/' a_expr
   11506             :  { 
   11507           0 :  $$ = cat_str(3,$1,mm_strdup("/"),$3);
   11508             : }
   11509             : |  a_expr '%' a_expr
   11510             :  { 
   11511           0 :  $$ = cat_str(3,$1,mm_strdup("%"),$3);
   11512             : }
   11513             : |  a_expr '^' a_expr
   11514             :  { 
   11515           0 :  $$ = cat_str(3,$1,mm_strdup("^"),$3);
   11516             : }
   11517             : |  a_expr '<' a_expr
   11518             :  { 
   11519           0 :  $$ = cat_str(3,$1,mm_strdup("<"),$3);
   11520             : }
   11521             : |  a_expr '>' a_expr
   11522             :  { 
   11523           0 :  $$ = cat_str(3,$1,mm_strdup(">"),$3);
   11524             : }
   11525             : |  a_expr '=' a_expr
   11526             :  { 
   11527          64 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
   11528             : }
   11529             : |  a_expr LESS_EQUALS a_expr
   11530             :  { 
   11531           2 :  $$ = cat_str(3,$1,mm_strdup("<="),$3);
   11532             : }
   11533             : |  a_expr GREATER_EQUALS a_expr
   11534             :  { 
   11535           0 :  $$ = cat_str(3,$1,mm_strdup(">="),$3);
   11536             : }
   11537             : |  a_expr NOT_EQUALS a_expr
   11538             :  { 
   11539           0 :  $$ = cat_str(3,$1,mm_strdup("<>"),$3);
   11540             : }
   11541             : |  a_expr qual_Op a_expr %prec Op
   11542             :  { 
   11543           4 :  $$ = cat_str(3,$1,$2,$3);
   11544             : }
   11545             : |  qual_Op a_expr %prec Op
   11546             :  { 
   11547           0 :  $$ = cat_str(2,$1,$2);
   11548             : }
   11549             : |  a_expr AND a_expr
   11550             :  { 
   11551           0 :  $$ = cat_str(3,$1,mm_strdup("and"),$3);
   11552             : }
   11553             : |  a_expr OR a_expr
   11554             :  { 
   11555           0 :  $$ = cat_str(3,$1,mm_strdup("or"),$3);
   11556             : }
   11557             : |  NOT a_expr
   11558             :  { 
   11559           0 :  $$ = cat_str(2,mm_strdup("not"),$2);
   11560             : }
   11561             : |  NOT_LA a_expr %prec NOT
   11562             :  { 
   11563           0 :  $$ = cat_str(2,mm_strdup("not"),$2);
   11564             : }
   11565             : |  a_expr LIKE a_expr
   11566             :  { 
   11567           0 :  $$ = cat_str(3,$1,mm_strdup("like"),$3);
   11568             : }
   11569             : |  a_expr LIKE a_expr ESCAPE a_expr %prec LIKE
   11570             :  { 
   11571           0 :  $$ = cat_str(5,$1,mm_strdup("like"),$3,mm_strdup("escape"),$5);
   11572             : }
   11573             : |  a_expr NOT_LA LIKE a_expr %prec NOT_LA
   11574             :  { 
   11575           0 :  $$ = cat_str(3,$1,mm_strdup("not like"),$4);
   11576             : }
   11577             : |  a_expr NOT_LA LIKE a_expr ESCAPE a_expr %prec NOT_LA
   11578             :  { 
   11579           0 :  $$ = cat_str(5,$1,mm_strdup("not like"),$4,mm_strdup("escape"),$6);
   11580             : }
   11581             : |  a_expr ILIKE a_expr
   11582             :  { 
   11583           0 :  $$ = cat_str(3,$1,mm_strdup("ilike"),$3);
   11584             : }
   11585             : |  a_expr ILIKE a_expr ESCAPE a_expr %prec ILIKE
   11586             :  { 
   11587           0 :  $$ = cat_str(5,$1,mm_strdup("ilike"),$3,mm_strdup("escape"),$5);
   11588             : }
   11589             : |  a_expr NOT_LA ILIKE a_expr %prec NOT_LA
   11590             :  { 
   11591           0 :  $$ = cat_str(3,$1,mm_strdup("not ilike"),$4);
   11592             : }
   11593             : |  a_expr NOT_LA ILIKE a_expr ESCAPE a_expr %prec NOT_LA
   11594             :  { 
   11595           0 :  $$ = cat_str(5,$1,mm_strdup("not ilike"),$4,mm_strdup("escape"),$6);
   11596             : }
   11597             : |  a_expr SIMILAR TO a_expr %prec SIMILAR
   11598             :  { 
   11599           0 :  $$ = cat_str(3,$1,mm_strdup("similar to"),$4);
   11600             : }
   11601             : |  a_expr SIMILAR TO a_expr ESCAPE a_expr %prec SIMILAR
   11602             :  { 
   11603           0 :  $$ = cat_str(5,$1,mm_strdup("similar to"),$4,mm_strdup("escape"),$6);
   11604             : }
   11605             : |  a_expr NOT_LA SIMILAR TO a_expr %prec NOT_LA
   11606             :  { 
   11607           0 :  $$ = cat_str(3,$1,mm_strdup("not similar to"),$5);
   11608             : }
   11609             : |  a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr %prec NOT_LA
   11610             :  { 
   11611           0 :  $$ = cat_str(5,$1,mm_strdup("not similar to"),$5,mm_strdup("escape"),$7);
   11612             : }
   11613             : |  a_expr IS NULL_P %prec IS
   11614             :  { 
   11615           0 :  $$ = cat_str(2,$1,mm_strdup("is null"));
   11616             : }
   11617             : |  a_expr ISNULL
   11618             :  { 
   11619           0 :  $$ = cat_str(2,$1,mm_strdup("isnull"));
   11620             : }
   11621             : |  a_expr IS NOT NULL_P %prec IS
   11622             :  { 
   11623           0 :  $$ = cat_str(2,$1,mm_strdup("is not null"));
   11624             : }
   11625             : |  a_expr NOTNULL
   11626             :  { 
   11627           0 :  $$ = cat_str(2,$1,mm_strdup("notnull"));
   11628             : }
   11629             : |  row OVERLAPS row
   11630             :  { 
   11631           0 :  $$ = cat_str(3,$1,mm_strdup("overlaps"),$3);
   11632             : }
   11633             : |  a_expr IS TRUE_P %prec IS
   11634             :  { 
   11635           0 :  $$ = cat_str(2,$1,mm_strdup("is true"));
   11636             : }
   11637             : |  a_expr IS NOT TRUE_P %prec IS
   11638             :  { 
   11639           0 :  $$ = cat_str(2,$1,mm_strdup("is not true"));
   11640             : }
   11641             : |  a_expr IS FALSE_P %prec IS
   11642             :  { 
   11643           0 :  $$ = cat_str(2,$1,mm_strdup("is false"));
   11644             : }
   11645             : |  a_expr IS NOT FALSE_P %prec IS
   11646             :  { 
   11647           0 :  $$ = cat_str(2,$1,mm_strdup("is not false"));
   11648             : }
   11649             : |  a_expr IS UNKNOWN %prec IS
   11650             :  { 
   11651           0 :  $$ = cat_str(2,$1,mm_strdup("is unknown"));
   11652             : }
   11653             : |  a_expr IS NOT UNKNOWN %prec IS
   11654             :  { 
   11655           0 :  $$ = cat_str(2,$1,mm_strdup("is not unknown"));
   11656             : }
   11657             : |  a_expr IS DISTINCT FROM a_expr %prec IS
   11658             :  { 
   11659           0 :  $$ = cat_str(3,$1,mm_strdup("is distinct from"),$5);
   11660             : }
   11661             : |  a_expr IS NOT DISTINCT FROM a_expr %prec IS
   11662             :  { 
   11663           0 :  $$ = cat_str(3,$1,mm_strdup("is not distinct from"),$6);
   11664             : }
   11665             : |  a_expr BETWEEN opt_asymmetric b_expr AND a_expr %prec BETWEEN
   11666             :  { 
   11667           0 :  $$ = cat_str(6,$1,mm_strdup("between"),$3,$4,mm_strdup("and"),$6);
   11668             : }
   11669             : |  a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr %prec NOT_LA
   11670             :  { 
   11671           0 :  $$ = cat_str(6,$1,mm_strdup("not between"),$4,$5,mm_strdup("and"),$7);
   11672             : }
   11673             : |  a_expr BETWEEN SYMMETRIC b_expr AND a_expr %prec BETWEEN
   11674             :  { 
   11675           0 :  $$ = cat_str(5,$1,mm_strdup("between symmetric"),$4,mm_strdup("and"),$6);
   11676             : }
   11677             : |  a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr %prec NOT_LA
   11678             :  { 
   11679           0 :  $$ = cat_str(5,$1,mm_strdup("not between symmetric"),$5,mm_strdup("and"),$7);
   11680             : }
   11681             : |  a_expr IN_P in_expr
   11682             :  { 
   11683           0 :  $$ = cat_str(3,$1,mm_strdup("in"),$3);
   11684             : }
   11685             : |  a_expr NOT_LA IN_P in_expr %prec NOT_LA
   11686             :  { 
   11687           0 :  $$ = cat_str(3,$1,mm_strdup("not in"),$4);
   11688             : }
   11689             : |  a_expr subquery_Op sub_type select_with_parens %prec Op
   11690             :  { 
   11691           0 :  $$ = cat_str(4,$1,$2,$3,$4);
   11692             : }
   11693             : |  a_expr subquery_Op sub_type '(' a_expr ')' %prec Op
   11694             :  { 
   11695           0 :  $$ = cat_str(6,$1,$2,$3,mm_strdup("("),$5,mm_strdup(")"));
   11696             : }
   11697             : |  UNIQUE select_with_parens
   11698             :  { 
   11699           0 : mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
   11700           0 :  $$ = cat_str(2,mm_strdup("unique"),$2);
   11701             : }
   11702             : |  a_expr IS DOCUMENT_P %prec IS
   11703             :  { 
   11704           0 :  $$ = cat_str(2,$1,mm_strdup("is document"));
   11705             : }
   11706             : |  a_expr IS NOT DOCUMENT_P %prec IS
   11707             :  { 
   11708           0 :  $$ = cat_str(2,$1,mm_strdup("is not document"));
   11709             : }
   11710             : |  a_expr IS NORMALIZED %prec IS
   11711             :  { 
   11712           0 :  $$ = cat_str(2,$1,mm_strdup("is normalized"));
   11713             : }
   11714             : |  a_expr IS unicode_normal_form NORMALIZED %prec IS
   11715             :  { 
   11716           0 :  $$ = cat_str(4,$1,mm_strdup("is"),$3,mm_strdup("normalized"));
   11717             : }
   11718             : |  a_expr IS NOT NORMALIZED %prec IS
   11719             :  { 
   11720           0 :  $$ = cat_str(2,$1,mm_strdup("is not normalized"));
   11721             : }
   11722             : |  a_expr IS NOT unicode_normal_form NORMALIZED %prec IS
   11723             :  { 
   11724           0 :  $$ = cat_str(4,$1,mm_strdup("is not"),$4,mm_strdup("normalized"));
   11725             : }
   11726             : |  DEFAULT
   11727             :  { 
   11728          32 :  $$ = mm_strdup("default");
   11729             : }
   11730             : ;
   11731             : 
   11732             : 
   11733             :  b_expr:
   11734             :  c_expr
   11735             :  { 
   11736           4 :  $$ = $1;
   11737             : }
   11738             : |  b_expr TYPECAST Typename
   11739             :  { 
   11740           0 :  $$ = cat_str(3,$1,mm_strdup("::"),$3);
   11741             : }
   11742             : |  '+' b_expr %prec UMINUS
   11743             :  { 
   11744           0 :  $$ = cat_str(2,mm_strdup("+"),$2);
   11745             : }
   11746             : |  '-' b_expr %prec UMINUS
   11747             :  { 
   11748           0 :  $$ = cat_str(2,mm_strdup("-"),$2);
   11749             : }
   11750             : |  b_expr '+' b_expr
   11751             :  { 
   11752           0 :  $$ = cat_str(3,$1,mm_strdup("+"),$3);
   11753             : }
   11754             : |  b_expr '-' b_expr
   11755             :  { 
   11756           0 :  $$ = cat_str(3,$1,mm_strdup("-"),$3);
   11757             : }
   11758             : |  b_expr '*' b_expr
   11759             :  { 
   11760           0 :  $$ = cat_str(3,$1,mm_strdup("*"),$3);
   11761             : }
   11762             : |  b_expr '/' b_expr
   11763             :  { 
   11764           0 :  $$ = cat_str(3,$1,mm_strdup("/"),$3);
   11765             : }
   11766             : |  b_expr '%' b_expr
   11767             :  { 
   11768           0 :  $$ = cat_str(3,$1,mm_strdup("%"),$3);
   11769             : }
   11770             : |  b_expr '^' b_expr
   11771             :  { 
   11772           0 :  $$ = cat_str(3,$1,mm_strdup("^"),$3);
   11773             : }
   11774             : |  b_expr '<' b_expr
   11775             :  { 
   11776           0 :  $$ = cat_str(3,$1,mm_strdup("<"),$3);
   11777             : }
   11778             : |  b_expr '>' b_expr
   11779             :  { 
   11780           0 :  $$ = cat_str(3,$1,mm_strdup(">"),$3);
   11781             : }
   11782             : |  b_expr '=' b_expr
   11783             :  { 
   11784           0 :  $$ = cat_str(3,$1,mm_strdup("="),$3);
   11785             : }
   11786             : |  b_expr LESS_EQUALS b_expr
   11787             :  { 
   11788           0 :  $$ = cat_str(3,$1,mm_strdup("<="),$3);
   11789             : }
   11790             : |  b_expr GREATER_EQUALS b_expr
   11791             :  { 
   11792           0 :  $$ = cat_str(3,$1,mm_strdup(">="),$3);
   11793             : }
   11794             : |  b_expr NOT_EQUALS b_expr
   11795             :  { 
   11796           0 :  $$ = cat_str(3,$1,mm_strdup("<>"),$3);
   11797             : }
   11798             : |  b_expr qual_Op b_expr %prec Op
   11799             :  { 
   11800           0 :  $$ = cat_str(3,$1,$2,$3);
   11801             : }
   11802             : |  qual_Op b_expr %prec Op
   11803             :  { 
   11804           0 :  $$ = cat_str(2,$1,$2);
   11805             : }
   11806             : |  b_expr IS DISTINCT FROM b_expr %prec IS
   11807             :  { 
   11808           0 :  $$ = cat_str(3,$1,mm_strdup("is distinct from"),$5);
   11809             : }
   11810             : |  b_expr IS NOT DISTINCT FROM b_expr %prec IS
   11811             :  { 
   11812           0 :  $$ = cat_str(3,$1,mm_strdup("is not distinct from"),$6);
   11813             : }
   11814             : |  b_expr IS DOCUMENT_P %prec IS
   11815             :  { 
   11816           0 :  $$ = cat_str(2,$1,mm_strdup("is document"));
   11817             : }
   11818             : |  b_expr IS NOT DOCUMENT_P %prec IS
   11819             :  { 
   11820           0 :  $$ = cat_str(2,$1,mm_strdup("is not document"));
   11821             : }
   11822             : ;
   11823             : 
   11824             : 
   11825             :  c_expr:
   11826             :  columnref
   11827             :  { 
   11828         294 :  $$ = $1;
   11829             : }
   11830             : |  AexprConst
   11831             :  { 
   11832         840 :  $$ = $1;
   11833             : }
   11834             : |  ecpg_param opt_indirection
   11835             :  { 
   11836          22 :  $$ = cat_str(2,$1,$2);
   11837             : }
   11838             : |  '(' a_expr ')' opt_indirection
   11839             :  { 
   11840           0 :  $$ = cat_str(4,mm_strdup("("),$2,mm_strdup(")"),$4);
   11841             : }
   11842             : |  case_expr
   11843             :  { 
   11844           0 :  $$ = $1;
   11845             : }
   11846             : |  func_expr
   11847             :  { 
   11848          44 :  $$ = $1;
   11849             : }
   11850             : |  select_with_parens %prec UMINUS
   11851             :  { 
   11852           4 :  $$ = $1;
   11853             : }
   11854             : |  select_with_parens indirection
   11855             :  { 
   11856           0 :  $$ = cat_str(2,$1,$2);
   11857             : }
   11858             : |  EXISTS select_with_parens
   11859             :  { 
   11860           0 :  $$ = cat_str(2,mm_strdup("exists"),$2);
   11861             : }
   11862             : |  ARRAY select_with_parens
   11863             :  { 
   11864           0 :  $$ = cat_str(2,mm_strdup("array"),$2);
   11865             : }
   11866             : |  ARRAY array_expr
   11867             :  { 
   11868           0 :  $$ = cat_str(2,mm_strdup("array"),$2);
   11869             : }
   11870             : |  explicit_row
   11871             :  { 
   11872           0 :  $$ = $1;
   11873             : }
   11874             : |  implicit_row
   11875             :  { 
   11876           2 :  $$ = $1;
   11877             : }
   11878             : |  GROUPING '(' expr_list ')'
   11879             :  { 
   11880           0 :  $$ = cat_str(3,mm_strdup("grouping ("),$3,mm_strdup(")"));
   11881             : }
   11882             : ;
   11883             : 
   11884             : 
   11885             :  func_application:
   11886             :  func_name '(' ')'
   11887             :  { 
   11888          30 :  $$ = cat_str(2,$1,mm_strdup("( )"));
   11889             : }
   11890             : |  func_name '(' func_arg_list opt_sort_clause ')'
   11891             :  { 
   11892           6 :  $$ = cat_str(5,$1,mm_strdup("("),$3,$4,mm_strdup(")"));
   11893             : }
   11894             : |  func_name '(' VARIADIC func_arg_expr opt_sort_clause ')'
   11895             :  { 
   11896           0 :  $$ = cat_str(5,$1,mm_strdup("( variadic"),$4,$5,mm_strdup(")"));
   11897             : }
   11898             : |  func_name '(' func_arg_list ',' VARIADIC func_arg_expr opt_sort_clause ')'
   11899             :  { 
   11900           0 :  $$ = cat_str(7,$1,mm_strdup("("),$3,mm_strdup(", variadic"),$6,$7,mm_strdup(")"));
   11901             : }
   11902             : |  func_name '(' ALL func_arg_list opt_sort_clause ')'
   11903             :  { 
   11904           0 :  $$ = cat_str(5,$1,mm_strdup("( all"),$4,$5,mm_strdup(")"));
   11905             : }
   11906             : |  func_name '(' DISTINCT func_arg_list opt_sort_clause ')'
   11907             :  { 
   11908           0 :  $$ = cat_str(5,$1,mm_strdup("( distinct"),$4,$5,mm_strdup(")"));
   11909             : }
   11910             : |  func_name '(' '*' ')'
   11911             :  { 
   11912           4 :  $$ = cat_str(2,$1,mm_strdup("( * )"));
   11913             : }
   11914             : ;
   11915             : 
   11916             : 
   11917             :  func_expr:
   11918             :  func_application within_group_clause filter_clause over_clause
   11919             :  { 
   11920          38 :  $$ = cat_str(4,$1,$2,$3,$4);
   11921             : }
   11922             : |  func_expr_common_subexpr
   11923             :  { 
   11924           6 :  $$ = $1;
   11925             : }
   11926             : ;
   11927             : 
   11928             : 
   11929             :  func_expr_windowless:
   11930             :  func_application
   11931             :  { 
   11932           2 :  $$ = $1;
   11933             : }
   11934             : |  func_expr_common_subexpr
   11935             :  { 
   11936           0 :  $$ = $1;
   11937             : }
   11938             : ;
   11939             : 
   11940             : 
   11941             :  func_expr_common_subexpr:
   11942             :  COLLATION FOR '(' a_expr ')'
   11943             :  { 
   11944           0 :  $$ = cat_str(3,mm_strdup("collation for ("),$4,mm_strdup(")"));
   11945             : }
   11946             : |  CURRENT_DATE
   11947             :  { 
   11948           0 :  $$ = mm_strdup("current_date");
   11949             : }
   11950             : |  CURRENT_TIME
   11951             :  { 
   11952           0 :  $$ = mm_strdup("current_time");
   11953             : }
   11954             : |  CURRENT_TIME '(' Iconst ')'
   11955             :  { 
   11956           0 :  $$ = cat_str(3,mm_strdup("current_time ("),$3,mm_strdup(")"));
   11957             : }
   11958             : |  CURRENT_TIMESTAMP
   11959             :  { 
   11960           0 :  $$ = mm_strdup("current_timestamp");
   11961             : }
   11962             : |  CURRENT_TIMESTAMP '(' Iconst ')'
   11963             :  { 
   11964           0 :  $$ = cat_str(3,mm_strdup("current_timestamp ("),$3,mm_strdup(")"));
   11965             : }
   11966             : |  LOCALTIME
   11967             :  { 
   11968           0 :  $$ = mm_strdup("localtime");
   11969             : }
   11970             : |  LOCALTIME '(' Iconst ')'
   11971             :  { 
   11972           0 :  $$ = cat_str(3,mm_strdup("localtime ("),$3,mm_strdup(")"));
   11973             : }
   11974             : |  LOCALTIMESTAMP
   11975             :  { 
   11976           0 :  $$ = mm_strdup("localtimestamp");
   11977             : }
   11978             : |  LOCALTIMESTAMP '(' Iconst ')'
   11979             :  { 
   11980           0 :  $$ = cat_str(3,mm_strdup("localtimestamp ("),$3,mm_strdup(")"));
   11981             : }
   11982             : |  CURRENT_ROLE
   11983             :  { 
   11984           0 :  $$ = mm_strdup("current_role");
   11985             : }
   11986             : |  CURRENT_USER
   11987             :  { 
   11988           0 :  $$ = mm_strdup("current_user");
   11989             : }
   11990             : |  SESSION_USER
   11991             :  { 
   11992           0 :  $$ = mm_strdup("session_user");
   11993             : }
   11994             : |  USER
   11995             :  { 
   11996           0 :  $$ = mm_strdup("user");
   11997             : }
   11998             : |  CURRENT_CATALOG
   11999             :  { 
   12000           0 :  $$ = mm_strdup("current_catalog");
   12001             : }
   12002             : |  CURRENT_SCHEMA
   12003             :  { 
   12004           0 :  $$ = mm_strdup("current_schema");
   12005             : }
   12006             : |  CAST '(' a_expr AS Typename ')'
   12007             :  { 
   12008           4 :  $$ = cat_str(5,mm_strdup("cast ("),$3,mm_strdup("as"),$5,mm_strdup(")"));
   12009             : }
   12010             : |  EXTRACT '(' extract_list ')'
   12011             :  { 
   12012           0 :  $$ = cat_str(3,mm_strdup("extract ("),$3,mm_strdup(")"));
   12013             : }
   12014             : |  NORMALIZE '(' a_expr ')'
   12015             :  { 
   12016           0 :  $$ = cat_str(3,mm_strdup("normalize ("),$3,mm_strdup(")"));
   12017             : }
   12018             : |  NORMALIZE '(' a_expr ',' unicode_normal_form ')'
   12019             :  { 
   12020           0 :  $$ = cat_str(5,mm_strdup("normalize ("),$3,mm_strdup(","),$5,mm_strdup(")"));
   12021             : }
   12022             : |  OVERLAY '(' overlay_list ')'
   12023             :  { 
   12024           0 :  $$ = cat_str(3,mm_strdup("overlay ("),$3,mm_strdup(")"));
   12025             : }
   12026             : |  OVERLAY '(' func_arg_list_opt ')'
   12027             :  { 
   12028           0 :  $$ = cat_str(3,mm_strdup("overlay ("),$3,mm_strdup(")"));
   12029             : }
   12030             : |  POSITION '(' position_list ')'
   12031             :  { 
   12032           0 :  $$ = cat_str(3,mm_strdup("position ("),$3,mm_strdup(")"));
   12033             : }
   12034             : |  SUBSTRING '(' substr_list ')'
   12035             :  { 
   12036           0 :  $$ = cat_str(3,mm_strdup("substring ("),$3,mm_strdup(")"));
   12037             : }
   12038             : |  SUBSTRING '(' func_arg_list_opt ')'
   12039             :  { 
   12040           0 :  $$ = cat_str(3,mm_strdup("substring ("),$3,mm_strdup(")"));
   12041             : }
   12042             : |  TREAT '(' a_expr AS Typename ')'
   12043             :  { 
   12044           0 :  $$ = cat_str(5,mm_strdup("treat ("),$3,mm_strdup("as"),$5,mm_strdup(")"));
   12045             : }
   12046             : |  TRIM '(' BOTH trim_list ')'
   12047             :  { 
   12048           0 :  $$ = cat_str(3,mm_strdup("trim ( both"),$4,mm_strdup(")"));
   12049             : }
   12050             : |  TRIM '(' LEADING trim_list ')'
   12051             :  { 
   12052           0 :  $$ = cat_str(3,mm_strdup("trim ( leading"),$4,mm_strdup(")"));
   12053             : }
   12054             : |  TRIM '(' TRAILING trim_list ')'
   12055             :  { 
   12056           0 :  $$ = cat_str(3,mm_strdup("trim ( trailing"),$4,mm_strdup(")"));
   12057             : }
   12058             : |  TRIM '(' trim_list ')'
   12059             :  { 
   12060           0 :  $$ = cat_str(3,mm_strdup("trim ("),$3,mm_strdup(")"));
   12061             : }
   12062             : |  NULLIF '(' a_expr ',' a_expr ')'
   12063             :  { 
   12064           2 :  $$ = cat_str(5,mm_strdup("nullif ("),$3,mm_strdup(","),$5,mm_strdup(")"));
   12065             : }
   12066             : |  COALESCE '(' expr_list ')'
   12067             :  { 
   12068           0 :  $$ = cat_str(3,mm_strdup("coalesce ("),$3,mm_strdup(")"));
   12069             : }
   12070             : |  GREATEST '(' expr_list ')'
   12071             :  { 
   12072           0 :  $$ = cat_str(3,mm_strdup("greatest ("),$3,mm_strdup(")"));
   12073             : }
   12074             : |  LEAST '(' expr_list ')'
   12075             :  { 
   12076           0 :  $$ = cat_str(3,mm_strdup("least ("),$3,mm_strdup(")"));
   12077             : }
   12078             : |  XMLCONCAT '(' expr_list ')'
   12079             :  { 
   12080           0 :  $$ = cat_str(3,mm_strdup("xmlconcat ("),$3,mm_strdup(")"));
   12081             : }
   12082             : |  XMLELEMENT '(' NAME_P ColLabel ')'
   12083             :  { 
   12084           0 :  $$ = cat_str(3,mm_strdup("xmlelement ( name"),$4,mm_strdup(")"));
   12085             : }
   12086             : |  XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ')'
   12087             :  { 
   12088           0 :  $$ = cat_str(5,mm_strdup("xmlelement ( name"),$4,mm_strdup(","),$6,mm_strdup(")"));
   12089             : }
   12090             : |  XMLELEMENT '(' NAME_P ColLabel ',' expr_list ')'
   12091             :  { 
   12092           0 :  $$ = cat_str(5,mm_strdup("xmlelement ( name"),$4,mm_strdup(","),$6,mm_strdup(")"));
   12093             : }
   12094             : |  XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
   12095             :  { 
   12096           0 :  $$ = cat_str(7,mm_strdup("xmlelement ( name"),$4,mm_strdup(","),$6,mm_strdup(","),$8,mm_strdup(")"));
   12097             : }
   12098             : |  XMLEXISTS '(' c_expr xmlexists_argument ')'
   12099             :  { 
   12100           0 :  $$ = cat_str(4,mm_strdup("xmlexists ("),$3,$4,mm_strdup(")"));
   12101             : }
   12102             : |  XMLFOREST '(' xml_attribute_list ')'
   12103             :  { 
   12104           0 :  $$ = cat_str(3,mm_strdup("xmlforest ("),$3,mm_strdup(")"));
   12105             : }
   12106             : |  XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
   12107             :  { 
   12108           0 :  $$ = cat_str(5,mm_strdup("xmlparse ("),$3,$4,$5,mm_strdup(")"));
   12109             : }
   12110             : |  XMLPI '(' NAME_P ColLabel ')'
   12111             :  { 
   12112           0 :  $$ = cat_str(3,mm_strdup("xmlpi ( name"),$4,mm_strdup(")"));
   12113             : }
   12114             : |  XMLPI '(' NAME_P ColLabel ',' a_expr ')'
   12115             :  { 
   12116           0 :  $$ = cat_str(5,mm_strdup("xmlpi ( name"),$4,mm_strdup(","),$6,mm_strdup(")"));
   12117             : }
   12118             : |  XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
   12119             :  { 
   12120           0 :  $$ = cat_str(6,mm_strdup("xmlroot ("),$3,mm_strdup(","),$5,$6,mm_strdup(")"));
   12121             : }
   12122             : |  XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename ')'
   12123             :  { 
   12124           0 :  $$ = cat_str(6,mm_strdup("xmlserialize ("),$3,$4,mm_strdup("as"),$6,mm_strdup(")"));
   12125             : }
   12126             : ;
   12127             : 
   12128             : 
   12129             :  xml_root_version:
   12130             :  VERSION_P a_expr
   12131             :  { 
   12132           0 :  $$ = cat_str(2,mm_strdup("version"),$2);
   12133             : }
   12134             : |  VERSION_P NO VALUE_P
   12135             :  { 
   12136           0 :  $$ = mm_strdup("version no value");
   12137             : }
   12138             : ;
   12139             : 
   12140             : 
   12141             :  opt_xml_root_standalone:
   12142             :  ',' STANDALONE_P YES_P
   12143             :  { 
   12144           0 :  $$ = mm_strdup(", standalone yes");
   12145             : }
   12146             : |  ',' STANDALONE_P NO
   12147             :  { 
   12148           0 :  $$ = mm_strdup(", standalone no");
   12149             : }
   12150             : |  ',' STANDALONE_P NO VALUE_P
   12151             :  { 
   12152           0 :  $$ = mm_strdup(", standalone no value");
   12153             : }
   12154             : | 
   12155             :  { 
   12156           0 :  $$=EMPTY; }
   12157             : ;
   12158             : 
   12159             : 
   12160             :  xml_attributes:
   12161             :  XMLATTRIBUTES '(' xml_attribute_list ')'
   12162             :  { 
   12163           0 :  $$ = cat_str(3,mm_strdup("xmlattributes ("),$3,mm_strdup(")"));
   12164             : }
   12165             : ;
   12166             : 
   12167             : 
   12168             :  xml_attribute_list:
   12169             :  xml_attribute_el
   12170             :  { 
   12171           0 :  $$ = $1;
   12172             : }
   12173             : |  xml_attribute_list ',' xml_attribute_el
   12174             :  { 
   12175           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12176             : }
   12177             : ;
   12178             : 
   12179             : 
   12180             :  xml_attribute_el:
   12181             :  a_expr AS ColLabel
   12182             :  { 
   12183           0 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
   12184             : }
   12185             : |  a_expr
   12186             :  { 
   12187           0 :  $$ = $1;
   12188             : }
   12189             : ;
   12190             : 
   12191             : 
   12192             :  document_or_content:
   12193             :  DOCUMENT_P
   12194             :  { 
   12195           0 :  $$ = mm_strdup("document");
   12196             : }
   12197             : |  CONTENT_P
   12198             :  { 
   12199           0 :  $$ = mm_strdup("content");
   12200             : }
   12201             : ;
   12202             : 
   12203             : 
   12204             :  xml_whitespace_option:
   12205             :  PRESERVE WHITESPACE_P
   12206             :  { 
   12207           0 :  $$ = mm_strdup("preserve whitespace");
   12208             : }
   12209             : |  STRIP_P WHITESPACE_P
   12210             :  { 
   12211           0 :  $$ = mm_strdup("strip whitespace");
   12212             : }
   12213             : | 
   12214             :  { 
   12215           0 :  $$=EMPTY; }
   12216             : ;
   12217             : 
   12218             : 
   12219             :  xmlexists_argument:
   12220             :  PASSING c_expr
   12221             :  { 
   12222           0 :  $$ = cat_str(2,mm_strdup("passing"),$2);
   12223             : }
   12224             : |  PASSING c_expr xml_passing_mech
   12225             :  { 
   12226           0 :  $$ = cat_str(3,mm_strdup("passing"),$2,$3);
   12227             : }
   12228             : |  PASSING xml_passing_mech c_expr
   12229             :  { 
   12230           0 :  $$ = cat_str(3,mm_strdup("passing"),$2,$3);
   12231             : }
   12232             : |  PASSING xml_passing_mech c_expr xml_passing_mech
   12233             :  { 
   12234           0 :  $$ = cat_str(4,mm_strdup("passing"),$2,$3,$4);
   12235             : }
   12236             : ;
   12237             : 
   12238             : 
   12239             :  xml_passing_mech:
   12240             :  BY REF
   12241             :  { 
   12242           0 :  $$ = mm_strdup("by ref");
   12243             : }
   12244             : |  BY VALUE_P
   12245             :  { 
   12246           0 :  $$ = mm_strdup("by value");
   12247             : }
   12248             : ;
   12249             : 
   12250             : 
   12251             :  within_group_clause:
   12252             :  WITHIN GROUP_P '(' sort_clause ')'
   12253             :  { 
   12254           0 :  $$ = cat_str(3,mm_strdup("within group ("),$4,mm_strdup(")"));
   12255             : }
   12256             : | 
   12257             :  { 
   12258          38 :  $$=EMPTY; }
   12259             : ;
   12260             : 
   12261             : 
   12262             :  filter_clause:
   12263             :  FILTER '(' WHERE a_expr ')'
   12264             :  { 
   12265           0 :  $$ = cat_str(3,mm_strdup("filter ( where"),$4,mm_strdup(")"));
   12266             : }
   12267             : | 
   12268             :  { 
   12269          38 :  $$=EMPTY; }
   12270             : ;
   12271             : 
   12272             : 
   12273             :  window_clause:
   12274             :  WINDOW window_definition_list
   12275             :  { 
   12276           0 :  $$ = cat_str(2,mm_strdup("window"),$2);
   12277             : }
   12278             : | 
   12279             :  { 
   12280         182 :  $$=EMPTY; }
   12281             : ;
   12282             : 
   12283             : 
   12284             :  window_definition_list:
   12285             :  window_definition
   12286             :  { 
   12287           0 :  $$ = $1;
   12288             : }
   12289             : |  window_definition_list ',' window_definition
   12290             :  { 
   12291           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12292             : }
   12293             : ;
   12294             : 
   12295             : 
   12296             :  window_definition:
   12297             :  ColId AS window_specification
   12298             :  { 
   12299           0 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
   12300             : }
   12301             : ;
   12302             : 
   12303             : 
   12304             :  over_clause:
   12305             :  OVER window_specification
   12306             :  { 
   12307           0 :  $$ = cat_str(2,mm_strdup("over"),$2);
   12308             : }
   12309             : |  OVER ColId
   12310             :  { 
   12311           0 :  $$ = cat_str(2,mm_strdup("over"),$2);
   12312             : }
   12313             : | 
   12314             :  { 
   12315          38 :  $$=EMPTY; }
   12316             : ;
   12317             : 
   12318             : 
   12319             :  window_specification:
   12320             :  '(' opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause ')'
   12321             :  { 
   12322           0 :  $$ = cat_str(6,mm_strdup("("),$2,$3,$4,$5,mm_strdup(")"));
   12323             : }
   12324             : ;
   12325             : 
   12326             : 
   12327             :  opt_existing_window_name:
   12328             :  ColId
   12329             :  { 
   12330           0 :  $$ = $1;
   12331             : }
   12332             : |  %prec Op
   12333             :  { 
   12334           0 :  $$=EMPTY; }
   12335             : ;
   12336             : 
   12337             : 
   12338             :  opt_partition_clause:
   12339             :  PARTITION BY expr_list
   12340             :  { 
   12341           0 :  $$ = cat_str(2,mm_strdup("partition by"),$3);
   12342             : }
   12343             : | 
   12344             :  { 
   12345           0 :  $$=EMPTY; }
   12346             : ;
   12347             : 
   12348             : 
   12349             :  opt_frame_clause:
   12350             :  RANGE frame_extent opt_window_exclusion_clause
   12351             :  { 
   12352           0 :  $$ = cat_str(3,mm_strdup("range"),$2,$3);
   12353             : }
   12354             : |  ROWS frame_extent opt_window_exclusion_clause
   12355             :  { 
   12356           0 :  $$ = cat_str(3,mm_strdup("rows"),$2,$3);
   12357             : }
   12358             : |  GROUPS frame_extent opt_window_exclusion_clause
   12359             :  { 
   12360           0 :  $$ = cat_str(3,mm_strdup("groups"),$2,$3);
   12361             : }
   12362             : | 
   12363             :  { 
   12364           0 :  $$=EMPTY; }
   12365             : ;
   12366             : 
   12367             : 
   12368             :  frame_extent:
   12369             :  frame_bound
   12370             :  { 
   12371           0 :  $$ = $1;
   12372             : }
   12373             : |  BETWEEN frame_bound AND frame_bound
   12374             :  { 
   12375           0 :  $$ = cat_str(4,mm_strdup("between"),$2,mm_strdup("and"),$4);
   12376             : }
   12377             : ;
   12378             : 
   12379             : 
   12380             :  frame_bound:
   12381             :  UNBOUNDED PRECEDING
   12382             :  { 
   12383           0 :  $$ = mm_strdup("unbounded preceding");
   12384             : }
   12385             : |  UNBOUNDED FOLLOWING
   12386             :  { 
   12387           0 :  $$ = mm_strdup("unbounded following");
   12388             : }
   12389             : |  CURRENT_P ROW
   12390             :  { 
   12391           0 :  $$ = mm_strdup("current row");
   12392             : }
   12393             : |  a_expr PRECEDING
   12394             :  { 
   12395           0 :  $$ = cat_str(2,$1,mm_strdup("preceding"));
   12396             : }
   12397             : |  a_expr FOLLOWING
   12398             :  { 
   12399           0 :  $$ = cat_str(2,$1,mm_strdup("following"));
   12400             : }
   12401             : ;
   12402             : 
   12403             : 
   12404             :  opt_window_exclusion_clause:
   12405             :  EXCLUDE CURRENT_P ROW
   12406             :  { 
   12407           0 :  $$ = mm_strdup("exclude current row");
   12408             : }
   12409             : |  EXCLUDE GROUP_P
   12410             :  { 
   12411           0 :  $$ = mm_strdup("exclude group");
   12412             : }
   12413             : |  EXCLUDE TIES
   12414             :  { 
   12415           0 :  $$ = mm_strdup("exclude ties");
   12416             : }
   12417             : |  EXCLUDE NO OTHERS
   12418             :  { 
   12419           0 :  $$ = mm_strdup("exclude no others");
   12420             : }
   12421             : | 
   12422             :  { 
   12423           0 :  $$=EMPTY; }
   12424             : ;
   12425             : 
   12426             : 
   12427             :  row:
   12428             :  ROW '(' expr_list ')'
   12429             :  { 
   12430           0 :  $$ = cat_str(3,mm_strdup("row ("),$3,mm_strdup(")"));
   12431             : }
   12432             : |  ROW '(' ')'
   12433             :  { 
   12434           0 :  $$ = mm_strdup("row ( )");
   12435             : }
   12436             : |  '(' expr_list ',' a_expr ')'
   12437             :  { 
   12438           0 :  $$ = cat_str(5,mm_strdup("("),$2,mm_strdup(","),$4,mm_strdup(")"));
   12439             : }
   12440             : ;
   12441             : 
   12442             : 
   12443             :  explicit_row:
   12444             :  ROW '(' expr_list ')'
   12445             :  { 
   12446           0 :  $$ = cat_str(3,mm_strdup("row ("),$3,mm_strdup(")"));
   12447             : }
   12448             : |  ROW '(' ')'
   12449             :  { 
   12450           0 :  $$ = mm_strdup("row ( )");
   12451             : }
   12452             : ;
   12453             : 
   12454             : 
   12455             :  implicit_row:
   12456             :  '(' expr_list ',' a_expr ')'
   12457             :  { 
   12458           2 :  $$ = cat_str(5,mm_strdup("("),$2,mm_strdup(","),$4,mm_strdup(")"));
   12459             : }
   12460             : ;
   12461             : 
   12462             : 
   12463             :  sub_type:
   12464             :  ANY
   12465             :  { 
   12466           0 :  $$ = mm_strdup("any");
   12467             : }
   12468             : |  SOME
   12469             :  { 
   12470           0 :  $$ = mm_strdup("some");
   12471             : }
   12472             : |  ALL
   12473             :  { 
   12474           0 :  $$ = mm_strdup("all");
   12475             : }
   12476             : ;
   12477             : 
   12478             : 
   12479             :  all_Op:
   12480             :  Op
   12481             :  { 
   12482           0 :  $$ = $1;
   12483             : }
   12484             : |  MathOp
   12485             :  { 
   12486           0 :  $$ = $1;
   12487             : }
   12488             : ;
   12489             : 
   12490             : 
   12491             :  MathOp:
   12492             :  '+'
   12493             :  { 
   12494           0 :  $$ = mm_strdup("+");
   12495             : }
   12496             : |  '-'
   12497             :  { 
   12498           0 :  $$ = mm_strdup("-");
   12499             : }
   12500             : |  '*'
   12501             :  { 
   12502           0 :  $$ = mm_strdup("*");
   12503             : }
   12504             : |  '/'
   12505             :  { 
   12506           0 :  $$ = mm_strdup("/");
   12507             : }
   12508             : |  '%'
   12509             :  { 
   12510           0 :  $$ = mm_strdup("%");
   12511             : }
   12512             : |  '^'
   12513             :  { 
   12514           0 :  $$ = mm_strdup("^");
   12515             : }
   12516             : |  '<'
   12517             :  { 
   12518           0 :  $$ = mm_strdup("<");
   12519             : }
   12520             : |  '>'
   12521             :  { 
   12522           0 :  $$ = mm_strdup(">");
   12523             : }
   12524             : |  '='
   12525             :  { 
   12526           0 :  $$ = mm_strdup("=");
   12527             : }
   12528             : |  LESS_EQUALS
   12529             :  { 
   12530           0 :  $$ = mm_strdup("<=");
   12531             : }
   12532             : |  GREATER_EQUALS
   12533             :  { 
   12534           0 :  $$ = mm_strdup(">=");
   12535             : }
   12536             : |  NOT_EQUALS
   12537             :  { 
   12538           0 :  $$ = mm_strdup("<>");
   12539             : }
   12540             : ;
   12541             : 
   12542             : 
   12543             :  qual_Op:
   12544             :  Op
   12545             :  { 
   12546           4 :  $$ = $1;
   12547             : }
   12548             : |  OPERATOR '(' any_operator ')'
   12549             :  { 
   12550           0 :  $$ = cat_str(3,mm_strdup("operator ("),$3,mm_strdup(")"));
   12551             : }
   12552             : ;
   12553             : 
   12554             : 
   12555             :  qual_all_Op:
   12556             :  all_Op
   12557             :  { 
   12558           0 :  $$ = $1;
   12559             : }
   12560             : |  OPERATOR '(' any_operator ')'
   12561             :  { 
   12562           0 :  $$ = cat_str(3,mm_strdup("operator ("),$3,mm_strdup(")"));
   12563             : }
   12564             : ;
   12565             : 
   12566             : 
   12567             :  subquery_Op:
   12568             :  all_Op
   12569             :  { 
   12570           0 :  $$ = $1;
   12571             : }
   12572             : |  OPERATOR '(' any_operator ')'
   12573             :  { 
   12574           0 :  $$ = cat_str(3,mm_strdup("operator ("),$3,mm_strdup(")"));
   12575             : }
   12576             : |  LIKE
   12577             :  { 
   12578           0 :  $$ = mm_strdup("like");
   12579             : }
   12580             : |  NOT_LA LIKE
   12581             :  { 
   12582           0 :  $$ = mm_strdup("not like");
   12583             : }
   12584             : |  ILIKE
   12585             :  { 
   12586           0 :  $$ = mm_strdup("ilike");
   12587             : }
   12588             : |  NOT_LA ILIKE
   12589             :  { 
   12590           0 :  $$ = mm_strdup("not ilike");
   12591             : }
   12592             : ;
   12593             : 
   12594             : 
   12595             :  expr_list:
   12596             :  a_expr
   12597             :  { 
   12598         266 :  $$ = $1;
   12599             : }
   12600             : |  expr_list ',' a_expr
   12601             :  { 
   12602         482 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12603             : }
   12604             : ;
   12605             : 
   12606             : 
   12607             :  func_arg_list:
   12608             :  func_arg_expr
   12609             :  { 
   12610           6 :  $$ = $1;
   12611             : }
   12612             : |  func_arg_list ',' func_arg_expr
   12613             :  { 
   12614           2 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12615             : }
   12616             : ;
   12617             : 
   12618             : 
   12619             :  func_arg_expr:
   12620             :  a_expr
   12621             :  { 
   12622           8 :  $$ = $1;
   12623             : }
   12624             : |  param_name COLON_EQUALS a_expr
   12625             :  { 
   12626           0 :  $$ = cat_str(3,$1,mm_strdup(":="),$3);
   12627             : }
   12628             : |  param_name EQUALS_GREATER a_expr
   12629             :  { 
   12630           0 :  $$ = cat_str(3,$1,mm_strdup("=>"),$3);
   12631             : }
   12632             : ;
   12633             : 
   12634             : 
   12635             :  func_arg_list_opt:
   12636             :  func_arg_list
   12637             :  { 
   12638           0 :  $$ = $1;
   12639             : }
   12640             : | 
   12641             :  { 
   12642           0 :  $$=EMPTY; }
   12643             : ;
   12644             : 
   12645             : 
   12646             :  type_list:
   12647             :  Typename
   12648             :  { 
   12649          10 :  $$ = $1;
   12650             : }
   12651             : |  type_list ',' Typename
   12652             :  { 
   12653          10 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12654             : }
   12655             : ;
   12656             : 
   12657             : 
   12658             :  array_expr:
   12659             :  '[' expr_list ']'
   12660             :  { 
   12661           0 :  $$ = cat_str(3,mm_strdup("["),$2,mm_strdup("]"));
   12662             : }
   12663             : |  '[' array_expr_list ']'
   12664             :  { 
   12665           0 :  $$ = cat_str(3,mm_strdup("["),$2,mm_strdup("]"));
   12666             : }
   12667             : |  '[' ']'
   12668             :  { 
   12669           0 :  $$ = mm_strdup("[ ]");
   12670             : }
   12671             : ;
   12672             : 
   12673             : 
   12674             :  array_expr_list:
   12675             :  array_expr
   12676             :  { 
   12677           0 :  $$ = $1;
   12678             : }
   12679             : |  array_expr_list ',' array_expr
   12680             :  { 
   12681           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12682             : }
   12683             : ;
   12684             : 
   12685             : 
   12686             :  extract_list:
   12687             :  extract_arg FROM a_expr
   12688             :  { 
   12689           0 :  $$ = cat_str(3,$1,mm_strdup("from"),$3);
   12690             : }
   12691             : ;
   12692             : 
   12693             : 
   12694             :  extract_arg:
   12695             :  ecpg_ident
   12696             :  { 
   12697           0 :  $$ = $1;
   12698             : }
   12699             : |  YEAR_P
   12700             :  { 
   12701           0 :  $$ = mm_strdup("year");
   12702             : }
   12703             : |  MONTH_P
   12704             :  { 
   12705           0 :  $$ = mm_strdup("month");
   12706             : }
   12707             : |  DAY_P
   12708             :  { 
   12709           0 :  $$ = mm_strdup("day");
   12710             : }
   12711             : |  HOUR_P
   12712             :  { 
   12713           0 :  $$ = mm_strdup("hour");
   12714             : }
   12715             : |  MINUTE_P
   12716             :  { 
   12717           0 :  $$ = mm_strdup("minute");
   12718             : }
   12719             : |  SECOND_P
   12720             :  { 
   12721           0 :  $$ = mm_strdup("second");
   12722             : }
   12723             : |  ecpg_sconst
   12724             :  { 
   12725           0 :  $$ = $1;
   12726             : }
   12727             : ;
   12728             : 
   12729             : 
   12730             :  unicode_normal_form:
   12731             :  NFC
   12732             :  { 
   12733           0 :  $$ = mm_strdup("nfc");
   12734             : }
   12735             : |  NFD
   12736             :  { 
   12737           0 :  $$ = mm_strdup("nfd");
   12738             : }
   12739             : |  NFKC
   12740             :  { 
   12741           0 :  $$ = mm_strdup("nfkc");
   12742             : }
   12743             : |  NFKD
   12744             :  { 
   12745           0 :  $$ = mm_strdup("nfkd");
   12746             : }
   12747             : ;
   12748             : 
   12749             : 
   12750             :  overlay_list:
   12751             :  a_expr PLACING a_expr FROM a_expr FOR a_expr
   12752             :  { 
   12753           0 :  $$ = cat_str(7,$1,mm_strdup("placing"),$3,mm_strdup("from"),$5,mm_strdup("for"),$7);
   12754             : }
   12755             : |  a_expr PLACING a_expr FROM a_expr
   12756             :  { 
   12757           0 :  $$ = cat_str(5,$1,mm_strdup("placing"),$3,mm_strdup("from"),$5);
   12758             : }
   12759             : ;
   12760             : 
   12761             : 
   12762             :  position_list:
   12763             :  b_expr IN_P b_expr
   12764             :  { 
   12765           0 :  $$ = cat_str(3,$1,mm_strdup("in"),$3);
   12766             : }
   12767             : ;
   12768             : 
   12769             : 
   12770             :  substr_list:
   12771             :  a_expr FROM a_expr FOR a_expr
   12772             :  { 
   12773           0 :  $$ = cat_str(5,$1,mm_strdup("from"),$3,mm_strdup("for"),$5);
   12774             : }
   12775             : |  a_expr FOR a_expr FROM a_expr
   12776             :  { 
   12777           0 :  $$ = cat_str(5,$1,mm_strdup("for"),$3,mm_strdup("from"),$5);
   12778             : }
   12779             : |  a_expr FROM a_expr
   12780             :  { 
   12781           0 :  $$ = cat_str(3,$1,mm_strdup("from"),$3);
   12782             : }
   12783             : |  a_expr FOR a_expr
   12784             :  { 
   12785           0 :  $$ = cat_str(3,$1,mm_strdup("for"),$3);
   12786             : }
   12787             : |  a_expr SIMILAR a_expr ESCAPE a_expr
   12788             :  { 
   12789           0 :  $$ = cat_str(5,$1,mm_strdup("similar"),$3,mm_strdup("escape"),$5);
   12790             : }
   12791             : ;
   12792             : 
   12793             : 
   12794             :  trim_list:
   12795             :  a_expr FROM expr_list
   12796             :  { 
   12797           0 :  $$ = cat_str(3,$1,mm_strdup("from"),$3);
   12798             : }
   12799             : |  FROM expr_list
   12800             :  { 
   12801           0 :  $$ = cat_str(2,mm_strdup("from"),$2);
   12802             : }
   12803             : |  expr_list
   12804             :  { 
   12805           0 :  $$ = $1;
   12806             : }
   12807             : ;
   12808             : 
   12809             : 
   12810             :  in_expr:
   12811             :  select_with_parens
   12812             :  { 
   12813           0 :  $$ = $1;
   12814             : }
   12815             : |  '(' expr_list ')'
   12816             :  { 
   12817           0 :  $$ = cat_str(3,mm_strdup("("),$2,mm_strdup(")"));
   12818             : }
   12819             : ;
   12820             : 
   12821             : 
   12822             :  case_expr:
   12823             :  CASE case_arg when_clause_list case_default END_P
   12824             :  { 
   12825           0 :  $$ = cat_str(5,mm_strdup("case"),$2,$3,$4,mm_strdup("end"));
   12826             : }
   12827             : ;
   12828             : 
   12829             : 
   12830             :  when_clause_list:
   12831             :  when_clause
   12832             :  { 
   12833           0 :  $$ = $1;
   12834             : }
   12835             : |  when_clause_list when_clause
   12836             :  { 
   12837           0 :  $$ = cat_str(2,$1,$2);
   12838             : }
   12839             : ;
   12840             : 
   12841             : 
   12842             :  when_clause:
   12843             :  WHEN a_expr THEN a_expr
   12844             :  { 
   12845           0 :  $$ = cat_str(4,mm_strdup("when"),$2,mm_strdup("then"),$4);
   12846             : }
   12847             : ;
   12848             : 
   12849             : 
   12850             :  case_default:
   12851             :  ELSE a_expr
   12852             :  { 
   12853           0 :  $$ = cat_str(2,mm_strdup("else"),$2);
   12854             : }
   12855             : | 
   12856             :  { 
   12857           0 :  $$=EMPTY; }
   12858             : ;
   12859             : 
   12860             : 
   12861             :  case_arg:
   12862             :  a_expr
   12863             :  { 
   12864           0 :  $$ = $1;
   12865             : }
   12866             : | 
   12867             :  { 
   12868           0 :  $$=EMPTY; }
   12869             : ;
   12870             : 
   12871             : 
   12872             :  columnref:
   12873             :  ColId
   12874             :  { 
   12875         294 :  $$ = $1;
   12876             : }
   12877             : |  ColId indirection
   12878             :  { 
   12879           0 :  $$ = cat_str(2,$1,$2);
   12880             : }
   12881             : ;
   12882             : 
   12883             : 
   12884             :  indirection_el:
   12885             :  '.' attr_name
   12886             :  { 
   12887           0 :  $$ = cat_str(2,mm_strdup("."),$2);
   12888             : }
   12889             : |  '.' '*'
   12890             :  { 
   12891           0 :  $$ = mm_strdup(". *");
   12892             : }
   12893             : |  '[' a_expr ']'
   12894             :  { 
   12895           0 :  $$ = cat_str(3,mm_strdup("["),$2,mm_strdup("]"));
   12896             : }
   12897             : |  '[' opt_slice_bound ':' opt_slice_bound ']'
   12898             :  { 
   12899           0 :  $$ = cat_str(5,mm_strdup("["),$2,mm_strdup(":"),$4,mm_strdup("]"));
   12900             : }
   12901             : ;
   12902             : 
   12903             : 
   12904             :  opt_slice_bound:
   12905             :  a_expr
   12906             :  { 
   12907           0 :  $$ = $1;
   12908             : }
   12909             : | 
   12910             :  { 
   12911           0 :  $$=EMPTY; }
   12912             : ;
   12913             : 
   12914             : 
   12915             :  indirection:
   12916             :  indirection_el
   12917             :  { 
   12918           0 :  $$ = $1;
   12919             : }
   12920             : |  indirection indirection_el
   12921             :  { 
   12922           0 :  $$ = cat_str(2,$1,$2);
   12923             : }
   12924             : ;
   12925             : 
   12926             : 
   12927             :  opt_indirection:
   12928             : 
   12929             :  { 
   12930         380 :  $$=EMPTY; }
   12931             : |  opt_indirection indirection_el
   12932             :  { 
   12933           0 :  $$ = cat_str(2,$1,$2);
   12934             : }
   12935             : ;
   12936             : 
   12937             : 
   12938             :  opt_asymmetric:
   12939             :  ASYMMETRIC
   12940             :  { 
   12941           0 :  $$ = mm_strdup("asymmetric");
   12942             : }
   12943             : | 
   12944             :  { 
   12945           0 :  $$=EMPTY; }
   12946             : ;
   12947             : 
   12948             : 
   12949             :  opt_target_list:
   12950             :  target_list
   12951             :  { 
   12952         182 :  $$ = $1;
   12953             : }
   12954             : | 
   12955             :  { 
   12956           0 :  $$=EMPTY; }
   12957             : ;
   12958             : 
   12959             : 
   12960             :  target_list:
   12961             :  target_el
   12962             :  { 
   12963         186 :  $$ = $1;
   12964             : }
   12965             : |  target_list ',' target_el
   12966             :  { 
   12967         136 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   12968             : }
   12969             : ;
   12970             : 
   12971             : 
   12972             :  target_el:
   12973             :  a_expr AS ColLabel
   12974             :  { 
   12975           6 :  $$ = cat_str(3,$1,mm_strdup("as"),$3);
   12976             : }
   12977             : |  a_expr BareColLabel
   12978             :  { 
   12979           0 :  $$ = cat_str(2,$1,$2);
   12980             : }
   12981             : |  a_expr
   12982             :  { 
   12983         264 :  $$ = $1;
   12984             : }
   12985             : |  '*'
   12986             :  { 
   12987          52 :  $$ = mm_strdup("*");
   12988             : }
   12989             : ;
   12990             : 
   12991             : 
   12992             :  qualified_name_list:
   12993             :  qualified_name
   12994             :  { 
   12995           0 :  $$ = $1;
   12996             : }
   12997             : |  qualified_name_list ',' qualified_name
   12998             :  { 
   12999           0 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   13000             : }
   13001             : ;
   13002             : 
   13003             : 
   13004             :  qualified_name:
   13005             :  ColId
   13006             :  { 
   13007         540 :  $$ = $1;
   13008             : }
   13009             : |  ColId indirection
   13010             :  { 
   13011           0 :  $$ = cat_str(2,$1,$2);
   13012             : }
   13013             : ;
   13014             : 
   13015             : 
   13016             :  name_list:
   13017             :  name
   13018             :  { 
   13019           2 :  $$ = $1;
   13020             : }
   13021             : |  name_list ',' name
   13022             :  { 
   13023           2 :  $$ = cat_str(3,$1,mm_strdup(","),$3);
   13024             : }
   13025             : ;
   13026             : 
   13027             : 
   13028             :  name:
   13029             :  ColId
   13030             :  { 
   13031        1182 :  $$ = $1;
   13032             : }
   13033             : ;
   13034             : 
   13035             : 
   13036             :  attr_name:
   13037             :  ColLabel
   13038             :  { 
   13039           0 :  $$ = $1;
   13040             : }
   13041             : ;
   13042             : 
   13043             : 
   13044             :  file_name:
   13045             :  ecpg_sconst
   13046             :  { 
   13047           0 :  $$ = $1;
   13048             : }
   13049             : ;
   13050             : 
   13051             : 
   13052             :  func_name:
   13053             :  type_function_name
   13054             :  { 
   13055