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