granicus.if.org Git - postgresql/blob - src/interfaces/ecpg/preproc/preproc.y

   1 /* $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/Attic/preproc.y,v 1.208 2003/02/14 13:17:13 meskes Exp $ */
   2
   3 /* Copyright comment */
   4 %{
   5 #include "postgres_fe.h"
   6
   7 #include "extern.h"
   8
   9 /*
  10  * Variables containing simple states.
  11  */
  12 int struct_level = 0;
  13 int braces_open; /* brace level counter */
  14 char    errortext[128];
  15 char    *connection = NULL;
  16 char    *input_filename = NULL;
  17
  18 static int      QueryIsRule = 0, FoundInto = 0;
  19 static int      initializer = 0;
  20 static struct this_type actual_type[STRUCT_DEPTH];
  21 static char *actual_storage[STRUCT_DEPTH];
  22 static char *actual_startline[STRUCT_DEPTH];
  23
  24 /* temporarily store struct members while creating the data structure */
  25 struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL };
  26
  27 /* also store struct type so we can do a sizeof() later */
  28 static char *ECPGstruct_sizeof = NULL;
  29
  30 struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, 0L, NULL, {NULL}};
  31 struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};
  32
  33 struct ECPGtype ecpg_query = {ECPGt_char_variable, 0L, NULL, {NULL}};
  34
  35 /*
  36  * Handle parsing errors and warnings
  37  */
  38 void
  39 mmerror(int error_code, enum errortype type, char * error)
  40 {
  41         switch(type)
  42         {
  43                 case ET_WARNING:
  44                         fprintf(stderr, "%s:%d: WARNING: %s\n", input_filename, yylineno, error);
  45                         break;
  46                 case ET_ERROR:
  47                         fprintf(stderr, "%s:%d: ERROR: %s\n", input_filename, yylineno, error);
  48                         ret_value = error_code;
  49                         break;
  50                 case ET_FATAL:
  51                         fprintf(stderr, "%s:%d: ERROR: %s\n", input_filename, yylineno, error);
  52                         exit(error_code);
  53         }
  54 }
  55
  56 /*
  57  * string concatenation
  58  */
  59
  60 static char *
  61 cat2_str(char *str1, char *str2)
  62 {
  63         char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2);
  64
  65         strcpy(res_str, str1);
  66         strcat(res_str, " ");
  67         strcat(res_str, str2);
  68         free(str1);
  69         free(str2);
  70         return(res_str);
  71 }
  72
  73 static char *
  74 cat_str(int count, ...)
  75 {
  76         va_list         args;
  77         int                     i;
  78         char            *res_str;
  79
  80         va_start(args, count);
  81
  82         res_str = va_arg(args, char *);
  83
  84         /* now add all other strings */
  85         for (i = 1; i < count; i++)
  86                 res_str = cat2_str(res_str, va_arg(args, char *));
  87
  88         va_end(args);
  89
  90         return(res_str);
  91 }
  92
  93 char *
  94 make_str(const char *str)
  95 {
  96         char * res_str = (char *)mm_alloc(strlen(str) + 1);
  97
  98         strcpy(res_str, str);
  99         return res_str;
 100 }
 101
 102 static char *
 103 make2_str(char *str1, char *str2)
 104 {
 105         char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1);
 106
 107         strcpy(res_str, str1);
 108         strcat(res_str, str2);
 109         free(str1);
 110         free(str2);
 111         return(res_str);
 112 }
 113
 114 static char *
 115 make3_str(char *str1, char *str2, char *str3)
 116 {
 117         char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1);
 118
 119         strcpy(res_str, str1);
 120         strcat(res_str, str2);
 121         strcat(res_str, str3);
 122         free(str1);
 123         free(str2);
 124         free(str3);
 125         return(res_str);
 126 }
 127
 128 static char *
 129 make_name(void)
 130 {
 131         char * name = (char *)mm_alloc(yyleng + 1);
 132
 133         strncpy(name, yytext, yyleng);
 134         name[yyleng] = '\0';
 135         return(name);
 136 }
 137
 138 %}
 139
 140 %union {
 141         double  dval;
 142         int             ival;
 143         char    *str;
 144         struct  when            action;
 145         struct  index           index;
 146         int             tagname;
 147         struct  this_type       type;
 148         enum    ECPGttype       type_enum;
 149         enum    ECPGdtype       dtype_enum;
 150         struct  fetch_desc      descriptor;
 151 }
 152
 153 /* special embedded SQL token */
 154 %token  SQL_ALLOCATE SQL_AUTOCOMMIT SQL_BOOL SQL_BREAK
 155                 SQL_CALL SQL_CARDINALITY SQL_CONNECT SQL_CONNECTION
 156                 SQL_CONTINUE SQL_COUNT SQL_CURRENT SQL_DATA
 157                 SQL_DATETIME_INTERVAL_CODE
 158                 SQL_DATETIME_INTERVAL_PRECISION
 159                 SQL_DESCRIPTOR SQL_DISCONNECT SQL_ENUM SQL_FOUND
 160                 SQL_FREE SQL_GO SQL_GOTO SQL_IDENTIFIED
 161                 SQL_INDICATOR SQL_KEY_MEMBER SQL_LENGTH
 162                 SQL_LONG SQL_NAME SQL_NULLABLE SQL_OCTET_LENGTH
 163                 SQL_OPEN SQL_RELEASE SQL_REFERENCE
 164                 SQL_RETURNED_LENGTH SQL_RETURNED_OCTET_LENGTH SQL_SCALE
 165                 SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQL SQL_SQLERROR
 166                 SQL_SQLPRINT SQL_SQLWARNING SQL_START SQL_STOP
 167                 SQL_STRUCT SQL_UNSIGNED SQL_VALUE SQL_VAR SQL_WHENEVER
 168
 169 /* C token */
 170 %token  S_ADD S_AND S_ANYTHING S_AUTO S_CONST S_DEC S_DIV
 171                 S_DOTPOINT S_EQUAL S_EXTERN S_INC S_LSHIFT S_MEMPOINT
 172                 S_MEMBER S_MOD S_MUL S_NEQUAL S_OR S_REGISTER S_RSHIFT
 173                 S_STATIC S_SUB S_VOLATILE
 174                 S_TYPEDEF
 175
 176 /* I need this and don't know where it is defined inside the backend */
 177 %token  TYPECAST
 178
 179 /* ordinary key words in alphabetical order */
 180 %token <keyword> ABORT_P ABSOLUTE ACCESS ACTION ADD AFTER
 181         AGGREGATE ALL ALTER ANALYSE ANALYZE AND ANY AS ASC
 182         ASSERTION ASSIGNMENT AT AUTHORIZATION
 183
 184         BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
 185         BOOLEAN BOTH BY
 186
 187         CACHE CALLED CASCADE CASE CAST CHAIN CHAR_P
 188         CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
 189         CLUSTER COALESCE COLLATE COLUMN COMMENT COMMIT
 190         COMMITTED CONSTRAINT CONSTRAINTS CONVERSION_P CONVERT COPY
 191         CREATE CREATEDB CREATEUSER CROSS CURRENT_DATE CURRENT_TIME
 192         CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
 193
 194         DATABASE DAY_P DEALLOCATE DEC DECIMAL DECLARE DEFAULT
 195         DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS
 196         DESC DISTINCT DO DOMAIN_P DOUBLE DROP
 197         EACH ELSE ENCODING ENCRYPTED END_P ESCAPE EXCEPT EXCLUSIVE
 198         EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
 199
 200         FALSE_P FETCH FLOAT_P FOR FORCE FOREIGN FORWARD FREEZE FROM
 201         FULL FUNCTION
 202
 203         GET GLOBAL GRANT GROUP_P
 204         HANDLER HAVING HOUR_P
 205
 206         ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P INCREMENT INDEX INHERITS
 207         INITIALLY INNER_P INOUT INPUT INSENSITIVE INSERT INSTEAD INT
 208         INTEGER INTERSECT INTERVAL INTO INVOKER IS ISNULL ISOLATION
 209
 210         JOIN
 211
 212         KEY
 213
 214         LANCOMPILER LANGUAGE LAST LEADING LEFT LEVEL LIKE LIMIT LISTEN
 215         LOAD LOCAL LOCATION LOCK_P
 216
 217         MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
 218
 219         NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NOCREATEDB
 220         NOCREATEUSER NONE NOT NOTHING NOTIFY NOTNULL NULL_P NULLIF
 221         NUMERIC
 222
 223         OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OR ORDER
 224         OUT_P OUTER_P OVERLAPS OVERLAY OWNER
 225
 226         PARTIAL PASSWORD PATH_P PENDANT PLACING POSITION
 227         PRECISION PRESERVE PREPARE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
 228
 229         READ REAL RECHECK REFERENCES REINDEX RELATIVE RENAME REPLACE
 230         RESET RESTRICT RETURNS REVOKE RIGHT ROLLBACK ROW ROWS RULE
 231
 232         SCHEMA SCROLL SECOND_P SECURITY SELECT SEQUENCE SERIALIZABLE
 233         SESSION SESSION_USER SET SETOF SHARE SHOW SIMILAR SIMPLE SMALLINT SOME
 234         STABLE START STATEMENT STATISTICS STDIN STDOUT STORAGE STRICT
 235         SUBSTRING SYSID
 236
 237         TABLE TEMP TEMPLATE TEMPORARY THEN TIME TIMESTAMP TO TOAST
 238         TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P TRUNCATE TRUSTED TYPE_P
 239         UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL UPDATE USAGE
 240         USER USING
 241
 242         VACUUM VALID VALUE VALUES VARCHAR VARYING VERBOSE VERSION VIEW VOLATILE
 243         WHEN WHERE WITH WITHOUT WORK WRITE
 244         YEAR_P
 245         ZONE
 246
 247 /* The grammar thinks these are keywords, but they are not in the keywords.c
 248  * list and so can never be entered directly.  The filter in parser.c
 249  * creates these tokens when required.
 250  */
 251 %token  UNIONJOIN
 252
 253 /* Special keywords, not in the query language - see the "lex" file */
 254 %token <str>    IDENT SCONST Op CSTRING CVARIABLE CPP_LINE IP BCONST XCONST
 255 %token <ival>   ICONST PARAM
 256 %token <dval>   FCONST
 257
 258 /* precedence: lowest to highest */
 259 %left           UNION EXCEPT
 260 %left           INTERSECT
 261 %left           OR
 262 %left           AND
 263 %right          NOT
 264 %right          '='
 265 %nonassoc       '<' '>'
 266 %nonassoc       LIKE ILIKE SIMILAR
 267 %nonassoc       ESCAPE
 268 %nonassoc       OVERLAPS
 269 %nonassoc       BETWEEN
 270 %nonassoc       IN_P
 271 %left           POSTFIXOP                                       /* dummy for postfix Op rules */
 272 %left           Op OPERATOR                             /* multi-character ops and user-defined operators */
 273 %nonassoc       NOTNULL
 274 %nonassoc       ISNULL
 275 %nonassoc       IS NULL_P TRUE_P FALSE_P UNKNOWN
 276 %left           '+' '-'
 277 %left           '*' '/' '%'
 278 %left           '^'
 279 /* Unary Operators */
 280 %left           AT ZONE
 281 %right          UMINUS
 282 %left           '[' ']'
 283 %left           '(' ')'
 284 %left           TYPECAST
 285 %left           '.'
 286 %left           JOIN UNIONJOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
 287
 288 %type  <str>    Iconst Fconst Sconst TransactionStmt CreateStmt UserId
 289 %type  <str>    CreateAsElement OptCreateAs CreateAsList CreateAsStmt
 290 %type  <str>    comment_text ConstraintDeferrabilitySpec TableElementList
 291 %type  <str>    key_match ColLabel SpecialRuleRelation ColId columnDef
 292 %type  <str>    ColConstraint ColConstraintElem drop_type Bconst
 293 %type  <str>    TableConstraint OptTableElementList Xconst opt_transaction
 294 %type  <str>    ConstraintElem key_actions ColQualList type_name
 295 %type  <str>    target_list target_el update_target_list alias_clause
 296 %type  <str>    update_target_el opt_id qualified_name database_name
 297 %type  <str>    access_method attr_name index_name name func_name
 298 %type  <str>    file_name AexprConst c_expr ConstTypename var_list
 299 %type  <str>    a_expr b_expr TruncateStmt CommentStmt OnCommitOption opt_by
 300 %type  <str>    opt_indirection expr_list extract_list extract_arg
 301 %type  <str>    position_list substr_list substr_from alter_column_default
 302 %type  <str>    trim_list in_expr substr_for attrs TableFuncElement
 303 %type  <str>    Typename SimpleTypename Numeric opt_float opt_numeric
 304 %type  <str>    opt_decimal Character character opt_varying opt_charset
 305 %type  <str>    opt_collate opt_timezone opt_interval table_ref
 306 %type  <str>    row_descriptor ConstDatetime AlterDomainStmt
 307 %type  <str>    SelectStmt into_clause OptTemp ConstraintAttributeSpec
 308 %type  <str>    opt_table opt_all sort_clause sortby_list ConstraintAttr
 309 %type  <str>    sortby OptUseOp qualified_name_list name_list ColId_or_Sconst
 310 %type  <str>    group_clause having_clause from_clause opt_distinct
 311 %type  <str>    join_outer where_clause relation_expr sub_type opt_arg
 312 %type  <str>    opt_column_list insert_rest InsertStmt OptimizableStmt
 313 %type  <str>    columnList DeleteStmt LockStmt UpdateStmt CursorStmt
 314 %type  <str>    NotifyStmt columnElem UnlistenStmt TableElement rowdefinition
 315 %type  <str>    copy_delimiter ListenStmt CopyStmt copy_file_name opt_binary
 316 %type  <str>    FetchStmt direction fetch_how_many from_in CreateOpClassStmt
 317 %type  <str>    ClosePortalStmt DropStmt VacuumStmt AnalyzeStmt opt_verbose
 318 %type  <str>    opt_full func_arg OptWithOids opt_freeze opt_ecpg_into
 319 %type  <str>    analyze_keyword opt_name_list ExplainStmt index_params
 320 %type  <str>    index_list func_index index_elem opt_class access_method_clause
 321 %type  <str>    index_opt_unique IndexStmt func_return ConstInterval
 322 %type  <str>    func_args_list func_args opt_with def_arg overlay_placing
 323 %type  <str>    def_elem def_list definition DefineStmt select_with_parens
 324 %type  <str>    opt_instead event RuleActionList opt_using CreateAssertStmt
 325 %type  <str>    RuleActionStmtOrEmpty RuleActionMulti func_as reindex_type
 326 %type  <str>    RuleStmt opt_column opt_name oper_argtypes NumConst
 327 %type  <str>    MathOp RemoveFuncStmt aggr_argtype for_update_clause
 328 %type  <str>    RemoveAggrStmt opt_procedural select_no_parens CreateCastStmt
 329 %type  <str>    RemoveOperStmt RenameStmt all_Op opt_Trusted opt_lancompiler
 330 %type  <str>    VariableSetStmt var_value zone_value VariableShowStmt
 331 %type  <str>    VariableResetStmt AlterTableStmt from_list overlay_list
 332 %type  <str>    user_list OptUserList OptUserElem relation_name
 333 %type  <str>    CreateUserStmt AlterUserStmt CreateSeqStmt OptSeqList
 334 %type  <str>    OptSeqElem TriggerForSpec TriggerForOpt TriggerForType
 335 %type  <str>    DropTrigStmt TriggerOneEvent TriggerEvents RuleActionStmt
 336 %type  <str>    TriggerActionTime CreateTrigStmt DropPLangStmt DropCastStmt
 337 %type  <str>    CreatePLangStmt TriggerFuncArgs TriggerFuncArg simple_select
 338 %type  <str>    ViewStmt LoadStmt CreatedbStmt createdb_opt_item
 339 %type  <str>    createdb_opt_list opt_encoding OptInherit opt_equal
 340 %type  <str>    AlterUserSetStmt privilege_list privilege privilege_target
 341 %type  <str>    opt_grant_grant_option opt_revoke_grant_option
 342 %type  <str>    transaction_mode_list_or_empty transaction_mode_list
 343 %type  <str>    function_with_argtypes_list function_with_argtypes
 344 %type  <str>    DropdbStmt ClusterStmt grantee RevokeStmt Bit DropOpClassStmt
 345 %type  <str>    GrantStmt privileges PosAllConst constraints_set_list
 346 %type  <str>    opt_cursor ConstraintsSetStmt AllConst CreateDomainStmt
 347 %type  <str>    case_expr when_clause_list case_default case_arg when_clause
 348 %type  <str>    select_clause opt_select_limit select_limit_value opt_recheck
 349 %type  <str>    ConstraintTimeSpec AlterDatabaseSetStmt DropAssertStmt
 350 %type  <str>    select_offset_value ReindexStmt join_type opt_boolean
 351 %type  <str>    join_qual update_list joined_table opclass_item
 352 %type  <str>    opt_lock lock_type OptGroupList OptGroupElem
 353 %type  <str>    OptConstrFromTable OptTempTableName StringConst
 354 %type  <str>    constraints_set_mode comment_type opt_empty_parentheses
 355 %type  <str>    CreateGroupStmt AlterGroupStmt DropGroupStmt key_delete
 356 %type  <str>    opt_force key_update CreateSchemaStmt PosIntStringConst
 357 %type  <str>    IntConst PosIntConst grantee_list func_type opt_or_replace
 358 %type  <str>    select_limit opt_for_update_clause CheckPointStmt
 359 %type  <str>    OptSchemaName OptSchemaEltList schema_stmt opt_drop_behavior
 360 %type  <str>    handler_name any_name_list any_name opt_as insert_column_list
 361 %type  <str>    columnref dotted_name function_name insert_target_el
 362 %type  <str>    insert_target_list insert_column_item DropRuleStmt
 363 %type  <str>    createfunc_opt_item set_rest var_list_or_default
 364 %type  <str>    CreateFunctionStmt createfunc_opt_list func_table
 365 %type  <str>    DropUserStmt copy_from copy_opt_list copy_opt_item
 366 %type  <str>    opt_oids TableLikeClause key_action opt_definition
 367 %type  <str>    cast_context row r_expr qual_Op qual_all_Op opt_default
 368 %type  <str>    CreateConversionStmt any_operator opclass_item_list
 369 %type  <str>    iso_level type_list CharacterWithLength ConstCharacter
 370 %type  <str>    CharacterWithoutLength BitWithLength BitWithoutLength
 371 %type  <str>    ConstBit GenericType TableFuncElementList opt_analyze
 372 %type  <str>    opt_sort_clause transaction_access_mode
 373
 374 %type  <str>    ECPGWhenever ECPGConnect connection_target ECPGOpen
 375 %type  <str>    indicator ECPGExecute ECPGPrepare opt_ecpg_using ecpg_into
 376 %type  <str>    storage_declaration storage_clause opt_initializer c_anything
 377 %type  <str>    variable_list variable c_thing c_term
 378 %type  <str>    opt_pointer ECPGDisconnect dis_name storage_modifier
 379 %type  <str>    ECPGRelease execstring server_name ECPGVarDeclaration
 380 %type  <str>    connection_object opt_server opt_port c_stuff c_stuff_item
 381 %type  <str>    user_name opt_user char_variable ora_user ident opt_reference
 382 %type  <str>    var_type_declarations quoted_ident_stringvar
 383 %type  <str>    db_prefix server opt_options opt_connection_name c_list
 384 %type  <str>    ECPGSetConnection ECPGTypedef c_args ECPGKeywords
 385 %type  <str>    enum_type civar civarind ECPGCursorStmt ECPGDeallocate
 386 %type  <str>    ECPGFree ECPGDeclare ECPGVar opt_at enum_definition
 387 %type  <str>    struct_type s_struct vt_declarations variable_declarations
 388 %type  <str>    var_declaration type_declaration single_vt_declaration
 389 %type  <str>    s_union union_type ECPGSetAutocommit on_off
 390 %type  <str>    ECPGAllocateDescr ECPGDeallocateDescr symbol opt_symbol
 391 %type  <str>    ECPGGetDescriptorHeader ECPGColLabel single_var_declaration
 392 %type  <str>    reserved_keyword unreserved_keyword
 393 %type  <str>    col_name_keyword func_name_keyword
 394 %type  <str>    ECPGTypeName variablelist ECPGColLabelCommon
 395
 396 %type  <descriptor> ECPGGetDescriptor
 397
 398 %type  <type_enum> simple_type signed_type unsigned_type
 399
 400 %type  <dtype_enum> descriptor_item desc_header_item
 401
 402 %type  <type>   type common_type single_vt_type
 403
 404 %type  <action> action
 405
 406 %type  <index>  opt_array_bounds opt_type_array_bounds
 407
 408 %type  <ival>   Iresult
 409
 410 %%
 411 prog: statements;
 412
 413 statements: /*EMPTY*/
 414                 | statements statement
 415                 ;
 416
 417 statement: ecpgstart opt_at stmt ';'    { connection = NULL; }
 418                 | ecpgstart stmt ';'
 419                 | ecpgstart ECPGVarDeclaration
 420                 {
 421                         fprintf(yyout, "%s", $2);
 422                         free($2);
 423                         output_line_number();
 424                 }
 425                 | ECPGDeclaration
 426                 | c_thing               { fprintf(yyout, "%s", $1); free($1); }
 427                 | CPP_LINE              { fprintf(yyout, "%s", $1); free($1); }
 428                 | '{'                   { braces_open++; fputs("{", yyout); }
 429                 | '}'                   { remove_variables(braces_open--); fputs("}", yyout); }
 430                 ;
 431
 432 opt_at: AT connection_target
 433                 {
 434                         connection = $2;
 435                         /*
 436                          *      if we have a variable as connection
 437                          *      target, remove it from the variable
 438                          *      list or else it will be used twice
 439                          */
 440                         if (argsinsert != NULL)
 441                                 argsinsert = NULL;
 442                 };
 443
 444 stmt:  AlterDatabaseSetStmt { output_statement($1, 0, connection); }
 445                 | AlterDomainStmt       { output_statement($1, 0, connection); }
 446                 | AlterGroupStmt        { output_statement($1, 0, connection); }
 447                 | AlterTableStmt        { output_statement($1, 0, connection); }
 448                 | AlterUserStmt         { output_statement($1, 0, connection); }
 449                 | AlterUserSetStmt      { output_statement($1, 0, connection); }
 450                 | ClosePortalStmt       { output_statement($1, 0, connection); }
 451                 | CommentStmt           { output_statement($1, 0, connection); }
 452                 | CopyStmt              { output_statement($1, 0, connection); }
 453                 | CreateStmt            { output_statement($1, 0, connection); }
 454                 | CreateAsStmt          { output_statement($1, 0, connection); }
 455                 | CreateCastStmt        { output_statement($1, 0, connection); }
 456                 | CreateDomainStmt      { output_statement($1, 0, connection); }
 457                 | CreateFunctionStmt    { output_statement($1, 0, connection); }
 458                 | CreateSchemaStmt      { output_statement($1, 0, connection); }
 459                 | CreateGroupStmt       { output_statement($1, 0, connection); }
 460                 | CreateSeqStmt         { output_statement($1, 0, connection); }
 461                 | CreatePLangStmt       { output_statement($1, 0, connection); }
 462                 | CreateAssertStmt      { output_statement($1, 0, connection); }
 463                 | CreateOpClassStmt     { output_statement($1, 0, connection); }
 464                 | CreateTrigStmt        { output_statement($1, 0, connection); }
 465                 | CreateUserStmt        { output_statement($1, 0, connection); }
 466                 | ClusterStmt           { output_statement($1, 0, connection); }
 467                 /*| DeallocateStmt      { output_statement($1, 0, connection); }*/
 468                 | DefineStmt            { output_statement($1, 0, connection); }
 469                 | DropStmt              { output_statement($1, 0, connection); }
 470                 | TruncateStmt          { output_statement($1, 0, connection); }
 471                 | DropCastStmt          { output_statement($1, 0, connection); }
 472                 | DropGroupStmt         { output_statement($1, 0, connection); }
 473                 | DropOpClassStmt       { output_statement($1, 0, connection); }
 474                 | DropPLangStmt         { output_statement($1, 0, connection); }
 475                 | DropAssertStmt        { output_statement($1, 0, connection); }
 476                 | DropTrigStmt          { output_statement($1, 0, connection); }
 477                 | DropRuleStmt          { output_statement($1, 0, connection); }
 478                 | DropUserStmt          { output_statement($1, 0, connection); }
 479                 | ExplainStmt           { output_statement($1, 0, connection); }/*              | ExecuteStmt           { output_statement($1, 0, connection); }*/
 480                 | FetchStmt             { output_statement($1, 1, connection); }
 481                 | GrantStmt             { output_statement($1, 0, connection); }
 482                 | IndexStmt             { output_statement($1, 0, connection); }
 483                 | ListenStmt            { output_statement($1, 0, connection); }
 484                 | UnlistenStmt          { output_statement($1, 0, connection); }
 485                 | LockStmt              { output_statement($1, 0, connection); }
 486                 | NotifyStmt            { output_statement($1, 0, connection); }
 487 /*              | PrepareStmt           { output_statement($1, 0, connection); }*/
 488                 | ReindexStmt           { output_statement($1, 0, connection); }
 489                 | RemoveAggrStmt        { output_statement($1, 0, connection); }
 490                 | RemoveOperStmt        { output_statement($1, 0, connection); }
 491                 | RemoveFuncStmt        { output_statement($1, 0, connection); }
 492                 | RenameStmt            { output_statement($1, 0, connection); }
 493                 | RevokeStmt            { output_statement($1, 0, connection); }
 494                 | OptimizableStmt
 495                 {
 496                         if (strncmp($1, "/* " , sizeof("/* ")-1) == 0)
 497                                 output_simple_statement($1);
 498                         else
 499                                 output_statement($1, 1, connection);
 500                 }
 501                 | RuleStmt              { output_statement($1, 0, connection); }
 502                 | TransactionStmt
 503                 {
 504                         fprintf(yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", $1);
 505                         whenever_action(2);
 506                         free($1);
 507                 }
 508                 | ViewStmt              { output_statement($1, 0, connection); }
 509                 | LoadStmt              { output_statement($1, 0, connection); }
 510                 | CreatedbStmt          { output_statement($1, 0, connection); }
 511                 | DropdbStmt            { output_statement($1, 0, connection); }
 512                 | VacuumStmt            { output_statement($1, 0, connection); }
 513                 | AnalyzeStmt           { output_statement($1, 0, connection); }
 514                 | VariableSetStmt       { output_statement($1, 0, connection); }
 515                 | VariableShowStmt      { output_statement($1, 0, connection); }
 516                 | VariableResetStmt     { output_statement($1, 0, connection); }
 517                 | ConstraintsSetStmt    { output_statement($1, 0, connection); }
 518                 | CheckPointStmt        { output_statement($1, 0, connection); }
 519                 | CreateConversionStmt  { output_statement($1, 0, connection); }
 520                 | ECPGAllocateDescr
 521                 {
 522                         fprintf(yyout,"ECPGallocate_desc(__LINE__, %s);",$1);
 523                         whenever_action(0);
 524                         free($1);
 525                 }
 526                 | ECPGConnect
 527                 {
 528                         if (connection)
 529                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for connect statement.\n");
 530
 531                         fprintf(yyout, "{ ECPGconnect(__LINE__, %s, %d); ", $1, autocommit);
 532                         reset_variables();
 533                         whenever_action(2);
 534                         free($1);
 535                 }
 536                 | ECPGCursorStmt
 537                 {
 538                         output_simple_statement($1);
 539                 }
 540                 | ECPGDeallocate
 541                 {
 542                         if (connection)
 543                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for connect statement.\n");
 544
 545                         fputc('{', yyout);
 546                         fputs($1, yyout);
 547                         whenever_action(2);
 548                         free($1);
 549                 }
 550                 | ECPGDeallocateDescr
 551                 {
 552                         fprintf(yyout,"ECPGdeallocate_desc(__LINE__, %s);",$1);
 553                         whenever_action(0);
 554                         free($1);
 555                 }
 556                 | ECPGDeclare
 557                 {
 558                         output_simple_statement($1);
 559                 }
 560                 | ECPGDisconnect
 561                 {
 562                         if (connection)
 563                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for disconnect statement.\n");
 564
 565                         fprintf(yyout, "{ ECPGdisconnect(__LINE__, %s);",
 566                                         $1 ? $1 : "\"CURRENT\"");
 567                         whenever_action(2);
 568                         free($1);
 569                 }
 570                 | ECPGExecute
 571                 {
 572                         output_statement($1, 0, connection);
 573                 }
 574                 | ECPGFree
 575                 {
 576                         fprintf(yyout, "{ ECPGdeallocate(__LINE__, \"%s\");", $1);
 577
 578                         whenever_action(2);
 579                         free($1);
 580                 }
 581                 | ECPGGetDescriptor
 582                 {
 583                         lookup_descriptor($1.name, connection);
 584                         output_get_descr($1.name, $1.str);
 585                         free($1.name);
 586                         free($1.str);
 587                 }
 588                 | ECPGGetDescriptorHeader
 589                 {
 590                         lookup_descriptor($1, connection);
 591                         output_get_descr_header($1);
 592                         free($1);
 593                 }
 594                 | ECPGOpen
 595                 {
 596                         struct cursor *ptr;
 597                         struct arguments *p;
 598
 599                         for (ptr = cur; ptr != NULL; ptr=ptr->next)
 600                         {
 601                                 if (strcmp(ptr->name, $1) == 0)
 602                                         break;
 603                         }
 604
 605                         if (ptr == NULL)
 606                         {
 607                                 snprintf(errortext, sizeof(errortext), "trying to open undeclared cursor %s\n", $1);
 608                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
 609                         }
 610
 611                         /* merge variables given in prepare statement with those given here */
 612                         for (p = ptr->argsinsert; p; p = p->next)
 613                                 append_variable(&argsinsert, p->variable, p->indicator);
 614
 615                         for (p = ptr->argsresult; p; p = p->next)
 616                                 add_variable(&argsresult, p->variable, p->indicator);
 617
 618                         output_statement(mm_strdup(ptr->command), 0, ptr->connection ? mm_strdup(ptr->connection) : NULL);
 619                 }
 620                 | ECPGPrepare
 621                 {
 622                         if (connection)
 623                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for set connection statement.\n");
 624
 625                         fprintf(yyout, "{ ECPGprepare(__LINE__, %s);", $1);
 626                         whenever_action(2);
 627                         free($1);
 628                 }
 629                 | ECPGRelease           { /* output already done */ }
 630                 | ECPGSetAutocommit
 631                 {
 632                         fprintf(yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", $1, connection ? connection : "NULL");
 633                         whenever_action(2);
 634                         free($1);
 635                 }
 636                 | ECPGSetConnection
 637                 {
 638                         if (connection)
 639                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for set connection statement.\n");
 640
 641                         fprintf(yyout, "{ ECPGsetconn(__LINE__, %s);", $1);
 642                         whenever_action(2);
 643                         free($1);
 644                 }
 645                 | ECPGTypedef
 646                 {
 647                         if (connection)
 648                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for typedef statement.\n");
 649
 650                         fprintf(yyout, "%s", $1);
 651                         free($1);
 652                         output_line_number();
 653                 }
 654                 | ECPGVar
 655                 {
 656                         if (connection)
 657                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for var statement.\n");
 658
 659                         output_simple_statement($1);
 660                 }
 661                 | ECPGWhenever
 662                 {
 663                         if (connection)
 664                                 mmerror(PARSE_ERROR, ET_ERROR, "no at option for whenever statement.\n");
 665
 666                         output_simple_statement($1);
 667                 }
 668                 ;
 669
 670
 671 /*
 672  * We start with a lot of stuff that's very similar to the backend's parsing
 673  */
 674
 675 /*****************************************************************************
 676  *
 677  * Create a new Postgres DBMS user
 678  *
 679  *
 680  *****************************************************************************/
 681
 682 CreateUserStmt: CREATE USER UserId opt_with OptUserList
 683                         { $$ = cat_str(4, make_str("create user"), $3, make_str("with"), $5); }
 684                 ;
 685
 686 opt_with:  WITH                 { $$ = make_str("with"); }
 687                 | /*EMPTY*/     { $$ = EMPTY; }
 688                 ;
 689
 690
 691 /*****************************************************************************
 692  *
 693  * Alter a postgresql DBMS user
 694  *
 695  *
 696  *****************************************************************************/
 697
 698 AlterUserStmt: ALTER USER UserId OptUserList
 699                         { $$ = cat_str(3, make_str("alter user"), $3, $4); }
 700                 | ALTER USER UserId WITH OptUserList
 701                         { $$ = cat_str(4, make_str("alter user"), $3, make_str("with"), $5); }
 702                 ;
 703
 704 AlterUserSetStmt: ALTER USER UserId SET set_rest
 705                         { $$ = cat_str(4, make_str("alter user"), $3, make_str("set"), $5); }
 706                 | ALTER USER UserId VariableResetStmt
 707                         { $$ = cat_str(3, make_str("alter user"), $3, $4); }
 708                 ;
 709
 710 /*****************************************************************************
 711  *
 712  * Drop a postgresql DBMS user
 713  *
 714  *
 715  *****************************************************************************/
 716 DropUserStmt:  DROP USER user_list
 717                         { $$ = cat2_str(make_str("drop user"), $3);}
 718                 ;
 719 /*
 720  * Options for CREATE USER and ALTER USER
 721  */
 722
 723 OptUserList: OptUserList OptUserElem    { $$ = cat2_str($1, $2); }
 724                 | /* EMPTY */                                   { $$ = EMPTY; }
 725                 ;
 726
 727 OptUserElem:  PASSWORD Sconst
 728                 { $$ = cat2_str(make_str("password"), $2); }
 729                 | SYSID PosIntConst
 730                         { $$ = cat2_str(make_str("sysid"), $2); }
 731                 | CREATEDB
 732                         { $$ = make_str("createdb"); }
 733                 | NOCREATEDB
 734                         { $$ = make_str("nocreatedb"); }
 735                 | CREATEUSER
 736                         { $$ = make_str("createuser"); }
 737                 | NOCREATEUSER
 738                         { $$ = make_str("nocreateuser"); }
 739                 | IN_P GROUP_P user_list
 740                         { $$ = cat2_str(make_str("in group"), $3); }
 741                 | VALID UNTIL Sconst
 742                         { $$ = cat2_str(make_str("valid until"), $3); }
 743                 ;
 744
 745 user_list:      user_list ',' UserId
 746                         { $$ = cat_str(3, $1, make_str(","), $3); }
 747                 | UserId
 748                         { $$ = $1; }
 749                 ;
 750
 751 /*****************************************************************************
 752  *
 753  * Create a postgresql group
 754  *
 755  *
 756  ****************************************************************************/
 757 CreateGroupStmt:  CREATE GROUP_P UserId OptGroupList
 758                         { $$ = cat_str(3, make_str("create group"), $3, $4); }
 759                 | CREATE GROUP_P UserId WITH OptGroupList
 760                         { $$ = cat_str(4, make_str("create group"), $3, make_str("with"), $5); }
 761                 ;
 762
 763 /*
 764  * Options for CREATE GROUP
 765  */
 766 OptGroupList: OptGroupList OptGroupElem         { $$ = cat2_str($1, $2); }
 767                 | /* EMPTY */                                           { $$ = EMPTY; }
 768                 ;
 769
 770 OptGroupElem:  USER user_list
 771                         { $$ = cat2_str(make_str("user"), $2); }
 772                 | SYSID PosIntConst
 773                         { $$ = cat2_str(make_str("sysid"), $2); }
 774                 ;
 775
 776
 777 /*****************************************************************************
 778  *
 779  * Alter a postgresql group
 780  *
 781  *
 782  *****************************************************************************/
 783 AlterGroupStmt: ALTER GROUP_P UserId ADD USER user_list
 784                         { $$ = cat_str(4, make_str("alter group"), $3, make_str("add user"), $6); }
 785                 | ALTER GROUP_P UserId DROP USER user_list
 786                         { $$ = cat_str(4, make_str("alter group"), $3, make_str("drop user"), $6); }
 787                 ;
 788
 789 /*****************************************************************************
 790  *
 791  * Drop a postgresql group
 792  *
 793  *
 794  *****************************************************************************/
 795 DropGroupStmt: DROP GROUP_P UserId
 796                         { $$ = cat2_str(make_str("drop group"), $3); }
 797                 ;
 798
 799 /*****************************************************************************
 800  *
 801  * Manipulate a schema
 802  *
 803  *
 804  *****************************************************************************/
 805
 806 CreateSchemaStmt:  CREATE SCHEMA UserId OptSchemaName AUTHORIZATION UserId OptSchemaEltList
 807                         { $$ = cat_str(6, make_str("create scheme"), $3, $4, make_str("authorization"), $6, $7); }
 808                 | CREATE SCHEMA ColId OptSchemaEltList
 809                         { $$ = cat_str(3, make_str("create scheme"), $3, $4); }
 810                 ;
 811
 812 OptSchemaName: ColId            { $$ = $1; }
 813                | /* EMPTY */   { $$ = EMPTY; }
 814                ;
 815
 816 OptSchemaEltList: OptSchemaEltList schema_stmt         { $$ = cat2_str($1, $2); }
 817                 | /* EMPTY */   { $$ = EMPTY; }
 818                 ;
 819
 820 /*
 821  *     schema_stmt are the ones that can show up inside a CREATE SCHEMA
 822  *     statement (in addition to by themselves).
 823  */
 824 schema_stmt: CreateStmt         { $$ = $1; }
 825                | GrantStmt      { $$ = $1; }
 826                | ViewStmt       { $$ = $1; }
 827                ;
 828
 829
 830
 831 /*****************************************************************************
 832  *
 833  * Set PG internal variable
 834  *        SET name TO 'var_value'
 835  * Include SQL92 syntax (thomas 1997-10-22):
 836  *        SET TIME ZONE 'var_value'
 837  *
 838  *****************************************************************************/
 839 VariableSetStmt:  SET set_rest
 840                         { $$ = cat2_str(make_str("set"), $2 ); }
 841                 | SET LOCAL set_rest
 842                         { $$ = cat2_str(make_str("set local"), $3 ); }
 843                 | SET SESSION set_rest
 844                         { $$ = cat2_str(make_str("set session"), $3 ); }
 845                 ;
 846
 847 set_rest:       ColId TO var_list_or_default
 848                         { $$ = cat_str(3, $1, make_str("to"), $3); }
 849                 | ColId "=" var_list_or_default
 850                         { $$ = cat_str(3, $1, make_str("="), $3); }
 851                 | TIME ZONE zone_value
 852                         { $$ = cat2_str(make_str("time zone"), $3); }
 853                 | TRANSACTION transaction_mode_list
 854                         { $$ = cat2_str(make_str("transaction"), $2); }
 855                 | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
 856                         { $$ = cat2_str(make_str("session characteristics as transaction"), $5); }
 857                 | NAMES opt_encoding
 858                         { $$ = cat2_str(make_str("names"), $2); }
 859                 | SESSION AUTHORIZATION ColId_or_Sconst
 860                         { $$ = cat2_str(make_str("session authorization"), $3); }
 861                 | SESSION AUTHORIZATION DEFAULT
 862                         { $$ = make_str("session authorization default"); }
 863                 ;
 864
 865 var_list_or_default:  var_list
 866                         { $$ = $1; }
 867                 | DEFAULT
 868                         { $$ = make_str("default"); }
 869                 ;
 870
 871 var_list:  var_value
 872                         { $$ = $1; }
 873                 | var_list ',' var_value
 874                         { $$ = cat_str(3, $1, make_str(","), $3); }
 875                 ;
 876
 877 iso_level:      READ COMMITTED  { $$ = make_str("read committed"); }
 878                 | SERIALIZABLE          { $$ = make_str("serializable"); }
 879                 ;
 880
 881 var_value:      opt_boolean             { $$ = $1; }
 882                 | AllConst              { $$ = $1; }
 883                 | ColId                 { $$ = $1; }
 884                 ;
 885
 886 opt_boolean:  TRUE_P            { $$ = make_str("true"); }
 887                 | FALSE_P                       { $$ = make_str("false"); }
 888                 | ON                            { $$ = make_str("on"); }
 889                 | OFF                           { $$ = make_str("off"); }
 890                 ;
 891 /* Timezone values can be:
 892  * - a string such as 'pst8pdt'
 893  * - a column identifier such as "pst8pdt"
 894  * - an integer or floating point number
 895  * - a time interval per SQL99
 896  * ConstInterval and ColId give shift/reduce errors,
 897  * so use IDENT and reject anything which is a reserved word.
 898  */
 899 zone_value:  AllConst           { $$ = $1; }
 900                 | ident         { $$ = $1; }
 901                 | ConstInterval StringConst opt_interval
 902                         { $$ = cat_str(3, $1, $2, $3); }
 903                 | ConstInterval '(' PosIntConst ')' StringConst opt_interval
 904                         { $$ = cat_str(6, $1, make_str("("), $3, make_str(")"), $5, $6); }
 905                 | DEFAULT
 906                         { $$ = make_str("default"); }
 907                 | LOCAL
 908                         { $$ = make_str("local"); }
 909                 ;
 910
 911 opt_encoding:   StringConst             { $$ = $1; }
 912                 | DEFAULT                               { $$ = make_str("default"); }
 913                 | /*EMPTY*/                             { $$ = EMPTY; }
 914                 ;
 915
 916 ColId_or_Sconst: ColId                  { $$ = $1; }
 917                 | StringConst                   { $$ = $1; }
 918                 ;
 919
 920 VariableShowStmt:  SHOW ColId
 921                         { $$ = cat2_str(make_str("show"), $2); }
 922                 | SHOW TIME ZONE
 923                         { $$ = make_str("show time zone"); }
 924                 | SHOW TRANSACTION ISOLATION LEVEL
 925                         { $$ = make_str("show transaction isolation level"); }
 926                 | SHOW SESSION AUTHORIZATION
 927                         { $$ = make_str("show session authorization"); }
 928                 | SHOW ALL
 929                         { $$ = make_str("show all"); }
 930                 ;
 931
 932 VariableResetStmt:      RESET ColId
 933                         { $$ = cat2_str(make_str("reset"), $2); }
 934                 | RESET TIME ZONE
 935                         { $$ = make_str("reset time zone"); }
 936                 | RESET TRANSACTION ISOLATION LEVEL
 937                         { $$ = make_str("reset transaction isolation level"); }
 938                 | RESET SESSION AUTHORIZATION
 939                         { $$ = make_str("reset session authorization"); }
 940                 | RESET ALL
 941                         { $$ = make_str("reset all"); }
 942                 ;
 943
 944 ConstraintsSetStmt:    SET CONSTRAINTS constraints_set_list constraints_set_mode
 945                         { $$ = cat_str(3, make_str("set constraints"), $3, $4); }
 946                 ;
 947
 948 constraints_set_list:  ALL
 949                         { $$ = make_str("all"); }
 950                 | name_list
 951                         { $$ = $1; }
 952                 ;
 953
 954 constraints_set_mode:  DEFERRED         { $$ = make_str("deferred"); }
 955                 | IMMEDIATE             { $$ = make_str("immediate"); }
 956                 ;
 957
 958 /*
 959  * Checkpoint statement
 960  */
 961 CheckPointStmt: CHECKPOINT         { $$= make_str("checkpoint"); }
 962                 ;
 963
 964
 965 /*****************************************************************************
 966  *
 967  *      ALTER TABLE variations
 968  *
 969  *****************************************************************************/
 970
 971 AlterTableStmt:
 972 /* ALTER TABLE <relation> ADD [COLUMN] <coldef> */
 973                 ALTER TABLE relation_expr ADD opt_column columnDef
 974                         { $$ = cat_str(5, make_str("alter table"), $3, make_str("add"), $5, $6); }
 975 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
 976                 | ALTER TABLE relation_expr ALTER opt_column ColId alter_column_default
 977                         { $$ = cat_str(6, make_str("alter table"), $3, make_str("alter"), $5, $6, $7); }
 978 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> DROP NOT NULL */
 979                 | ALTER TABLE relation_expr ALTER opt_column ColId DROP NOT NULL_P
 980                         { $$ = cat_str(6, make_str("alter table"), $3, make_str("alter"), $5, $6, make_str("drop not null")); }
 981 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET NOT NULL */
 982                 | ALTER TABLE relation_expr ALTER opt_column ColId SET NOT NULL_P
 983                         { $$ = cat_str(6, make_str("alter table"), $3, make_str("alter"), $5, $6, make_str("set not null")); }
 984 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STATISTICS <IntegerOnly> */
 985                 | ALTER TABLE relation_expr ALTER opt_column ColId SET STATISTICS PosIntConst
 986                         { $$ = cat_str(7, make_str("alter table"), $3, make_str("alter"), $5, $6, make_str("set statistics"), $9); }
 987 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
 988                 | ALTER TABLE relation_expr ALTER opt_column ColId SET STORAGE ColId
 989                         { $$ = cat_str(7, make_str("alter table"), $3, make_str("alter"), $5, $6, make_str("set storage"), $9); }
 990 /* ALTER TABLE <relation> DROP [COLUMN] <colname> {RESTRICT|CASCADE} */
 991                 | ALTER TABLE relation_expr DROP opt_column ColId opt_drop_behavior
 992                         { $$ = cat_str(6, make_str("alter table"), $3, make_str("drop"), $5, $6, $7); }
 993 /* ALTER TABLE <relation> ADD CONSTRAINT ... */
 994                 | ALTER TABLE relation_expr ADD TableConstraint
 995                         { $$ = cat_str(4, make_str("alter table"), $3, make_str("add"), $5); }
 996 /* ALTER TABLE <relation> DROP CONSTRAINT ... */
 997                 | ALTER TABLE relation_expr DROP CONSTRAINT name opt_drop_behavior
 998                         { $$ = cat_str(5, make_str("alter table"), $3, make_str("drop constraint"), $6, $7); }
 999 /* ALTER TABLE <relation> SET WITHOUT OIDS  */
1000                 | ALTER TABLE relation_expr SET WITHOUT OIDS
1001                         { $$ = cat_str(3, make_str("alter table"), $3, make_str("set without oids")); }
1002  /* ALTER TABLE <name> CREATE TOAST TABLE */
1003                 | ALTER TABLE qualified_name CREATE TOAST TABLE
1004                         { $$ = cat_str(3, make_str("alter table"), $3, make_str("create toast table")); }
1005 /* ALTER TABLE <name> OWNER TO UserId */
1006                 | ALTER TABLE qualified_name OWNER TO UserId
1007                         { $$ = cat_str(4, make_str("alter table"), $3, make_str("owner to"), $6); }
1008                 ;
1009
1010 alter_column_default:
1011                 SET DEFAULT a_expr              { $$ = cat2_str(make_str("set default"), $3); }
1012                 | DROP DEFAULT                  { $$ = make_str("drop default"); }
1013                 ;
1014
1015 opt_drop_behavior: CASCADE                      { $$ = make_str("cascade"); }
1016                 | RESTRICT                      { $$ = make_str("restrict"); }
1017                 | /* EMPTY */                   { $$ = EMPTY; }
1018                 ;
1019
1020 /*****************************************************************************
1021  *
1022  *              QUERY :
1023  *                              close <optname>
1024  *
1025  *****************************************************************************/
1026
1027 ClosePortalStmt:  CLOSE opt_id  { $$ = cat2_str(make_str("close"), $2); }
1028                 ;
1029
1030 opt_id:  ColId                                  { $$ = $1; }
1031                 | /*EMPTY*/                     { $$ = NULL; }
1032                 ;
1033
1034 /*****************************************************************************
1035  *
1036  *              QUERY :
1037  *                              COPY [BINARY] <relname> FROM/TO
1038  *                              [USING DELIMITERS <delimiter>]
1039  *
1040  *****************************************************************************/
1041
1042 CopyStmt:  COPY opt_binary qualified_name opt_oids copy_from
1043                 copy_file_name copy_delimiter opt_with copy_opt_list
1044                         { $$ = cat_str(9, make_str("copy"), $2, $3, $4, $5, $6, $7, $8, $9); }
1045                 ;
1046
1047 copy_from:      TO                                      { $$ = make_str("to"); }
1048                 | FROM                                  { $$ = make_str("from"); }
1049                 ;
1050
1051 /*
1052  * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
1053  * used depends on the direction. (It really doesn't make sense to copy from
1054  * stdout. We silently correct the "typo".               - AY 9/94
1055  */
1056 copy_file_name:  StringConst    { $$ = $1; }
1057                 | STDIN                                 { $$ = make_str("stdin"); }
1058                 | STDOUT                                { $$ = make_str("stdout"); }
1059                 ;
1060
1061 copy_opt_list: copy_opt_list copy_opt_item      { $$ = cat2_str($1, $2); }
1062                 | /* EMPTY */                   { $$ = EMPTY; }
1063                 ;
1064
1065 copy_opt_item:  BINARY          { $$ = make_str("binary"); }
1066                 | OIDS          { $$ = make_str("oids"); }
1067                 | DELIMITER opt_as StringConst
1068                         { $$ = cat_str(3, make_str("delimiter"), $2, $3); }
1069                 | NULL_P opt_as StringConst
1070                         { $$ = cat_str(3, make_str("null"), $2, $3); }
1071                 ;
1072
1073 opt_binary:     BINARY          { $$ = make_str("binary"); }
1074                 | /* EMPTY */   { $$ = EMPTY; }
1075                 ;
1076
1077 opt_oids:       WITH OIDS       { $$ = make_str("with oids"); }
1078                 | /* EMPTY */   { $$ = EMPTY; }
1079                 ;
1080
1081
1082 /*
1083  * the default copy delimiter is tab but the user can configure it
1084  */
1085 copy_delimiter:  opt_using DELIMITERS StringConst
1086                         { $$ = cat_str(3, $1, make_str("delimiters"), $3); }
1087                 | /*EMPTY*/
1088                         { $$ = EMPTY; }
1089                 ;
1090
1091 opt_using:      USING           { $$ = make_str("using"); }
1092                 | /* EMPTY */   { $$ = EMPTY; }
1093                 ;
1094
1095 /*****************************************************************************
1096  *
1097  *              QUERY :
1098  *                              CREATE TABLE relname
1099  *
1100  *****************************************************************************/
1101
1102 CreateStmt:  CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')'
1103                                 OptInherit OptWithOids OnCommitOption
1104                         { $$ = cat_str(10, make_str("create"), $2, make_str("table"), $4, make_str("("), $6, make_str(")"), $8, $9, $10); }
1105                 | CREATE OptTemp TABLE qualified_name OF qualified_name
1106                         '(' OptTableElementList ')' OptWithOids OnCommitOption
1107                         { $$ = cat_str(11, make_str("create"), $2, make_str("table"), $4, make_str("of"), $6, make_str("("), $8, make_str(")"), $10, $11); }
1108                 ;
1109
1110 /*
1111  * Redundancy here is needed to avoid shift/reduce conflicts,
1112  * since TEMP is not a reserved word.  See also OptTempTableName.
1113  */
1114
1115 OptTemp: TEMPORARY                      { $$ = make_str("temporary"); }
1116                 | TEMP                          { $$ = make_str("temp"); }
1117                 | LOCAL TEMPORARY       { $$ = make_str("local temporary"); }
1118                 | LOCAL TEMP            { $$ = make_str("local temp"); }
1119                 | GLOBAL TEMPORARY
1120                 {
1121                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE TABLE / GLOBAL TEMPORARY will be passed to backend");
1122                         $$ = make_str("global temporary");
1123                 }
1124                 | GLOBAL TEMP
1125                 {
1126                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE TABLE / GLOBAL TEMP will be passed to backend");
1127                         $$ = make_str("global temp");
1128                 }
1129                 | /*EMPTY*/                     { $$ = EMPTY; }
1130                 ;
1131
1132
1133 OptTableElementList:  TableElementList
1134                         { $$ = $1; }
1135                 | /*EMPTY*/
1136                         { $$ = EMPTY; }
1137                 ;
1138 TableElementList: TableElement
1139                         { $$ = $1; }
1140                 | TableElementList ',' TableElement
1141                         { $$ = cat_str(3, $1, make_str(","), $3); }
1142                 ;
1143
1144 TableElement:  columnDef                { $$ = $1; }
1145                 | TableLikeClause       { $$ = $1; }
1146                 | TableConstraint       { $$ = $1; }
1147                 ;
1148
1149 columnDef:      ColId Typename ColQualList opt_collate
1150                 {
1151                         if (strlen($4) > 0)
1152                         {
1153                                 snprintf(errortext, sizeof(errortext), "Currently unsupported CREATE TABLE / COLLATE %s will be passed to backend", $4);
1154                                 mmerror(PARSE_ERROR, ET_WARNING, errortext);
1155                         }
1156                         $$ = cat_str(4, $1, $2, $3, $4);
1157                 }
1158                 ;
1159
1160 ColQualList:  ColQualList ColConstraint { $$ = cat2_str($1,$2); }
1161                 | /*EMPTY*/                                             { $$ = EMPTY; }
1162                 ;
1163
1164 ColConstraint:  CONSTRAINT name ColConstraintElem
1165                         { $$ = cat_str(3, make_str("constraint"), $2, $3); }
1166                 | ColConstraintElem             { $$ = $1; }
1167                 | ConstraintAttr                { $$ = $1; }
1168                 ;
1169
1170 /* DEFAULT NULL is already the default for Postgres.
1171  * But define it here and carry it forward into the system
1172  * to make it explicit.
1173  * - thomas 1998-09-13
1174  *
1175  * WITH NULL and NULL are not SQL92-standard syntax elements,
1176  * so leave them out. Use DEFAULT NULL to explicitly indicate
1177  * that a column may have that value. WITH NULL leads to
1178  * shift/reduce conflicts with WITH TIME ZONE anyway.
1179  * - thomas 1999-01-08
1180  */
1181 ColConstraintElem:      NOT NULL_P
1182                         { $$ = make_str("not null"); }
1183                 | NULL_P
1184                         { $$ = make_str("null"); }
1185                 | UNIQUE
1186                         { $$ = make_str("unique"); }
1187                 | PRIMARY KEY
1188                         { $$ = make_str("primary key"); }
1189                 | CHECK '(' a_expr ')'
1190                         { $$ = cat_str(3, make_str("check ("), $3, make_str(")")); }
1191                 | DEFAULT b_expr
1192                         { $$ = cat2_str(make_str("default"), $2); }
1193                 |  REFERENCES qualified_name opt_column_list key_match key_actions
1194                         { $$ = cat_str(5, make_str("references"), $2, $3, $4, $5); }
1195                 ;
1196
1197 /*
1198  * ConstraintAttr represents constraint attributes, which we parse as if
1199  * they were independent constraint clauses, in order to avoid shift/reduce
1200  * conflicts (since NOT might start either an independent NOT NULL clause
1201  * or an attribute).  analyze.c is responsible for attaching the attribute
1202  * information to the preceding "real" constraint node, and for complaining
1203  * if attribute clauses appear in the wrong place or wrong combinations.
1204  *
1205  * See also ConstraintAttributeSpec, which can be used in places where
1206  * there is no parsing conflict.
1207  */
1208 ConstraintAttr: DEFERRABLE              { $$ = make_str("deferrable"); }
1209                 | NOT DEFERRABLE                { $$ = make_str("not deferrable"); }
1210                 | INITIALLY DEFERRED    { $$ = make_str("initially deferred"); }
1211                 | INITIALLY IMMEDIATE   { $$ = make_str("initially immediate"); }
1212                 ;
1213
1214 TableLikeClause:  LIKE any_name
1215                         {
1216                                 mmerror(PARSE_ERROR, ET_ERROR, "LIKE in table definitions not yet supported");
1217                                 $$ = cat2_str(make_str("like"), $2);
1218                         }
1219                 ;
1220
1221 /* ConstraintElem specifies constraint syntax which is not embedded into
1222  *      a column definition. ColConstraintElem specifies the embedded form.
1223  * - thomas 1997-12-03
1224  */
1225 TableConstraint:  CONSTRAINT name ConstraintElem
1226                         { $$ = cat_str(3, make_str("constraint"), $2, $3); }
1227                 | ConstraintElem
1228                         { $$ = $1; }
1229                 ;
1230
1231 ConstraintElem:  CHECK '(' a_expr ')'
1232                         { $$ = cat_str(3, make_str("check("), $3, make_str(")")); }
1233                 | UNIQUE '(' columnList ')'
1234                         { $$ = cat_str(3, make_str("unique("), $3, make_str(")")); }
1235                 | PRIMARY KEY '(' columnList ')'
1236                         { $$ = cat_str(3, make_str("primary key("), $4, make_str(")")); }
1237                 | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name opt_column_list
1238                         key_match key_actions ConstraintAttributeSpec
1239                         { $$ = cat_str(8, make_str("foreign key("), $4, make_str(") references"), $7, $8, $9, $10, $11); }
1240                 ;
1241
1242 opt_column_list:  '(' columnList ')'    { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
1243                | /*EMPTY*/              { $$ = EMPTY; }
1244                ;
1245
1246 columnList:  columnList ',' columnElem
1247                                { $$ = cat_str(3, $1, make_str(","), $3); }
1248                | columnElem
1249                                { $$ = $1; }
1250                ;
1251
1252 columnElem:  ColId      { $$ = $1; }
1253                 ;
1254
1255 key_match:      MATCH FULL
1256                         { $$ = make_str("match full"); }
1257                 | MATCH PARTIAL
1258                 {
1259                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported FOREIGN KEY/MATCH PARTIAL will be passed to backend");
1260                         $$ = make_str("match partial");
1261                 }
1262                 | /*EMPTY*/
1263                         { $$ = EMPTY; }
1264                 ;
1265
1266 key_actions:  key_delete                        { $$ = $1; }
1267                 | key_update                            { $$ = $1; }
1268                 | key_delete key_update         { $$ = cat2_str($1, $2); }
1269                 | key_update key_delete         { $$ = cat2_str($1, $2); }
1270                 | /*EMPTY*/                                     { $$ = EMPTY; }
1271                 ;
1272
1273 key_delete: ON DELETE_P key_action
1274                         { $$ = cat2_str(make_str("on delete"), $3); }
1275                 ;
1276
1277 key_update: ON UPDATE key_action
1278                         { $$ = cat2_str(make_str("on update"), $3); }
1279                 ;
1280
1281 key_action:     NO ACTION                       { $$ = make_str("no action"); }
1282                 | RESTRICT                                      { $$ = make_str("restrict"); }
1283                 | CASCADE                                       { $$ = make_str("cascade"); }
1284                 | SET DEFAULT                           { $$ = make_str("set default"); }
1285                 | SET NULL_P                            { $$ = make_str("set null"); }
1286                 ;
1287
1288 OptInherit:  INHERITS '(' qualified_name_list ')'
1289                         { $$ = cat_str(3, make_str("inherits ("), $3, make_str(")")); }
1290                 | /*EMPTY*/
1291                         { $$ = EMPTY; }
1292                 ;
1293
1294 OptWithOids:  WITH OIDS                         { $$ = make_str("with oids"); }
1295                 | WITHOUT OIDS                          { $$ = make_str("without oids"); }
1296                 | /*EMPTY*/                                     { $$ = EMPTY; }
1297                 ;
1298
1299 OnCommitOption:   ON COMMIT DROP                { $$ = make_str("on commit drop"); }
1300                 | ON COMMIT DELETE_P ROWS       { $$ = make_str("on commit delete rows"); }
1301                 | ON COMMIT PRESERVE ROWS       { $$ = make_str("on commit preserve rows"); }
1302                 | /*EMPTY*/                     { $$ = EMPTY; }
1303                 ;
1304
1305
1306 /*
1307  * Note: CREATE TABLE ... AS SELECT ... is just another spelling for
1308  * SELECT ... INTO.
1309  */
1310
1311 CreateAsStmt:  CREATE OptTemp TABLE qualified_name OptCreateAs AS
1312                 { FoundInto = 0; }
1313                 SelectStmt
1314                 {
1315                         if (FoundInto == 1)
1316                                 mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE / AS SELECT may not specify INTO");
1317
1318                         $$ = cat_str(7, make_str("create"), $2, make_str("table"), $4, $5, make_str("as"), $8);
1319                 }
1320                 ;
1321
1322 OptCreateAs:  '(' CreateAsList ')'
1323                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
1324                 | /*EMPTY*/
1325                         { $$ = EMPTY; }
1326                 ;
1327
1328 CreateAsList:  CreateAsList ',' CreateAsElement
1329                         { $$ = cat_str(3, $1, make_str(","), $3); }
1330                 | CreateAsElement
1331                         { $$ = $1; }
1332                 ;
1333
1334 CreateAsElement:  ColId { $$ = $1; }
1335                 ;
1336
1337 /*****************************************************************************
1338  *
1339  *              QUERY :
1340  *                              CREATE SEQUENCE seqname
1341  *
1342  *****************************************************************************/
1343
1344 CreateSeqStmt:  CREATE OptTemp SEQUENCE qualified_name OptSeqList
1345                         { $$ = cat_str(4, make_str("create sequence"), $2, $4, $5); }
1346                 ;
1347
1348 OptSeqList:  OptSeqList OptSeqElem      { $$ = cat2_str($1, $2); }
1349                 | /*EMPTY*/                                     { $$ = EMPTY; }
1350                 ;
1351
1352 OptSeqElem:  CACHE NumConst
1353                         { $$ = cat2_str(make_str("cache"), $2); }
1354                 | CYCLE
1355                         { $$ = make_str("cycle"); }
1356                 | NO CYCLE
1357                         { $$ = make_str("no cycle"); }
1358                 | INCREMENT opt_by NumConst
1359                         { $$ = cat_str(3, make_str("increment"), $2, $3); }
1360                 | MAXVALUE NumConst
1361                         { $$ = cat2_str(make_str("maxvalue"), $2); }
1362                 | MINVALUE NumConst
1363                         { $$ = cat2_str(make_str("minvalue"), $2); }
1364                 | NO MAXVALUE
1365                         { $$ = make_str("no maxvalue"); }
1366                 | NO MINVALUE
1367                         { $$ = make_str("no minvalue"); }
1368                 | START opt_with NumConst
1369                         { $$ = cat_str(3, make_str("start"), $2, $3); }
1370                 ;
1371
1372 opt_by:         BY      { $$ = make_str("by"); }
1373                 | /*EMPTY*/     { $$ = EMPTY; }
1374                 ;
1375
1376 /*****************************************************************************
1377  *
1378  *              QUERIES :
1379  *                              CREATE PROCEDURAL LANGUAGE ...
1380  *                              DROP PROCEDURAL LANGUAGE ...
1381  *
1382  *****************************************************************************/
1383
1384 CreatePLangStmt:  CREATE opt_Trusted opt_procedural LANGUAGE ColId_or_Sconst
1385                         HANDLER handler_name opt_lancompiler
1386                         { $$ = cat_str(8, make_str("create"), $2, $3, make_str("language"), $5, make_str("handler"), $7, $8); }
1387                 ;
1388
1389 opt_Trusted:    TRUSTED { $$ = make_str("trusted"); }
1390                 | /*EMPTY*/             { $$ = EMPTY; }
1391                 ;
1392
1393 /* This ought to be just func_name, but that causes reduce/reduce conflicts
1394  * (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
1395  * Work around by using name and dotted_name separately.
1396  */
1397 handler_name: name
1398                                { $$ = $1; }
1399         | dotted_name
1400                                { $$ = $1; /* XXX changing soon */ }
1401                ;
1402
1403 opt_lancompiler: LANCOMPILER StringConst
1404                         { $$ = cat2_str(make_str("lancompiler"), $2); }
1405                 | /*EMPTY*/
1406                         { $$ = ""; }
1407                 ;
1408
1409 DropPLangStmt:  DROP opt_procedural LANGUAGE StringConst opt_drop_behavior
1410                         { $$ = cat_str(5, make_str("drop"), $2, make_str("language"), $4, $5); }
1411                 ;
1412
1413 opt_procedural: PROCEDURAL      { $$ = make_str("prcedural"); }
1414                 | /*EMPTY*/                     { $$ = EMPTY; }
1415                 ;
1416
1417 /*****************************************************************************
1418  *
1419  *              QUERIES :
1420  *                              CREATE TRIGGER ...
1421  *                              DROP TRIGGER ...
1422  *
1423  *****************************************************************************/
1424
1425 CreateTrigStmt:  CREATE TRIGGER name TriggerActionTime TriggerEvents ON
1426                                 qualified_name TriggerForSpec
1427                                 EXECUTE PROCEDURE
1428                                 name '(' TriggerFuncArgs ')'
1429                         { $$ = cat_str(12, make_str("create trigger"), $3, $4, $5, make_str("on"), $7, $8, make_str("execute procedure"), $11, make_str("("), $13, make_str(")")); }
1430                 |       CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
1431                                 qualified_name OptConstrFromTable
1432                                 ConstraintAttributeSpec
1433                                 FOR EACH ROW EXECUTE PROCEDURE
1434                                 func_name '(' TriggerFuncArgs ')'
1435                         { $$ = cat_str(13, make_str("create constraint trigger"), $4, make_str("after"), $6, make_str("on"), $8, $9, $10, make_str("for each row execute procedure"), $16, make_str("("), $18, make_str(")")); }
1436                 ;
1437
1438 TriggerActionTime:      BEFORE          { $$ = make_str("before"); }
1439                 | AFTER                                 { $$ = make_str("after"); }
1440                 ;
1441
1442 TriggerEvents:  TriggerOneEvent
1443                         { $$ = $1; }
1444                 | TriggerOneEvent OR TriggerOneEvent
1445                         { $$ = cat_str(3, $1, make_str("or"), $3); }
1446                 | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
1447                         { $$ = cat_str(5, $1, make_str("or"), $3, make_str("or"), $5); }
1448                 ;
1449
1450 TriggerOneEvent:  INSERT        { $$ = make_str("insert"); }
1451                 | DELETE_P                      { $$ = make_str("delete"); }
1452                 | UPDATE                        { $$ = make_str("update"); }
1453                 ;
1454
1455 TriggerForSpec:  FOR TriggerForOpt TriggerForType
1456                         { $$ = cat_str(3, make_str("for"), $2, $3); }
1457                 | /* EMPTY */
1458                         { $$ = EMPTY; }
1459                 ;
1460
1461 TriggerForOpt:  EACH            { $$ = make_str("each"); }
1462                 | /*EMPTY*/                     { $$ = EMPTY; }
1463                 ;
1464
1465 TriggerForType:  ROW            { $$ = make_str("row"); }
1466                 | STATEMENT                     { $$ = make_str("statement"); }
1467                 ;
1468
1469 TriggerFuncArgs:  TriggerFuncArg
1470                         { $$ = $1; }
1471                 | TriggerFuncArgs ',' TriggerFuncArg
1472                         { $$ = cat_str(3, $1, make_str(","), $3); }
1473                 | /*EMPTY*/
1474                         { $$ = EMPTY; }
1475                 ;
1476
1477 TriggerFuncArg:  PosAllConst    { $$ = $1; }
1478                 | ColId         { $$ = $1; }
1479                 ;
1480
1481 OptConstrFromTable: /* Empty */         { $$ = EMPTY; }
1482                 | FROM qualified_name   { $$ = cat2_str(make_str("from"), $2); }
1483                 ;
1484
1485 ConstraintAttributeSpec: ConstraintDeferrabilitySpec    { $$ = $1; }
1486                 | ConstraintDeferrabilitySpec ConstraintTimeSpec
1487                 {
1488                         if (strcmp($1, "deferrable") != 0 && strcmp($2, "initially deferrable") == 0 )
1489                                 mmerror(PARSE_ERROR, ET_ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
1490
1491                         $$ = cat2_str($1, $2);
1492                 }
1493                 | ConstraintTimeSpec            { $$ = $1; }
1494                 | ConstraintTimeSpec ConstraintDeferrabilitySpec
1495                 {
1496                         if (strcmp($2, "deferrable") != 0 && strcmp($1, "initially deferrable") == 0 )
1497                                 mmerror(PARSE_ERROR, ET_ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
1498
1499                         $$ = cat2_str($1, $2);
1500                 }
1501                 ;
1502
1503 ConstraintDeferrabilitySpec: NOT DEFERRABLE
1504                         { $$ = make_str("not deferrable"); }
1505                 | DEFERRABLE
1506                         { $$ = make_str("deferrable"); }
1507                 ;
1508
1509 ConstraintTimeSpec: INITIALLY IMMEDIATE
1510                         { $$ = make_str("initially immediate"); }
1511                 | INITIALLY DEFERRED
1512                         { $$ = make_str("initially deferred"); }
1513                 ;
1514
1515 DropTrigStmt:  DROP TRIGGER name ON qualified_name opt_drop_behavior
1516                         { $$ = cat_str(5, make_str("drop trigger"), $3, make_str("on"), $5, $6); }
1517                 ;
1518
1519 /*****************************************************************************
1520  *
1521  *             QUERIES :
1522  *                             CREATE ASSERTION ...
1523  *                             DROP ASSERTION ...
1524  *
1525  *****************************************************************************/
1526 CreateAssertStmt:  CREATE ASSERTION name
1527                        CHECK '(' a_expr ')' ConstraintAttributeSpec
1528                         {
1529                                 mmerror(PARSE_ERROR, ET_ERROR, "CREATE ASSERTION is not yet supported");
1530                                 $$ = cat_str(6, make_str("create assertion"), $3, make_str("check ("), $6, make_str(")"), $8);
1531                         }
1532                 ;
1533
1534 DropAssertStmt:  DROP ASSERTION name
1535         {
1536                 mmerror(PARSE_ERROR, ET_ERROR, "DROP ASSERTION is not yet supported");
1537                 $$ = cat2_str(make_str("drop assertion"), $3);
1538         }
1539         ;
1540
1541
1542 /*****************************************************************************
1543  *
1544  *              QUERY :
1545  *                              define (type,operator,aggregate)
1546  *
1547  *****************************************************************************/
1548
1549 DefineStmt:  CREATE AGGREGATE func_name definition
1550                         { $$ = cat_str(3, make_str("create aggregate"), $3, $4); }
1551                 | CREATE OPERATOR all_Op definition
1552                         { $$ = cat_str(3, make_str("create operator"), $3, $4); }
1553                 | CREATE TYPE_P any_name definition
1554                         { $$ = cat_str(3, make_str("create type"), $3, $4); }
1555                 | CREATE TYPE_P any_name AS rowdefinition
1556                         { $$ = cat_str(4, make_str("create type"), $3, make_str("as"), $5); }
1557                 ;
1558
1559 rowdefinition: '(' TableFuncElementList ')'
1560                         { $$ = cat_str(3, make_str("("), $2, make_str(")"));}
1561                 ;
1562
1563 definition:  '(' def_list ')'
1564                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
1565                 ;
1566
1567 def_list:  def_elem                                     { $$ = $1; }
1568                 | def_list ',' def_elem         { $$ = cat_str(3, $1, make_str(","), $3); }
1569                 ;
1570
1571 def_elem:  ColLabel '=' def_arg         { $$ = cat_str(3, $1, make_str("="), $3); }
1572                 | ColLabel                                      { $$ = $1; }
1573                 ;
1574
1575 /* Note: any simple identifier will be returned as a type name! */
1576 def_arg:  func_return                           {  $$ = $1; }
1577                 | qual_all_Op                                   {  $$ = $1; }
1578                 | AllConst                                      {  $$ = $1; }
1579                 ;
1580
1581 CreateOpClassStmt:      CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename
1582                         USING access_method AS opclass_item_list
1583                                 {
1584                                         $$ = cat_str(9, make_str("create operator class"), $4, $5, make_str("for type"), $8, make_str("using"), $10, make_str("as"), $12);
1585                                 }
1586                                 ;
1587
1588 opclass_item_list:      opclass_item            { $$ = $1; }
1589                         | opclass_item_list ',' opclass_item    { $$ = cat_str(3, $1, make_str(","), $3); }
1590                         ;
1591
1592 opclass_item:   OPERATOR PosIntConst any_operator opt_recheck
1593                         { $$ = cat_str(4, make_str("operator"), $2, $3, $4); }
1594                 | OPERATOR PosIntConst any_operator '(' oper_argtypes ')' opt_recheck
1595                         { $$ =  cat_str(7, make_str("operator"), $2, $3, make_str("("), $5, make_str(")"), $7); }
1596                 | FUNCTION PosIntConst func_name func_args
1597                         { $$ = cat_str(4, make_str("function"), $2, $3, $4); }
1598                 | STORAGE Typename
1599                         { $$ = cat2_str(make_str("storage"), $2); }
1600                 ;
1601
1602 opt_default:   DEFAULT  { $$ = make_str("default"); }
1603         |  /*EMPTY*/    { $$ = EMPTY; }
1604         ;
1605
1606 opt_recheck:   RECHECK  { $$ = make_str("recheck"); }
1607         |  /*EMPTY*/    { $$ = EMPTY; }
1608         ;
1609
1610 DropOpClassStmt: DROP OPERATOR CLASS any_name USING access_method opt_drop_behavior
1611                         { $$ = cat_str(5,make_str("drop operator class"), $4, make_str("using"), $6, $7); }
1612                 ;
1613
1614 /*****************************************************************************
1615  *
1616  *              QUERY:
1617  *
1618  *                         DROP itemtype itemname [, itemname ...]
1619  *
1620  *****************************************************************************/
1621
1622 DropStmt:  DROP drop_type any_name_list opt_drop_behavior
1623                         { $$ = cat_str(4, make_str("drop"), $2, $3, $4); }
1624                 ;
1625
1626 drop_type:      TABLE           { $$ = make_str("table"); }
1627                 | SEQUENCE              { $$ = make_str("sequence"); }
1628                 | VIEW                  { $$ = make_str("view"); }
1629                 | INDEX                 { $$ = make_str("index"); }
1630                 | TYPE_P                { $$ = make_str("type"); }
1631                 | DOMAIN_P              { $$ = make_str("domain"); }
1632                 | CONVERSION_P          { $$ = make_str("conversion"); }
1633                 | SCHEMA                { $$ = make_str("schema"); }
1634                 ;
1635
1636 any_name_list:  any_name
1637                        { $$ = $1; }
1638                | any_name_list ',' any_name
1639                        { $$ = cat_str(3, $1, make_str(","), $3); }
1640                ;
1641
1642 any_name: ColId
1643                        { $$ = $1; }
1644                | dotted_name
1645                        { $$ = $1; }
1646                 ;
1647 /*****************************************************************************
1648  *
1649  *                         QUERY:
1650  *                                                         truncate table relname
1651  *
1652  *****************************************************************************/
1653 TruncateStmt:  TRUNCATE opt_table qualified_name
1654                         { $$ = cat_str(3, make_str("truncate table"), $2, $3); }
1655                 ;
1656
1657 /*****************************************************************************
1658  *
1659  *              QUERY:
1660  *                                         fetch/move [forward | backward] [ # | all ] [ in <portalname> ]
1661  *                                         fetch [ forward | backward | absolute | relative ]
1662  *                                                       [ # | all | next | prior ] [ [ in | from ] <portalname> ]
1663  *
1664  *****************************************************************************/
1665
1666 FetchStmt: FETCH direction fetch_how_many from_in name ecpg_into
1667                         { $$ = cat_str(5, make_str("fetch"), $2, $3, $4, $5); }
1668                 | FETCH fetch_how_many from_in name ecpg_into
1669                         { $$ = cat_str(4, make_str("fetch"), $2, $3, $4); }
1670                 | FETCH direction from_in name ecpg_into
1671                         { $$ = cat_str(4, make_str("fetch"), $2, $3, $4); }
1672                 | FETCH from_in name ecpg_into
1673                         { $$ = cat_str(3, make_str("fetch"), $2, $3); }
1674                 | FETCH name ecpg_into
1675                         { $$ = cat2_str(make_str("fetch"), $2); }
1676                 | MOVE direction fetch_how_many from_in name
1677                         { $$ = cat_str(5, make_str("move"), $2, $3, $4, $5); }
1678                 | MOVE fetch_how_many from_in name
1679                         { $$ = cat_str(4, make_str("move"), $2, $3, $4); }
1680                 | MOVE direction from_in name
1681                         { $$ = cat_str(4, make_str("move"), $2, $3, $4); }
1682                 | MOVE from_in name
1683                         { $$ = cat_str(3, make_str("move"), $2, $3); }
1684                 | MOVE name
1685                         { $$ = cat2_str(make_str("move"), $2); }
1686                 ;
1687
1688 direction:      FORWARD         { $$ = make_str("forward"); }
1689                 | BACKWARD              { $$ = make_str("backward"); }
1690                 | RELATIVE              { $$ = make_str("relative"); }
1691                 | ABSOLUTE
1692                 {
1693                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported FETCH/ABSOLUTE will be passed to backend, backend will use RELATIVE");
1694                         $$ = make_str("absolute");
1695                 }
1696                 ;
1697
1698 fetch_how_many: IntConst        { $$ = $1; }
1699                 | ALL           { $$ = make_str("all"); }
1700                 | NEXT          { $$ = make_str("next"); }
1701                 | PRIOR         { $$ = make_str("prior"); }
1702                 ;
1703
1704 from_in: IN_P                           { $$ = make_str("in"); }
1705                 | FROM                          { $$ = make_str("from"); }
1706                 ;
1707
1708 /*****************************************************************************
1709  *
1710  *      The COMMENT ON statement can take different forms based upon the type of
1711  *      the object associated with the comment. The form of the statement is:
1712  *
1713  *      COMMENT ON [ [ DATABASE | DOMAIN | INDEX |  SEQUENCE | TABLE | TYPE | VIEW ]
1714  *                               <objname> | AGGREGATE <aggname> (<aggtype>) | FUNCTION
1715  *                              <funcname> (arg1, arg2, ...) | OPERATOR <op>
1716  *                              (leftoperand_typ rightoperand_typ) | TRIGGER <triggername> ON
1717  *                              <relname> | RULE <rulename> ON <relname> ] IS 'text'
1718  *
1719  *****************************************************************************/
1720 CommentStmt:   COMMENT ON comment_type name IS comment_text
1721                         { $$ = cat_str(5, make_str("comment on"), $3, $4, make_str("is"), $6); }
1722                 | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')' IS comment_text
1723                         { $$ = cat_str(6, make_str("comment on aggregate"), $4, make_str("("), $6, make_str(") is"), $9); }
1724                 | COMMENT ON FUNCTION func_name func_args IS comment_text
1725                         { $$ = cat_str(5, make_str("comment on function"), $4, $5, make_str("is"), $7); }
1726                 | COMMENT ON OPERATOR all_Op '(' oper_argtypes ')' IS comment_text
1727                         { $$ = cat_str(6, make_str("comment on operator"), $4, make_str("("), $6, make_str(") is"), $9); }
1728                 | COMMENT ON TRIGGER name ON any_name IS comment_text
1729                         { $$ = cat_str(6, make_str("comment on trigger"), $4, make_str("on"), $6, make_str("is"), $8); }
1730                 | COMMENT ON RULE name ON any_name IS comment_text
1731                         { $$ = cat_str(6, make_str("comment on rule"), $4, make_str("on"), $6, make_str("is"), $8); }
1732                 | COMMENT ON RULE name IS comment_text
1733                         { $$ = cat_str(4, make_str("comment on rule"), $4, make_str("is"), $6); }
1734                 ;
1735
1736 comment_type:  COLUMN           { $$ = make_str("column"); }
1737                 | DATABASE      { $$ = make_str("database"); }
1738                 | SCHEMA        { $$ = make_str("schema"); }
1739                 | INDEX         { $$ = make_str("idnex"); }
1740                 | SEQUENCE      { $$ = make_str("sequence"); }
1741                 | TABLE         { $$ = make_str("table"); }
1742                 | DOMAIN_P      { $$ = make_str("domain"); }
1743                 | TYPE_P        { $$ = make_str("type"); }
1744                 | VIEW          { $$ = make_str("view"); }
1745                 ;
1746
1747 comment_text:   StringConst { $$ = $1; }
1748                 | NULL_P                        { $$ = make_str("null"); }
1749                 ;
1750
1751 /*****************************************************************************
1752  *
1753  *              QUERY:
1754  * GRANT and REVOKE statements
1755  *
1756  *****************************************************************************/
1757
1758 GrantStmt:      GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option
1759                         { $$ = cat_str(7, make_str("grant"), $2, make_str("on"), $4, make_str("to"), $6, $7); }
1760                 ;
1761
1762 RevokeStmt:  REVOKE opt_revoke_grant_option privileges ON privilege_target FROM grantee_list opt_drop_behavior
1763                         {
1764                           $$ = cat_str(9, make_str("revoke"), $2, $3, make_str("on"), $5, make_str("from"), $7, $8);
1765                         }
1766
1767                 ;
1768
1769 privileges:  ALL PRIVILEGES             { $$ = make_str("all privileges"); }
1770                 | ALL                                   { $$ = make_str("all"); }
1771                 | privilege_list                { $$ = $1; }
1772                 ;
1773
1774 privilege_list:  privilege
1775                         { $$ = $1; }
1776                 | privilege_list ',' privilege
1777                         { $$ = cat_str(3, $1, make_str(","), $3); }
1778                 ;
1779
1780 privilege:      SELECT                  { $$ = make_str("select"); }
1781                 | INSERT                        { $$ = make_str("insert"); }
1782                 | UPDATE                        { $$ = make_str("update"); }
1783                 | DELETE_P                      { $$ = make_str("delete"); }
1784                 | RULE                          { $$ = make_str("rule"); }
1785                 | REFERENCES            { $$ = make_str("references"); }
1786                 | TRIGGER                       { $$ = make_str("trigger"); }
1787                 | EXECUTE                       { $$ = make_str("execute"); }
1788                 | USAGE                         { $$ = make_str("usage"); }
1789                 | CREATE                        { $$ = make_str("create"); }
1790                 | TEMPORARY                     { $$ = make_str("temporary"); }
1791                 | TEMP                          { $$ = make_str("temp"); }
1792                 ;
1793
1794 privilege_target: qualified_name_list
1795                         { $$ = $1; }
1796                 | TABLE qualified_name_list
1797                         { $$ = cat2_str(make_str("table"), $2); }
1798                 | FUNCTION function_with_argtypes_list
1799                         { $$ = cat2_str(make_str("function"), $2); }
1800                 | DATABASE name_list
1801                         { $$ = cat2_str(make_str("database"), $2); }
1802                 | LANGUAGE name_list
1803                         { $$ = cat2_str(make_str("language") , $2); }
1804                 | SCHEMA name_list
1805                         { $$ = cat2_str(make_str("schema") , $2); }
1806                 ;
1807
1808 grantee_list: grantee
1809                         { $$ = $1; }
1810                 | grantee_list ',' grantee
1811                         { $$ = cat_str(3, $1, make_str(","), $3); }
1812                 ;
1813
1814 grantee:  ColId                 { $$ = $1; }
1815                 | GROUP_P ColId         { $$ = cat2_str(make_str("group"), $2); }
1816                 ;
1817
1818 opt_grant_grant_option:  WITH GRANT OPTION
1819                 {
1820                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported GRANT/WITH GRANT OPTION will be passed to backend");
1821                         $$ = make_str("with grant option");
1822                 }
1823                 | /*EMPTY*/     { $$ = EMPTY; }
1824                 ;
1825
1826 opt_revoke_grant_option: GRANT OPTION FOR
1827                 {
1828                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported REVOKE/GRANT OPTION FOR will be passed to backend");
1829                         $$ = make_str("with grant option");
1830                 }
1831                 | /*EMPTY*/     { $$ = EMPTY; }
1832                 ;
1833
1834 function_with_argtypes_list: function_with_argtypes
1835                         { $$ = $1; }
1836                 | function_with_argtypes_list ',' function_with_argtypes
1837                         { $$ = cat_str(3, $1, make_str(","), $3); }
1838                 ;
1839
1840 function_with_argtypes: func_name func_args { $$ = cat2_str($1, $2); };
1841
1842 /*****************************************************************************
1843  *
1844  *              QUERY:
1845  *                              create index <indexname> on <relname>
1846  *                                [ using <access> ] "(" (<col> with <op>)+ ")"
1847  *                                [ where <predicate> ]
1848  *
1849  *****************************************************************************/
1850
1851 IndexStmt:      CREATE index_opt_unique INDEX index_name ON qualified_name
1852                                 access_method_clause '(' index_params ')' where_clause
1853                         { $$ = cat_str(11, make_str("create"), $2, make_str("index"), $4, make_str("on"), $6, $7, make_str("("), $9, make_str(")"), $11); }
1854                 ;
1855
1856 index_opt_unique:  UNIQUE       { $$ = make_str("unique"); }
1857                 | /*EMPTY*/             { $$ = EMPTY; }
1858                 ;
1859
1860 access_method_clause:  USING access_method
1861                         { $$ = cat2_str(make_str("using"), $2); }
1862                 | /*EMPTY*/
1863                         { $$ = EMPTY; }
1864                 ;
1865
1866 index_params:  index_list       { $$ = $1; }
1867                 | func_index            { $$ = $1; }
1868                 ;
1869
1870 index_list:  index_list ',' index_elem
1871                         { $$ = cat_str(3, $1, make_str(","), $3); }
1872                 | index_elem
1873                         { $$ = $1; }
1874                 ;
1875
1876 func_index:  func_name '(' name_list ')' opt_class
1877                         { $$ = cat_str(5, $1, make_str("("), $3, ")", $5); }
1878                 ;
1879
1880 index_elem:  attr_name opt_class
1881                         { $$ = cat2_str($1, $2); }
1882                 ;
1883
1884 opt_class:      any_name        { $$ = $1; }
1885                 | USING any_name        { $$ = cat2_str(make_str("using"), $2); }
1886                 | /*EMPTY*/             { $$ = EMPTY; }
1887                 ;
1888
1889 CreateFunctionStmt:     CREATE opt_or_replace FUNCTION func_name func_args
1890                                         RETURNS func_return createfunc_opt_list opt_definition
1891                         { $$ = cat_str(8, make_str("create"), $2, make_str("function"), $4, $5, make_str("returns"), $7, $8); }
1892                 ;
1893
1894 opt_or_replace:  OR REPLACE             { $$ = make_str("or replace"); }
1895                 | /*EMPTY*/                             { $$ = EMPTY; }
1896                 ;
1897
1898 func_args:      '(' func_args_list ')'
1899                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
1900                 | '(' ')'
1901                         { $$ = make_str("()"); }
1902                 ;
1903
1904 func_args_list:  func_arg
1905                         { $$ = $1; }
1906                 | func_args_list ',' func_arg
1907                         { $$ = cat_str(3, $1, make_str(","), $3); }
1908                 ;
1909
1910 func_arg:  opt_arg func_type
1911                 {
1912                         /* We can catch over-specified arguments here if we want to,
1913                          * but for now better to silently swallow typmod, etc.
1914                          * - thomas 2000-03-22
1915                          */
1916                         $$ = cat2_str($1, $2);
1917                 }
1918                 | func_type             { $$ = $1; }
1919                 ;
1920
1921 opt_arg:  IN_P  { $$ = make_str("in"); }
1922                 | OUT_P
1923                 {
1924                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE FUNCTION/OUT will be passed to backend");
1925
1926                         $$ = make_str("out");
1927                 }
1928                 | INOUT
1929                 {
1930                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE FUNCTION/INOUT will be passed to backend");
1931
1932                         $$ = make_str("inout");
1933                 }
1934                 ;
1935
1936 func_as: StringConst
1937                         { $$ = $1; }
1938                 | StringConst ',' StringConst
1939                         { $$ = cat_str(3, $1, make_str(","), $3); }
1940                 ;
1941
1942 func_return:  func_type
1943                 {
1944                         /* We can catch over-specified arguments here if we want to,
1945                          * but for now better to silently swallow typmod, etc.
1946                          * - thomas 2000-03-22
1947                          */
1948                         $$ = $1;
1949                 }
1950                 ;
1951
1952 func_type:      Typename
1953                         { $$ = $1; }
1954                 | type_name attrs '%' TYPE_P
1955                         { $$ = cat_str(3, $1, $2, make_str("% type")); }
1956                 ;
1957
1958
1959 createfunc_opt_list: createfunc_opt_item
1960                         { $$ = $1; }
1961                 | createfunc_opt_list createfunc_opt_item
1962                         { $$ = cat2_str($1, $2); }
1963                 ;
1964
1965 createfunc_opt_item: AS func_as
1966                                 { $$ = cat2_str(make_str("as"), $2); }
1967                 | LANGUAGE ColId_or_Sconst
1968                                 { $$ = cat2_str(make_str("language"), $2); }
1969                 | IMMUTABLE
1970                                 { $$ = make_str("immutable"); }
1971                 | STABLE
1972                                 { $$ = make_str("stable"); }
1973                 | VOLATILE
1974                                 { $$ = make_str("volatile"); }
1975                 | CALLED ON NULL_P INPUT
1976                                 { $$ = make_str("called on null input"); }
1977                 | RETURNS NULL_P ON NULL_P INPUT
1978                                 { $$ = make_str("returns null on null input"); }
1979                 | STRICT
1980                                 { $$ = make_str("strict"); }
1981                 | EXTERNAL SECURITY DEFINER
1982                                 { $$ = make_str("external security definer"); }
1983                 | EXTERNAL SECURITY INVOKER
1984                                 { $$ = make_str("external security invoker"); }
1985                 | SECURITY DEFINER
1986                                 { $$ = make_str("security definer"); }
1987                 | SECURITY INVOKER
1988                                 { $$ = make_str("security invoker"); }
1989                 ;
1990
1991 opt_definition: WITH definition { $$ = cat2_str(make_str("with"), $2); }
1992                 | /*EMPTY*/     { $$ = EMPTY; }
1993                 ;
1994
1995 /*****************************************************************************
1996  *
1997  *              QUERY:
1998  *
1999  *                         DROP FUNCTION funcname (arg1, arg2, ...)
2000  *                         DROP AGGREGATE aggname (aggtype)
2001  *                         DROP OPERATOR opname (leftoperand_typ rightoperand_typ)
2002  *
2003  *****************************************************************************/
2004
2005 RemoveFuncStmt:  DROP FUNCTION func_name func_args opt_drop_behavior
2006                         { $$ = cat_str(4, make_str("drop function"), $3, $4, $5); }
2007                 ;
2008
2009 RemoveAggrStmt:  DROP AGGREGATE func_name '(' aggr_argtype ')' opt_drop_behavior
2010                         { $$ = cat_str(6, make_str("drop aggregate"), $3, make_str("("), $5, make_str(")"), $7); }
2011                 ;
2012
2013 aggr_argtype:  Typename         { $$ = $1; }
2014                 | '*'                           { $$ = make_str("*"); }
2015                 ;
2016
2017
2018 RemoveOperStmt:  DROP OPERATOR all_Op '(' oper_argtypes ')' opt_drop_behavior
2019                         { $$ = cat_str(6, make_str("drop operator"), $3, make_str("("), $5, make_str(")"), $7); }
2020                 ;
2021
2022 oper_argtypes:  Typename
2023                         { mmerror(PARSE_ERROR, ET_ERROR, "parser: argument type missing (use NONE for unary operators)"); }
2024                 | Typename ',' Typename
2025                         { $$ = cat_str(3, $1, make_str(","), $3); }
2026                 | NONE ',' Typename                     /* left unary */
2027                         { $$ = cat2_str(make_str("none,"), $3); }
2028                 | Typename ',' NONE                     /* right unary */
2029                         { $$ = cat2_str($1, make_str(", none")); }
2030                 ;
2031
2032 any_operator:
2033                         all_Op
2034                                 { $$ = $1; }
2035                         | ColId '.' any_operator
2036                                 { $$ = cat_str(3, $1, make_str("."), $3); }
2037                         ;
2038
2039 CreateCastStmt:         CREATE CAST '(' Typename AS Typename ')'
2040                                 WITH FUNCTION function_with_argtypes cast_context
2041                         { $$ = cat_str(6, make_str("create cast ("), $4, make_str("as"), $6, make_str(") with function"), $10); }
2042                         | CREATE CAST '(' Typename AS Typename ')'
2043                                 WITHOUT FUNCTION cast_context
2044                         { $$ = cat_str(6, make_str("create cast ("), $4, make_str("as"), $6, make_str(") without function"), $10); }
2045                 ;
2046
2047 cast_context: AS ASSIGNMENT   { $$ = make_str("as assignment"); }
2048                 | /*EMPTY*/     { $$ = EMPTY; }
2049                 ;
2050
2051
2052 DropCastStmt: DROP CAST '(' Typename AS Typename ')' opt_drop_behavior
2053                         { $$ = cat_str(6, make_str("drop cast ("), $4, make_str("as"), $6, make_str(")"), $8); }
2054                 ;
2055
2056 /*****************************************************************************
2057  *
2058  *                              QUERY:
2059  *
2060  *                              REINDEX type <typename> [FORCE] [ALL]
2061  *
2062  *****************************************************************************/
2063 ReindexStmt:  REINDEX reindex_type qualified_name opt_force
2064                         { $$ = cat_str(4, make_str("reindex"), $2, $3, $4); }
2065                 | REINDEX DATABASE name opt_force
2066                         { $$ = cat_str(3, make_str("reindex database"), $3, $4); }
2067                 ;
2068
2069 reindex_type:   INDEX           { $$ = make_str("index"); }
2070                 | TABLE         { $$ = make_str("table"); }
2071                 ;
2072
2073 opt_force: FORCE                        { $$ = make_str("force"); }
2074                 | /* EMPTY */           { $$ = EMPTY; }
2075                 ;
2076
2077 /*****************************************************************************
2078  *
2079  *              QUERY:
2080  *                              rename <attrname1> in <relname> [*] to <attrname2>
2081  *                              rename <relname1> to <relname2>
2082  *
2083  *****************************************************************************/
2084
2085 RenameStmt:  ALTER TABLE relation_expr RENAME opt_column opt_name TO name
2086                         { $$ = cat_str(7, make_str("alter table"), $3, make_str("rename"), $5, $6, make_str("to"), $8); }
2087         | ALTER TRIGGER name ON relation_expr RENAME TO name
2088                         { $$ = cat_str(6, make_str("alter trigger"), $3, make_str("on"), $5, make_str("rename to"), $8); }
2089                 ;
2090
2091 opt_name:  name                         { $$ = $1; }
2092                 | /*EMPTY*/                     { $$ = EMPTY; }
2093                 ;
2094
2095 opt_column:  COLUMN                     { $$ = make_str("column"); }
2096                 | /*EMPTY*/                     { $$ = EMPTY; }
2097                 ;
2098
2099
2100 /*****************************************************************************
2101  *
2102  *              QUERY:  Define Rewrite Rule
2103  *
2104  *****************************************************************************/
2105
2106 RuleStmt:  CREATE opt_or_replace RULE name AS
2107                    { QueryIsRule=1; }
2108                    ON event TO qualified_name where_clause
2109                    DO opt_instead RuleActionList
2110                 {
2111                         QueryIsRule=0;
2112                         $$ = cat_str(12, make_str("create"), $2, make_str("rule"), $4, make_str("as on"), $8, make_str("to"), $10, $11, make_str("do"), $13, $14);
2113                 }
2114                 ;
2115
2116 RuleActionList:  NOTHING                                { $$ = make_str("nothing"); }
2117                 | RuleActionStmt                                { $$ = $1; }
2118                 | '(' RuleActionMulti ')'               { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2119                                 ;
2120
2121 /* the thrashing around here is to discard "empty" statements... */
2122 RuleActionMulti:  RuleActionMulti ';' RuleActionStmtOrEmpty
2123                         {  $$ = cat_str(3, $1, make_str(";"), $3); }
2124                 | RuleActionStmtOrEmpty
2125                         { $$ = cat2_str($1, make_str(";")); }
2126                 ;
2127
2128 RuleActionStmt:   SelectStmt
2129                 | InsertStmt
2130                 | UpdateStmt
2131                 | DeleteStmt
2132                 | NotifyStmt
2133                 ;
2134
2135 RuleActionStmtOrEmpty: RuleActionStmt   { $$ = $1; }
2136            | /*EMPTY*/                                          { $$ = EMPTY; }
2137            ;
2138
2139 /* change me to select, update, etc. some day */
2140 event:  SELECT                          { $$ = make_str("select"); }
2141                 | UPDATE                        { $$ = make_str("update"); }
2142                 | DELETE_P                      { $$ = make_str("delete"); }
2143                 | INSERT                        { $$ = make_str("insert"); }
2144                  ;
2145
2146 opt_instead:  INSTEAD           { $$ = make_str("instead"); }
2147                 | /*EMPTY*/                     { $$ = EMPTY; }
2148                 ;
2149
2150 DropRuleStmt:  DROP RULE name ON qualified_name opt_drop_behavior
2151                 { $$ = cat_str(5, make_str("drop rule"), $3, make_str("on"), $5, $6);}
2152                 ;
2153
2154 /*****************************************************************************
2155  *
2156  *              QUERY:
2157  *                              NOTIFY <qualified_name> can appear both in rule bodies and
2158  *                              as a query-level command
2159  *
2160  *****************************************************************************/
2161
2162 NotifyStmt:  NOTIFY qualified_name
2163                 { $$ = cat2_str(make_str("notify"), $2); }
2164                 ;
2165
2166 ListenStmt:  LISTEN qualified_name
2167                 { $$ = cat2_str(make_str("listen"), $2); }
2168                 ;
2169
2170 UnlistenStmt:  UNLISTEN qualified_name
2171                         { $$ = cat2_str(make_str("unlisten"), $2); }
2172                 | UNLISTEN '*'
2173                         { $$ = make_str("unlisten *"); }
2174                 ;
2175
2176
2177 /*****************************************************************************
2178  *
2179  *                              Transactions:
2180  *
2181  *        BEGIN / COMMIT / ROLLBACK
2182  *              (also older versions END / ABORT)
2183  *
2184  *****************************************************************************/
2185 TransactionStmt:  ABORT_P opt_transaction               { $$ = make_str("rollback"); }
2186                 | BEGIN_P opt_transaction               { $$ = make_str("begin transaction"); }
2187                 | START TRANSACTION transaction_mode_list_or_empty      { $$ = cat2_str(make_str("start transaction"), $3); }
2188                 | COMMIT opt_transaction                { $$ = make_str("commit"); }
2189                 | END_P opt_transaction         { $$ = make_str("commit"); }
2190                 | ROLLBACK opt_transaction              { $$ = make_str("rollback"); }
2191                 ;
2192
2193 opt_transaction: WORK                   { $$ = EMPTY; }
2194                 | TRANSACTION   { $$ = EMPTY; }
2195                 | /*EMPTY*/             { $$ = EMPTY; }
2196                 ;
2197
2198 transaction_mode_list:
2199         ISOLATION LEVEL iso_level
2200         { $$ = cat2_str(make_str("isolation level"), $3); }
2201         | transaction_access_mode
2202         { $$ = $1; }
2203         | ISOLATION LEVEL iso_level transaction_access_mode
2204         { $$ = cat_str(3, make_str("isolation level"), $3, $4); }
2205         | transaction_access_mode ISOLATION LEVEL iso_level
2206         { $$ = cat_str(3, $1, make_str("isolation level"), $4); }
2207         ;
2208
2209 transaction_mode_list_or_empty:
2210         transaction_mode_list   { $$ = $1; }
2211         | /* EMPTY */           { $$ = EMPTY; }
2212         ;
2213
2214 transaction_access_mode:
2215         READ ONLY       { $$ = make_str("read only"); }
2216         | READ WRITE    { $$ = make_str("read write"); }
2217         ;
2218
2219 /*****************************************************************************
2220  *
2221  *              QUERY:
2222  *                              define view <viewname> '('target-list ')' [where <quals> ]
2223  *
2224  *****************************************************************************/
2225
2226 ViewStmt:  CREATE opt_or_replace VIEW qualified_name opt_column_list AS SelectStmt
2227                         { $$ = cat_str(7, make_str("create"), $2, make_str("view"), $4, $5, make_str("as"), $7); }
2228                 ;
2229
2230
2231 /*****************************************************************************
2232  *
2233  *              QUERY:
2234  *                              load make_str("filename")
2235  *
2236  *****************************************************************************/
2237
2238 LoadStmt:  LOAD file_name
2239                         { $$ = cat2_str(make_str("load"), $2); }
2240                 ;
2241
2242
2243 /*****************************************************************************
2244  *
2245  *              CREATE DATABASE
2246  *
2247  *
2248  *****************************************************************************/
2249
2250 CreatedbStmt:  CREATE DATABASE database_name WITH createdb_opt_list
2251                         { $$ = cat_str(4, make_str("create database"), $3, make_str("with"), $5); }
2252                 | CREATE DATABASE database_name
2253                         { $$ = cat2_str(make_str("create database"), $3); }
2254                 ;
2255
2256 createdb_opt_list:      createdb_opt_item
2257                         { $$ = $1; }
2258                 | createdb_opt_list createdb_opt_item
2259                         { $$ = cat2_str($1, $2); }
2260                 ;
2261
2262 createdb_opt_item:      LOCATION opt_equal StringConst
2263                         { $$ = cat_str(3,make_str("location"), $2, $3); }
2264                 | LOCATION opt_equal DEFAULT
2265                         { $$ = cat_str(3, make_str("location"), $2, make_str("default")); }
2266                 | TEMPLATE opt_equal name
2267                         { $$ = cat_str(3, make_str("template"), $2, $3); }
2268                 | TEMPLATE opt_equal DEFAULT
2269                         { $$ = cat_str(3, make_str("template"), $2, make_str("default")); }
2270                 | ENCODING opt_equal PosIntStringConst
2271                         { $$ = cat_str(3, make_str("encoding"), $2, $3); }
2272                 | ENCODING opt_equal DEFAULT
2273                         { $$ = cat_str(3, make_str("encoding"), $2, make_str("default")); }
2274                 | OWNER opt_equal name
2275                         { $$ = cat_str(3, make_str("owner"), $2, $3); }
2276                 | OWNER opt_equal DEFAULT
2277                         { $$ = cat_str(3, make_str("owner"), $2, make_str("default")); }
2278                 ;
2279
2280 opt_equal: '='                                  { $$ = make_str("="); }
2281                 | /* EMPTY */                   { $$ = EMPTY; }
2282                 ;
2283
2284
2285 /*****************************************************************************
2286  *
2287  *                              ALTER DATABASE
2288  *
2289  *
2290  *****************************************************************************/
2291
2292 AlterDatabaseSetStmt: ALTER DATABASE database_name SET set_rest
2293                         { $$ = cat_str(4, make_str("alter database"), $3, make_str("set"), $5); }
2294                 | ALTER DATABASE database_name VariableResetStmt
2295                         { $$ = cat_str(3, make_str("alter database"), $3, $4); }
2296                 ;
2297
2298 /*****************************************************************************
2299  *
2300  *              DROP DATABASE
2301  *
2302  *
2303  *****************************************************************************/
2304
2305 DropdbStmt: DROP DATABASE database_name
2306                         { $$ = cat2_str(make_str("drop database"), $3); }
2307                 ;
2308
2309
2310 /*****************************************************************************
2311  *
2312  * Manipulate a domain
2313  *
2314  *****************************************************************************/
2315
2316 CreateDomainStmt:  CREATE DOMAIN_P any_name opt_as Typename ColQualList opt_collate
2317                         {
2318                                 $$ = cat_str(6, make_str("create domain"), $3, $4, $5, $6, $7);
2319                         }
2320                 ;
2321
2322 AlterDomainStmt:
2323         ALTER DOMAIN_P any_name alter_column_default
2324                 { $$ = cat_str(3, make_str("alter domain"), $3, $4); }
2325         | ALTER DOMAIN_P any_name DROP NOT NULL_P
2326                 { $$ = cat_str(3, make_str("alter domain"), $3, make_str("drop not null")); }
2327         | ALTER DOMAIN_P any_name SET NOT NULL_P
2328                 { $$ = cat_str(3, make_str("alter domain"), $3, make_str("set not null")); }
2329         | ALTER DOMAIN_P any_name ADD TableConstraint
2330                 { $$ = cat_str(4, make_str("alter domain"), $3, make_str("add"), $5); }
2331         | ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
2332                 { $$ = cat_str(5, make_str("alter domain"), $3, make_str("drop constraint"), $6, $7); }
2333         | ALTER DOMAIN_P any_name OWNER TO UserId
2334                 { $$ = cat_str(4, make_str("alter domain"), $3, make_str("owner to"), $6); }
2335         ;
2336
2337 opt_as: AS      {$$ = make_str("as"); }
2338         | /* EMPTY */   {$$ = EMPTY; }
2339         ;
2340
2341 CreateConversionStmt:
2342                        CREATE opt_default CONVERSION_P any_name FOR StringConst
2343                        TO StringConst FROM any_name
2344                        { $$ = cat_str(10, make_str("create"), $2, make_str("conversion"), $4, make_str("for"), $6, make_str("to"), $8, make_str("from"), $10); }
2345                        ;
2346
2347 /*****************************************************************************
2348  *
2349  *              QUERY:
2350  *                             cluster <index_name> on <qualified_name>
2351  *                             cluster <qualified_name>
2352  *                             cluster
2353  *
2354  *****************************************************************************/
2355
2356 ClusterStmt:  CLUSTER index_name ON qualified_name
2357                         { $$ = cat_str(4, make_str("cluster"), $2, make_str("on"), $4); }
2358         | CLUSTER qualified_name
2359                         { $$ = cat2_str(make_str("cluster"), $2); }
2360         | CLUSTER
2361                         { $$ = make_str("cluster"); }
2362         ;
2363
2364
2365 /*****************************************************************************
2366  *
2367  *              QUERY:
2368  *                              vacuum
2369  *                              analyze
2370  *
2371  *****************************************************************************/
2372
2373 VacuumStmt:  VACUUM opt_full opt_freeze opt_verbose
2374                         { $$ = cat_str(4, make_str("vacuum"), $2, $3, $4); }
2375                 | VACUUM opt_full opt_freeze opt_verbose qualified_name
2376                         { $$ = cat_str(5, make_str("vacuum"), $2, $3, $4, $5); }
2377                 | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
2378                         { $$ = cat_str(5, make_str("vacuum"), $2, $3, $4, $5); }
2379                 ;
2380
2381 AnalyzeStmt:  analyze_keyword opt_verbose
2382                         { $$ = cat_str(2, $1, $2); }
2383                 | analyze_keyword opt_verbose qualified_name opt_name_list
2384                         { $$ = cat_str(4, $1, $2, $3, $4); }
2385                 ;
2386
2387 analyze_keyword:  ANALYZE               { $$ = make_str("analyze"); }
2388                 | ANALYSE                               { $$ = make_str("analyse"); }
2389                 ;
2390
2391 opt_verbose:  VERBOSE                   { $$ = make_str("verbose"); }
2392                 | /*EMPTY*/                             { $$ = EMPTY; }
2393                 ;
2394
2395 opt_full:  FULL                                 { $$ = make_str("full"); }
2396                 | /*EMPTY*/                             { $$ = EMPTY; }
2397                 ;
2398
2399 opt_freeze:  FREEZE                             { $$ = make_str("freeze"); }
2400                 | /*EMPTY*/                             { $$ = EMPTY; }
2401                 ;
2402
2403 opt_name_list:  '(' name_list ')'
2404                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2405                 | /*EMPTY*/
2406                         { $$ = EMPTY; }
2407                 ;
2408
2409
2410 /*****************************************************************************
2411  *
2412  *              QUERY:
2413  *                              EXPLAIN query
2414  *
2415  *****************************************************************************/
2416
2417 ExplainStmt:  EXPLAIN opt_analyze opt_verbose OptimizableStmt
2418                         { $$ = cat_str(4, make_str("explain"), $2, $3, $4); }
2419 /*              | EXPLAIN opt_analyze opt_verbose ExecuteStmt
2420                         { $$ = cat_str(4, make_str("explain"), $2, $3, $4); }*/
2421                 ;
2422
2423 opt_analyze:
2424         analyze_keyword                 { $$ = $1; }
2425         | /* EMPTY */                   { $$ = EMPTY; }
2426         ;
2427
2428 /*
2429
2430 conflicts with ecpg
2431
2432 PrepareStmt: PREPARE name prep_type_clause AS OptimizableStmt
2433                 { $$ = cat_str(5, make_str("prepare"), $2, $3, make_str("as"), $5); }
2434                 ;
2435
2436 prep_type_clause: '(' prep_type_list ')'        { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2437                         | /* EMPTY * /          { $$ = EMPTY; }
2438                         ;
2439
2440 prep_type_list: Typename                { $$ = $1; }
2441         | prep_type_list ',' Typename   { $$ = cat_str(3, $1, make_str(","), $3); }
2442         ;
2443
2444 ExecuteStmt: EXECUTE name execute_param_clause into_clause
2445                 { $$ = cat_str(4, make_str("execute"), $2, $3, $4); }
2446                 ;
2447
2448 execute_param_clause: '(' expr_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2449                         | /* EMPTY * /          { $$ = EMPTY; }
2450                         ;
2451
2452 DeallocateStmt: DEALLOCATE name         { $$ = cat2_str(make_str("deallocate"), $2); }
2453         | DEALLOCATE PREPARE name       { $$ = cat2_str(make_str("deallocate prepare"), $3); }
2454         ;
2455 */
2456
2457 /*****************************************************************************
2458  *                                                                                                                                                       *
2459  *              Optimizable Stmts:                                                                                                       *
2460  *                                                                                                                                                       *
2461  *              one of the five queries processed by the planner                                         *
2462  *                                                                                                                                                       *
2463  *              [ultimately] produces query-trees as specified                                           *
2464  *              in the query-spec document in ~postgres/ref                                                      *
2465  *                                                                                                                                                       *
2466  *****************************************************************************/
2467
2468 OptimizableStmt:  SelectStmt
2469                 | CursorStmt
2470                 | UpdateStmt
2471                 | InsertStmt
2472                 | DeleteStmt
2473                 ;
2474
2475
2476 /*****************************************************************************
2477  *
2478  *              QUERY:
2479  *                              INSERT STATEMENTS
2480  *
2481  *****************************************************************************/
2482
2483 InsertStmt:  INSERT INTO qualified_name insert_rest
2484                         { $$ = cat_str(3, make_str("insert into"), $3, $4); }
2485                 ;
2486
2487 insert_rest:  VALUES '(' insert_target_list ')'
2488                         { $$ = cat_str(3, make_str("values("), $3, make_str(")")); }
2489                 | DEFAULT VALUES
2490                         { $$ = make_str("default values"); }
2491                 | SelectStmt
2492                         { $$ = $1; }
2493                 | '(' insert_column_list ')' VALUES '(' insert_target_list ')'
2494                         { $$ = cat_str(5, make_str("("), $2, make_str(") values ("), $6, make_str(")")); }
2495                 | '(' insert_column_list ')' SelectStmt
2496                         { $$ = cat_str(4, make_str("("), $2, make_str(")"), $4); }
2497                 ;
2498
2499 insert_column_list: insert_column_list ',' insert_column_item
2500                         { $$ = cat_str(3, $1, make_str(","), $3); }
2501                 | insert_column_item
2502                         { $$ = $1; }
2503                 ;
2504
2505 insert_column_item:  ColId opt_indirection
2506                         { $$ = cat2_str($1, $2); }
2507                 ;
2508
2509
2510 /*****************************************************************************
2511  *
2512  *              QUERY:
2513  *                              DELETE STATEMENTS
2514  *
2515  *****************************************************************************/
2516
2517 DeleteStmt:  DELETE_P FROM relation_expr where_clause
2518                         { $$ = cat_str(3, make_str("delete from"), $3, $4); }
2519                 ;
2520
2521 LockStmt:  LOCK_P opt_table qualified_name_list opt_lock
2522                         { $$ = cat_str(4, make_str("lock"), $2, $3, $4); }
2523                 ;
2524
2525 opt_lock:  IN_P lock_type MODE
2526                         { $$ = cat_str(3, make_str("in"), $2, make_str("mode")); }
2527                 | /*EMPTY*/
2528                         { $$ = EMPTY;}
2529                 ;
2530
2531 lock_type:      ACCESS SHARE            { $$ = make_str("access share"); }
2532                 | ROW SHARE                             { $$ = make_str("access share"); }
2533                 | ROW EXCLUSIVE                 { $$ = make_str("row exclusive"); }
2534                 | SHARE UPDATE EXCLUSIVE { $$ = make_str("share update exclusive"); }
2535                 | SHARE                                 { $$ = make_str("share"); }
2536                 | SHARE ROW EXCLUSIVE   { $$ = make_str("share row exclusive"); }
2537                 | EXCLUSIVE                             { $$ = make_str("exclusive"); }
2538                 | ACCESS EXCLUSIVE              { $$ = make_str("access exclusive"); }
2539                 ;
2540
2541 /*****************************************************************************
2542  *
2543  *              QUERY:
2544  *                              UpdateStmt (UPDATE)
2545  *
2546  *****************************************************************************/
2547
2548 UpdateStmt:  UPDATE relation_expr
2549                                 SET update_target_list
2550                                 from_clause
2551                                 where_clause
2552                         {$$ = cat_str(6, make_str("update"), $2, make_str("set"), $4, $5, $6); }
2553                 ;
2554
2555
2556 /*****************************************************************************
2557  *
2558  *              QUERY:
2559  *                              CURSOR STATEMENTS
2560  *
2561  *****************************************************************************/
2562 CursorStmt:  DECLARE name opt_cursor CURSOR FOR SelectStmt
2563                 {
2564                         struct cursor *ptr, *this;
2565
2566                         for (ptr = cur; ptr != NULL; ptr = ptr->next)
2567                         {
2568                                 if (strcmp($2, ptr->name) == 0)
2569                                 {
2570                                                 /* re-definition is a bug */
2571                                         snprintf(errortext, sizeof(errortext), "cursor %s already defined", $2);
2572                                         mmerror(PARSE_ERROR, ET_ERROR, errortext);
2573                                 }
2574                         }
2575
2576                         this = (struct cursor *) mm_alloc(sizeof(struct cursor));
2577
2578                         /* initial definition */
2579                         this->next = cur;
2580                         this->name = $2;
2581                         this->connection = connection;
2582                         this->command =  cat_str(5, make_str("declare"), mm_strdup($2), $3, make_str("cursor for"), $6);
2583                         this->argsinsert = argsinsert;
2584                         this->argsresult = argsresult;
2585                         argsinsert = argsresult = NULL;
2586
2587                         cur = this;
2588
2589                         $$ = cat_str(3, make_str("/*"), mm_strdup(this->command), make_str("*/"));
2590                 }
2591                 ;
2592
2593 opt_cursor:  BINARY                             { $$ = make_str("binary"); }
2594            | INSENSITIVE                        { $$ = make_str("insensitive"); }
2595            | SCROLL                                     { $$ = make_str("scroll"); }
2596            | INSENSITIVE SCROLL         { $$ = make_str("insensitive scroll"); }
2597            | /*EMPTY*/                          { $$ = EMPTY; }
2598            ;
2599
2600 /*****************************************************************************
2601  *
2602  *              QUERY:
2603  *                              SELECT STATEMENTS
2604  *
2605  *****************************************************************************/
2606
2607 SelectStmt: select_no_parens            %prec UMINUS
2608                         { $$ = $1; }
2609                 |       select_with_parens              %prec UMINUS
2610                         { $$ = $1; }
2611                 ;
2612
2613 select_with_parens: '(' select_no_parens ')'
2614                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2615                 | '(' select_with_parens ')'
2616                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2617                 ;
2618
2619 select_no_parens:          simple_select
2620                         { $$ = $1; }
2621                 | select_clause sort_clause
2622                         { $$ = cat2_str($1, $2); }
2623                 | select_clause opt_sort_clause for_update_clause opt_select_limit
2624                         { $$ = cat_str(4, $1, $2, $3, $4); }
2625                 | select_clause opt_sort_clause select_limit opt_for_update_clause
2626                         { $$ = cat_str(4, $1, $2, $3, $4); }
2627                 ;
2628
2629 select_clause: simple_select            { $$ = $1; }
2630                 | select_with_parens            { $$ = $1; }
2631                 ;
2632
2633 simple_select:  SELECT opt_distinct target_list
2634                                         into_clause from_clause where_clause
2635                                         group_clause having_clause
2636                         { $$ = cat_str(8, make_str("select"), $2, $3, $4, $5, $6, $7, $8); }
2637                 | select_clause UNION opt_all select_clause
2638                         { $$ = cat_str(4, $1, make_str("union"), $3, $4); }
2639                 | select_clause INTERSECT opt_all select_clause
2640                         { $$ = cat_str(4, $1, make_str("intersect"), $3, $4); }
2641                 | select_clause EXCEPT opt_all select_clause
2642                         { $$ = cat_str(4, $1, make_str("except"), $3, $4); }
2643                 ;
2644
2645 into_clause:  INTO OptTempTableName
2646                 {
2647                         FoundInto = 1;
2648                         $$= cat2_str(make_str("into"), $2);
2649                 }
2650                 | ecpg_into                     { $$ = EMPTY; }
2651                 | /*EMPTY*/                     { $$ = EMPTY; }
2652                 ;
2653
2654 /*
2655  * Redundancy here is needed to avoid shift/reduce conflicts,
2656  * since TEMP is not a reserved word.  See also OptTemp.
2657  *
2658  * The result is a cons cell (not a true list!) containing
2659  * a boolean and a table name.
2660  */
2661 OptTempTableName:  TEMPORARY opt_table qualified_name
2662                         { $$ = cat_str(3, make_str("temporary"), $2, $3); }
2663                 | TEMP opt_table qualified_name
2664                         { $$ = cat_str(3, make_str("temp"), $2, $3); }
2665                 | LOCAL TEMPORARY opt_table qualified_name
2666                         { $$ = cat_str(3, make_str("local temporary"), $3, $4); }
2667                 | LOCAL TEMP opt_table qualified_name
2668                         { $$ = cat_str(3, make_str("local temp"), $3, $4); }
2669                 | GLOBAL TEMPORARY opt_table qualified_name
2670                 {
2671                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE TABLE / GLOBAL TEMPORARY will be passed to backend");
2672                         $$ = cat_str(3, make_str("global temporary"), $3, $4);
2673                 }
2674                 | GLOBAL TEMP opt_table qualified_name
2675                 {
2676                         mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported CREATE TABLE / GLOBAL TEMP will be passed to backend");
2677                         $$ = cat_str(3, make_str("global temp"), $3, $4);
2678                 }
2679                 | TABLE qualified_name
2680                         { $$ = cat2_str(make_str("table"), $2); }
2681                 | qualified_name
2682                         { $$ = $1; }
2683                 ;
2684
2685 opt_table:      TABLE                           { $$ = make_str("table"); }
2686                 | /*EMPTY*/                             { $$ = EMPTY; }
2687                 ;
2688
2689 opt_all:  ALL                                   { $$ = make_str("all"); }
2690                 | /*EMPTY*/                             { $$ = EMPTY; }
2691                 ;
2692
2693 opt_distinct:  DISTINCT
2694                         { $$ = make_str("distinct"); }
2695                 | DISTINCT ON '(' expr_list ')'
2696                         { $$ = cat_str(3, make_str("distinct on ("), $4, make_str(")")); }
2697                 | ALL
2698                         { $$ = make_str("all"); }
2699                 | /*EMPTY*/
2700                         { $$ = EMPTY; }
2701                 ;
2702
2703 opt_sort_clause:        sort_clause     { $$ = $1; }
2704                 | /* EMPTY */           { $$ = EMPTY; }
2705                 ;
2706
2707 sort_clause:  ORDER BY sortby_list
2708                         { $$ = cat2_str(make_str("order by"), $3); }
2709                 ;
2710
2711 sortby_list:  sortby                                    { $$ = $1; }
2712                 | sortby_list ',' sortby                { $$ = cat_str(3, $1, make_str(","), $3); }
2713                 ;
2714
2715 sortby: a_expr OptUseOp
2716                         { $$ = cat2_str($1, $2); }
2717                 ;
2718
2719 OptUseOp:  USING all_Op         { $$ = cat2_str(make_str("using"), $2); }
2720                 | ASC                           { $$ = make_str("asc"); }
2721                 | DESC                          { $$ = make_str("desc"); }
2722                 | /*EMPTY*/                     { $$ = EMPTY; }
2723                 ;
2724
2725 select_limit:   LIMIT select_limit_value OFFSET select_offset_value
2726                    { $$ = cat_str(4, make_str("limit"), $2, make_str("offset"), $4); }
2727                 | OFFSET select_offset_value LIMIT select_limit_value
2728                    { $$ = cat_str(4, make_str("offset"), $2, make_str("limit"), $4); }
2729                 | LIMIT select_limit_value
2730                    { $$ = cat2_str(make_str("limit"), $2); }
2731                 | OFFSET select_offset_value
2732                    { $$ = cat2_str(make_str("offset"), $2); }
2733                 | LIMIT select_limit_value ',' select_offset_value
2734                    { mmerror(PARSE_ERROR, ET_WARNING, "No longer supported LIMIT #,# syntax passed to backend."); }
2735                 ;
2736
2737 opt_select_limit:       select_limit    { $$ = $1; }
2738                 | /*EMPTY*/                                     { $$ = EMPTY; }
2739                 ;
2740
2741 select_limit_value: PosIntConst
2742                 {
2743                         if (atoi($1) < 0)
2744                                 mmerror(PARSE_ERROR, ET_ERROR, "LIMIT must not be negative");
2745                         $$ = $1;
2746                 }
2747                 | ALL   { $$ = make_str("all"); }
2748                 | PARAM { $$ = make_name(); }
2749                 ;
2750
2751 select_offset_value:    PosIntConst
2752                 {
2753                         if (atoi($1) < 0)
2754                                 mmerror(PARSE_ERROR, ET_ERROR, "OFFSET must not be negative");
2755                         $$ = $1;
2756                 }
2757                 | PARAM { $$ = make_name(); }
2758                 ;
2759
2760 /*
2761  *      jimmy bell-style recursive queries aren't supported in the
2762  *      current system.
2763  *
2764  *      ...however, recursive addattr and rename supported.  make special
2765  *      cases for these.
2766  */
2767 group_clause:  GROUP_P BY expr_list
2768                         { $$ = cat2_str(make_str("group by"), $3); }
2769                 | /*EMPTY*/
2770                         { $$ = EMPTY; }
2771                 ;
2772
2773 having_clause:  HAVING a_expr
2774                         { $$ = cat2_str(make_str("having"), $2); }
2775                 | /*EMPTY*/
2776                         { $$ = EMPTY; }
2777                 ;
2778
2779 for_update_clause:      FOR UPDATE update_list
2780                         { $$ = make_str("for update"); }
2781                 | FOR READ ONLY
2782                         { $$ = make_str("for read only"); }
2783                 ;
2784
2785 opt_for_update_clause: for_update_clause        { $$ = $1; }
2786                 | /* EMPTY */                                           { $$ = EMPTY; }
2787                 ;
2788
2789 update_list:  OF name_list              { $$ = cat2_str(make_str("of"), $2); }
2790                 | /* EMPTY */                   { $$ = EMPTY; }
2791                 ;
2792
2793 /*****************************************************************************
2794  *
2795  *      clauses common to all Optimizable Stmts:
2796  *              from_clause - allow list of both JOIN expressions and table names
2797  *              where_clause    - qualifications for joins or restrictions
2798  *
2799  *****************************************************************************/
2800
2801 from_clause:    FROM from_list          { $$ = cat2_str(make_str("from"), $2); }
2802                 | /* EMPTY */                           { $$ = EMPTY; }
2803                 ;
2804
2805 from_list:      from_list ',' table_ref { $$ = cat_str(3, $1, make_str(","), $3); }
2806                 | table_ref                                     { $$ = $1; }
2807                 ;
2808
2809 /*
2810  * table_ref is where an alias clause can be attached.  Note we cannot make
2811  * alias_clause have an empty production because that causes parse conflicts
2812  * between table_ref := '(' joined_table ')' alias_clause
2813  * and joined_table := '(' joined_table ')'.  So, we must have the
2814  * redundant-looking productions here instead.
2815  */
2816 table_ref:      relation_expr
2817                         { $$ = $1; }
2818                 | relation_expr alias_clause
2819                         { $$= cat2_str($1, $2); }
2820                 | func_table
2821                         { $$ = $1; }
2822                 | func_table alias_clause
2823                         { $$= cat2_str($1, $2); }
2824                 | func_table AS '(' TableFuncElementList ')'
2825                         { $$=cat_str(4, $1, make_str("as ("), $4, make_str(")")); }
2826                 | func_table AS ColId '(' TableFuncElementList ')'
2827                         { $$=cat_str(6, $1, make_str("as"), $3, make_str("("), $5, make_str(")")); }
2828                 | func_table ColId '(' TableFuncElementList ')'
2829                         { $$=cat_str(5, $1, $2, make_str("("), $4, make_str(")")); }
2830                 | select_with_parens
2831                         {mmerror(PARSE_ERROR, ET_ERROR, "sub-SELECT in FROM must have an alias");}
2832                 | select_with_parens alias_clause
2833                         { $$=cat2_str($1, $2); }
2834                 | joined_table
2835                         { $$ = $1; }
2836                 | '(' joined_table ')' alias_clause
2837                         { $$=cat_str(4, make_str("("), $2, make_str(")"), $4); }
2838                 ;
2839
2840 /*
2841  * It may seem silly to separate joined_table from table_ref, but there is
2842  * method in SQL92's madness: if you don't do it this way you get reduce-
2843  * reduce conflicts, because it's not clear to the parser generator whether
2844  * to expect alias_clause after ')' or not.  For the same reason we must
2845  * treat 'JOIN' and 'join_type JOIN' separately, rather than allowing
2846  * join_type to expand to empty; if we try it, the parser generator can't
2847  * figure out when to reduce an empty join_type right after table_ref.
2848  *
2849  * Note that a CROSS JOIN is the same as an unqualified
2850  * INNER JOIN, and an INNER JOIN/ON has the same shape
2851  * but a qualification expression to limit membership.
2852  * A NATURAL JOIN implicitly matches column names between
2853  * tables and the shape is determined by which columns are
2854  * in common. We'll collect columns during the later transformations.
2855  */
2856
2857 joined_table:  '(' joined_table ')'
2858                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
2859                 | table_ref CROSS JOIN table_ref
2860                         { $$ = cat_str(3, $1, make_str("cross join"), $4); }
2861                 | table_ref UNIONJOIN table_ref
2862                         { $$ = cat_str(3, $1, make_str("unionjoin"), $3); }
2863                 | table_ref join_type JOIN table_ref join_qual
2864                         { $$ = cat_str(5, $1, $2, make_str("join"), $4, $5); }
2865                 | table_ref JOIN table_ref join_qual
2866                         { $$ = cat_str(4, $1, make_str("join"), $3, $4); }
2867                 | table_ref NATURAL join_type JOIN table_ref
2868                         { $$ = cat_str(5, $1, make_str("natural"), $3, make_str("join"), $5); }
2869                 | table_ref NATURAL JOIN table_ref
2870                         { $$ = cat_str(3, $1, make_str("natural join"), $4); }
2871                 ;
2872
2873 alias_clause:  AS ColId '(' name_list ')'
2874                         { $$ = cat_str(5, make_str("as"), $2, make_str("("), $4, make_str(")")); }
2875                 | AS ColId
2876                         { $$ = cat2_str(make_str("as"), $2); }
2877                 | ColId '(' name_list ')'
2878                         { $$ = cat_str(4, $1, make_str("("), $3, make_str(")")); }
2879                 | ColId
2880                         { $$ = $1; }
2881                 ;
2882
2883 join_type:      FULL join_outer         { $$ = cat2_str(make_str("full"), $2); }
2884                 | LEFT join_outer               { $$ = cat2_str(make_str("left"), $2); }
2885                 | RIGHT join_outer              { $$ = cat2_str(make_str("right"), $2); }
2886                 | INNER_P                               { $$ = make_str("inner"); }
2887                 ;
2888
2889 /* OUTER is just noise... */
2890 join_outer:  OUTER_P                    { $$ = make_str("outer"); }
2891                 | /*EMPTY*/                             { $$ = EMPTY;  /* no qualifiers */ }
2892                 ;
2893
2894 /* JOIN qualification clauses
2895  * Possibilities are:
2896  *      USING ( column list ) allows only unqualified column names,
2897  *                                                which must match between tables.
2898  *      ON expr allows more general qualifications.
2899  */
2900
2901 join_qual:      USING '(' name_list ')'
2902                         { $$ = cat_str(3, make_str("using ("), $3, make_str(")")); }
2903                 | ON a_expr
2904                         { $$ = cat2_str(make_str("on"), $2); }
2905                 ;
2906
2907 relation_expr:  qualified_name
2908                         { /* normal relations */ $$ = $1; }
2909                 | qualified_name '*'
2910                         { /* inheritance query */ $$ = cat2_str($1, make_str("*")); }
2911                 | ONLY qualified_name
2912                         { /* inheritance query */ $$ = cat2_str(make_str("only "), $2); }
2913                 | ONLY '(' qualified_name ')'
2914                         { /* inheritance query */ $$ = cat_str(3, make_str("only ("), $3, make_str(")")); }
2915                 ;
2916
2917 func_table:  func_name '(' ')'
2918                 { $$ = cat2_str($1, make_str("()")); }
2919         | func_name '(' expr_list ')'
2920                 { $$ = cat_str(4, $1, make_str("("), $3, make_str(")")); }
2921         ;
2922
2923 where_clause:  WHERE a_expr             { $$ = cat2_str(make_str("where"), $2); }
2924                 | /*EMPTY*/                             { $$ = EMPTY;  /* no qualifiers */ }
2925                 ;
2926
2927 TableFuncElementList: TableFuncElement
2928                         { $$ = $1; }
2929                 | TableFuncElementList ',' TableFuncElement
2930                         { $$ = cat_str(3, $1, ',', $3); }
2931                 ;
2932
2933 TableFuncElement:       ColId Typename  { $$ = cat2_str($1, $2); }
2934                         ;
2935
2936 /*****************************************************************************
2937  *
2938  *      Type syntax
2939  *              SQL92 introduces a large amount of type-specific syntax.
2940  *              Define individual clauses to handle these cases, and use
2941  *               the generic case to handle regular type-extensible Postgres syntax.
2942  *              - thomas 1997-10-10
2943  *
2944  *****************************************************************************/
2945
2946 Typename:  SimpleTypename opt_array_bounds
2947                         { $$ = cat2_str($1, $2.str); }
2948                 | SETOF SimpleTypename opt_array_bounds
2949                         { $$ = cat_str(3, make_str("setof"), $2, $3); }
2950                 ;
2951
2952
2953 opt_array_bounds:  '[' ']' opt_array_bounds
2954                 {
2955                         $$.index1 = 0;
2956                         $$.index2 = $3.index1;
2957                         $$.str = cat2_str(make_str("[]"), $3.str);
2958                 }
2959                 | '[' Iresult ']' opt_array_bounds
2960                 {
2961                         char *txt = mm_alloc(20L);
2962
2963                         sprintf (txt, "%d", $2);
2964                         $$.index1 = $2;
2965                         $$.index2 = $4.index1;
2966                         $$.str = cat_str(4, make_str("["), txt, make_str("]"), $4.str);
2967                 }
2968                 | /* EMPTY */
2969                 {
2970                         $$.index1 = -1;
2971                         $$.index2 = -1;
2972                         $$.str= EMPTY;
2973                 }
2974                 ;
2975
2976 Iresult:        PosIntConst                             { $$ = atol($1); }
2977                 |       '(' Iresult ')'                 { $$ = $2; }
2978                 |       Iresult '+' Iresult             { $$ = $1 + $3; }
2979                 |       Iresult '-' Iresult             { $$ = $1 - $3; }
2980                 |       Iresult '*' Iresult             { $$ = $1 * $3; }
2981                 |       Iresult '/' Iresult             { $$ = $1 / $3; }
2982                 |       Iresult '%' Iresult             { $$ = $1 % $3; }
2983                 ;
2984
2985 SimpleTypename:  GenericType            { $$ = $1; }
2986                 | ConstDatetime         { $$ = $1; }
2987                 | Numeric               { $$ = $1; }
2988                 | Bit                   { $$ = $1; }
2989                 | Character             { $$ = $1; }
2990                 | ConstInterval opt_interval
2991                         { $$ = cat2_str($1, $2); }
2992                 | ConstInterval '(' PosIntConst ')' opt_interval
2993                         { $$ = cat_str(5, $1, make_str("("), $3, make_str(")"), $5); }
2994                 | type_name attrs
2995                         { $$ = cat2_str($1, $2);}
2996                 ;
2997
2998 ConstTypename:  GenericType             { $$ = $1; }
2999                 | ConstDatetime         { $$ = $1; }
3000                 | Numeric               { $$ = $1; }
3001                 | ConstBit              { $$ = $1; }
3002                 | ConstCharacter        { $$ = $1; }
3003                 ;
3004
3005 GenericType:  type_name                 { $$ = $1; }
3006                 ;
3007
3008 /* SQL92 numeric data types
3009  * Check FLOAT() precision limits assuming IEEE floating types.
3010  * Provide real DECIMAL() and NUMERIC() implementations now - Jan 1998-12-30
3011  * - thomas 1997-09-18
3012  */
3013 Numeric:  INT
3014                         { $$ = make_str("int"); }
3015                 | INTEGER
3016                         { $$ = make_str("integer"); }
3017                 | SMALLINT
3018                         { $$ = make_str("smallint"); }
3019                 | BIGINT
3020                         { $$ = make_str("bigint"); }
3021                 | REAL
3022                         { $$ = make_str("real"); }
3023                 | FLOAT_P opt_float
3024                         { $$ = cat2_str(make_str("float"), $2); }
3025                 | DOUBLE PRECISION
3026                         { $$ = make_str("double precision"); }
3027                 | DECIMAL opt_decimal
3028                         { $$ = cat2_str(make_str("decimal"), $2); }
3029                 | DEC opt_decimal
3030                         { $$ = cat2_str(make_str("dec"), $2); }
3031                 | NUMERIC opt_numeric
3032                         { $$ = cat2_str(make_str("numeric"), $2); }
3033                 | BOOLEAN
3034                         { $$ = make_str("boolean"); }
3035                 ;
3036
3037 opt_float:      '(' PosIntConst ')'
3038                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3039                 | /*EMPTY*/
3040                         { $$ = EMPTY; }
3041                 ;
3042
3043 opt_numeric:  '(' PosIntConst ',' PosIntConst ')'
3044                         { $$ = cat_str(5, make_str("("), $2, make_str(","), $4, make_str(")")); }
3045                 | '(' PosIntConst ')'
3046                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3047                 | /*EMPTY*/
3048                         { $$ = EMPTY; }
3049                 ;
3050
3051 opt_decimal:  '(' PosIntConst ',' PosIntConst ')'
3052                         { $$ = cat_str(5, make_str("("), $2, make_str(","), $4, make_str(")")); }
3053                 | '(' PosIntConst ')'
3054                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3055                 | /*EMPTY*/
3056                         { $$ = EMPTY; }
3057                 ;
3058
3059 /*
3060  * SQL92 bit-field data types
3061  * The following implements BIT() and BIT VARYING().
3062  */
3063
3064 Bit:    BitWithLength           { $$ = $1; }
3065         | BitWithoutLength      { $$ = $1; }
3066         ;
3067
3068 ConstBit:       BitWithLength   { $$ = $1; }
3069                 | BitWithoutLength      { $$ = $1; }
3070                 ;
3071
3072 BitWithLength:  BIT opt_varying '(' PosIntConst ')'
3073                         { $$ = cat_str(5, make_str("bit"), $2, make_str("("), $4, make_str(")")); }
3074                 ;
3075
3076 BitWithoutLength: BIT opt_varying
3077                         { $$ = cat2_str(make_str("bit"), $2); }
3078                 ;
3079
3080 /*
3081  * SQL92 character data types
3082  * The following implements CHAR() and VARCHAR().
3083  *                                                              - ay 6/95
3084  */
3085 Character:      CharacterWithLength             { $$ = $1; }
3086                 | CharacterWithoutLength        { $$ = $1; }
3087                 ;
3088
3089 ConstCharacter: CharacterWithLength     { $$ = $1; }
3090                 | CharacterWithoutLength      { $$ = $1; }
3091                 ;
3092
3093 CharacterWithLength: character '(' PosIntConst ')' opt_charset
3094                         { $$ = cat_str(5, $1, make_str("("), $3, make_str(")"), $5); }
3095                 ;
3096
3097 CharacterWithoutLength: character opt_charset
3098                         { $$ = cat2_str($1, $2); }
3099                 ;
3100
3101 character:      CHARACTER opt_varying
3102                         { $$ = cat2_str(make_str("character"), $2); }
3103                 | CHAR_P opt_varying
3104                         { $$ = cat2_str(make_str("char"), $2); }
3105                 | VARCHAR
3106                         { $$ = make_str("varchar"); }
3107                 | NATIONAL CHARACTER opt_varying
3108                         { $$ = cat2_str(make_str("national character"), $3); }
3109                 | NATIONAL CHAR_P opt_varying
3110                         { $$ = cat2_str(make_str("national char"), $3); }
3111                 | NCHAR opt_varying
3112                         { $$ = cat2_str(make_str("nchar"), $2); }
3113                 ;
3114
3115 opt_varying:  VARYING
3116                         { $$ = make_str("varying"); }
3117                 | /*EMPTY*/
3118                         { $$ = EMPTY; }
3119                 ;
3120
3121 opt_charset:  CHARACTER SET ColId
3122                         { $$ = cat2_str(make_str("character set"), $3); }
3123                 | /*EMPTY*/
3124                         { $$ = EMPTY; }
3125                 ;
3126
3127 opt_collate:  COLLATE ColId
3128                         { $$ = cat2_str(make_str("collate"), $2); }
3129                 | /*EMPTY*/
3130                         { $$ = EMPTY; }
3131                 ;
3132
3133 ConstDatetime:  TIMESTAMP '(' PosIntConst ')' opt_timezone
3134                         { $$ = cat_str(4, make_str("timestamp("), $3, make_str(")"), $5); }
3135                 | TIMESTAMP opt_timezone
3136                         { $$ = cat2_str(make_str("timestamp"), $2); }
3137                 | TIME '(' PosIntConst ')' opt_timezone
3138                         { $$ = cat_str(4, make_str("time("), $3, make_str(")"), $5); }
3139                 | TIME opt_timezone
3140                         { $$ = cat2_str(make_str("time"), $2); }
3141                 ;
3142
3143 ConstInterval:  INTERVAL
3144                         { $$ = make_str("interval"); }
3145                 ;
3146
3147 opt_timezone:  WITH TIME ZONE
3148                         { $$ = make_str("with time zone"); }
3149                 | WITHOUT TIME ZONE
3150                         { $$ = make_str("without time zone"); }
3151                 | /*EMPTY*/
3152                         { $$ = EMPTY; }
3153                 ;
3154
3155 opt_interval:  YEAR_P                   { $$ = make_str("year"); }
3156                 | MONTH_P                               { $$ = make_str("month"); }
3157                 | DAY_P                                 { $$ = make_str("day"); }
3158                 | HOUR_P                                { $$ = make_str("hour"); }
3159                 | MINUTE_P                              { $$ = make_str("minute"); }
3160                 | SECOND_P                              { $$ = make_str("second"); }
3161                 | YEAR_P TO MONTH_P             { $$ = make_str("year to month"); }
3162                 | DAY_P TO HOUR_P               { $$ = make_str("day to hour"); }
3163                 | DAY_P TO MINUTE_P             { $$ = make_str("day to minute"); }
3164                 | DAY_P TO SECOND_P             { $$ = make_str("day to second"); }
3165                 | HOUR_P TO MINUTE_P    { $$ = make_str("hour to minute"); }
3166                 | MINUTE_P TO SECOND_P  { $$ = make_str("minute to second"); }
3167                 | HOUR_P TO SECOND_P    { $$ = make_str("hour to second"); }
3168                 | /*EMPTY*/                             { $$ = EMPTY; }
3169                 ;
3170
3171
3172 /*****************************************************************************
3173  *
3174  *      expression grammar
3175  *
3176  *****************************************************************************/
3177
3178 /* Expressions using row descriptors
3179  * Define row_descriptor to allow yacc to break the reduce/reduce conflict
3180  *      with singleton expressions.
3181  */
3182 r_expr: row IN_P select_with_parens
3183                         { $$ = cat_str(3, $1, make_str("in"), $3); }
3184                 | row NOT IN_P select_with_parens
3185                         { $$ = cat_str(3, $1, make_str("not in"), $4); }
3186                 | row qual_all_Op sub_type select_with_parens %prec Op
3187                         { $$ = cat_str(4, $1, $2, $3, $4); }
3188                 | row qual_all_Op select_with_parens %prec Op
3189                         { $$ = cat_str(3, $1, $2, $3); }
3190                 | row qual_all_Op row %prec Op
3191                         { $$ = cat_str(3, $1, $2, $3); }
3192                 | row IS NULL_P
3193                         { $$ = cat2_str($1, make_str("is null")); }
3194                 | row IS NOT NULL_P
3195                         { $$ = cat2_str($1, make_str("is not null")); }
3196                 | row OVERLAPS row
3197                         { $$ = cat_str(3, $1, make_str("overlaps"), $3); }
3198                 | row IS DISTINCT FROM row %prec IS
3199                         { $$ = cat_str(3, $1, make_str("is distinct from"), $5); }
3200                 ;
3201
3202 row: ROW '(' row_descriptor ')'
3203                 { $$ = cat_str(3, make_str("row ("), $3, make_str(")")); }
3204         | ROW '(' a_expr ')'
3205                 { $$ = cat_str(3, make_str("row ("), $3, make_str(")")); }
3206         | ROW '(' ')'
3207                 { $$ = make_str("row()"); }
3208         | '(' row_descriptor ')'
3209                 { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3210         ;
3211
3212 row_descriptor:  expr_list ',' a_expr
3213                         { $$ = cat_str(3, $1, make_str(","), $3); }
3214                 ;
3215
3216 sub_type:  ANY                                  { $$ = make_str("ANY"); }
3217                 | SOME                                  { $$ = make_str("SOME"); }
3218                 | ALL                                   { $$ = make_str("ALL"); }
3219                           ;
3220
3221 all_Op:  Op                             { $$ = $1; }
3222         | MathOp                        { $$ = $1; }
3223         ;
3224
3225 MathOp: '+'                             { $$ = make_str("+"); }
3226                 | '-'                   { $$ = make_str("-"); }
3227                 | '*'                   { $$ = make_str("*"); }
3228                 | '%'                   { $$ = make_str("%"); }
3229                 | '^'                   { $$ = make_str("^"); }
3230                 | '/'                   { $$ = make_str("/"); }
3231                 | '<'                   { $$ = make_str("<"); }
3232                 | '>'                   { $$ = make_str(">"); }
3233                 | '='                   { $$ = make_str("="); }
3234                 ;
3235
3236 qual_Op:  Op                            { $$ = $1; }
3237                 | OPERATOR '(' any_operator ')' { $$ = cat_str(3, make_str("operator ("), $3, make_str(")")); }
3238                 ;
3239
3240 qual_all_Op:  all_Op                            { $$ = $1; }
3241                 | OPERATOR '(' any_operator ')' { $$ = cat_str(3, make_str("operator ("), $3, make_str(")")); }
3242                 ;
3243
3244 /* General expressions
3245  * This is the heart of the expression syntax.
3246  *
3247  * We have two expression types: a_expr is the unrestricted kind, and
3248  * b_expr is a subset that must be used in some places to avoid shift/reduce
3249  * conflicts.  For example, we can't do BETWEEN as "BETWEEN a_expr AND a_expr"
3250  * because that use of AND conflicts with AND as a boolean operator.  So,
3251  * b_expr is used in BETWEEN and we remove boolean keywords from b_expr.
3252  *
3253  * Note that '(' a_expr ')' is a b_expr, so an unrestricted expression can
3254  * always be used by surrounding it with parens.
3255  *
3256  * c_expr is all the productions that are common to a_expr and b_expr;
3257  * it's factored out just to eliminate redundant coding.
3258  */
3259
3260 a_expr:  c_expr
3261                         { $$ = $1; }
3262                 | a_expr TYPECAST Typename
3263                         { $$ = cat_str(3, $1, make_str("::"), $3); }
3264                 | a_expr AT TIME ZONE c_expr
3265                         { $$ = cat_str(3, $1, make_str("at time zone"), $5); }
3266                 /*
3267                  * These operators must be called out explicitly in order to make use
3268                  * of yacc/bison's automatic operator-precedence handling.  All other
3269                  * operator names are handled by the generic productions using "Op",
3270                  * below; and all those operators will have the same precedence.
3271                  *
3272                  * If you add more explicitly-known operators, be sure to add them
3273                  * also to b_expr and to the MathOp list above.
3274                  */
3275                 | '+' a_expr %prec UMINUS
3276                         { $$ = cat2_str(make_str("+"), $2); }
3277                 | '-' a_expr %prec UMINUS
3278                         { $$ = cat2_str(make_str("-"), $2); }
3279                 | '%' a_expr
3280                         { $$ = cat2_str(make_str("%"), $2); }
3281                 | '^' a_expr
3282                         { $$ = cat2_str(make_str("^"), $2); }
3283                 | a_expr '%'
3284                         { $$ = cat2_str($1, make_str("%")); }
3285                 | a_expr '^'
3286                         { $$ = cat2_str($1, make_str("^")); }
3287                 | a_expr '+' a_expr
3288                         { $$ = cat_str(3, $1, make_str("+"), $3); }
3289                 | a_expr '-' a_expr
3290                         { $$ = cat_str(3, $1, make_str("-"), $3); }
3291                 | a_expr '*' a_expr
3292                         { $$ = cat_str(3, $1, make_str("*"), $3); }
3293                 | a_expr '/' a_expr
3294                         { $$ = cat_str(3, $1, make_str("/"), $3); }
3295                 | a_expr '%' a_expr
3296                         { $$ = cat_str(3, $1, make_str("%"), $3); }
3297                 | a_expr '^' a_expr
3298                         { $$ = cat_str(3, $1, make_str("^"), $3); }
3299                 | a_expr '<' a_expr
3300                         { $$ = cat_str(3, $1, make_str("<"), $3); }
3301                 | a_expr '>' a_expr
3302                         { $$ = cat_str(3, $1, make_str(">"), $3); }
3303                 | a_expr '=' a_expr
3304                         { $$ = cat_str(3, $1, make_str("="), $3); }
3305                 | a_expr qual_Op a_expr         %prec Op
3306                         { $$ = cat_str(3, $1, $2, $3); }
3307                 | qual_Op a_expr                %prec Op
3308                         { $$ = cat2_str($1, $2); }
3309                 | a_expr qual_Op                %prec POSTFIXOP
3310                         { $$ = cat2_str($1, $2); }
3311                 | a_expr AND a_expr
3312                         { $$ = cat_str(3, $1, make_str("and"), $3); }
3313                 | a_expr OR a_expr
3314                         { $$ = cat_str(3, $1, make_str("or"), $3); }
3315                 | NOT a_expr
3316                         { $$ = cat2_str(make_str("not"), $2); }
3317                 | a_expr LIKE a_expr
3318                         { $$ = cat_str(3, $1, make_str("like"), $3); }
3319                 | a_expr LIKE a_expr ESCAPE a_expr
3320                         { $$ = cat_str(5, $1, make_str("like"), $3, make_str("escape"), $5); }
3321                 | a_expr NOT LIKE a_expr
3322                         { $$ = cat_str(3, $1, make_str("not like"), $4); }
3323                 | a_expr NOT LIKE a_expr ESCAPE a_expr
3324                         { $$ = cat_str(5, $1, make_str("not like"), $4, make_str("escape"), $6); }
3325                 | a_expr ILIKE a_expr
3326                         { $$ = cat_str(3, $1, make_str("ilike"), $3); }
3327                 | a_expr ILIKE a_expr ESCAPE a_expr
3328                         { $$ = cat_str(5, $1, make_str("ilike"), $3, make_str("escape"), $5); }
3329                 | a_expr NOT ILIKE a_expr
3330                         { $$ = cat_str(3, $1, make_str("not ilike"), $4); }
3331                 | a_expr NOT ILIKE a_expr ESCAPE a_expr
3332                         { $$ = cat_str(5, $1, make_str("not ilike"), $4, make_str("escape"), $6); }
3333                 | a_expr SIMILAR TO a_expr      %prec SIMILAR
3334                         { $$ = cat_str(3, $1, make_str("similar to"), $4); }
3335                 | a_expr SIMILAR TO a_expr ESCAPE a_expr
3336                         { $$ = cat_str(5, $1, make_str("similar to"), $4, make_str("escape"), $6); }
3337                 | a_expr NOT SIMILAR TO a_expr  %prec SIMILAR
3338                         { $$ = cat_str(3, $1, make_str("not similar to"), $5); }
3339                 | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
3340                         { $$ = cat_str(5, $1, make_str("not similar to"), $5, make_str("escape"), $7); }
3341                 | a_expr ISNULL
3342                         { $$ = cat2_str($1, make_str("isnull")); }
3343                 | a_expr IS NULL_P
3344                         { $$ = cat2_str($1, make_str("is null")); }
3345                 | a_expr NOTNULL
3346                         { $$ = cat2_str($1, make_str("notnull")); }
3347                 | a_expr IS NOT NULL_P
3348                         { $$ = cat2_str($1, make_str("is not null")); }
3349                 /* IS TRUE, IS FALSE, etc used to be function calls
3350                  *      but let's make them expressions to allow the optimizer
3351                  *      a chance to eliminate them if a_expr is a constant string.
3352                  * - thomas 1997-12-22
3353                  *
3354                  *      Created BooleanTest Node type, and changed handling
3355                  *      for NULL inputs
3356                  * - jec 2001-06-18
3357                  */
3358                 | a_expr IS TRUE_P
3359                         { $$ = cat2_str($1, make_str("is true")); }
3360                 | a_expr IS NOT TRUE_P
3361                         { $$ = cat2_str($1, make_str("is not true")); }
3362                 | a_expr IS FALSE_P
3363                         { $$ = cat2_str($1, make_str("is false")); }
3364                 | a_expr IS NOT FALSE_P
3365                         { $$ = cat2_str($1, make_str("is not false")); }
3366                 | a_expr IS UNKNOWN
3367                         { $$ = cat2_str($1, make_str("is unknown")); }
3368                 | a_expr IS NOT UNKNOWN
3369                         { $$ = cat2_str($1, make_str("is not unknown")); }
3370                 | a_expr IS DISTINCT FROM a_expr %prec IS
3371                         { $$ = cat_str(3, $1, make_str("is distinct from"), $5); }
3372                 | a_expr IS OF '(' type_list ')' %prec IS
3373                         { $$ = cat_str(4, $1, make_str("is of ("), $5, make_str(")")); }
3374                 | a_expr IS NOT OF '(' type_list ')' %prec IS
3375                         { $$ = cat_str(4, $1, make_str("is not of ("), $6, make_str(")")); }
3376                 | a_expr BETWEEN b_expr AND b_expr      %prec BETWEEN
3377                         { $$ = cat_str(5, $1, make_str("between"), $3, make_str("and"), $5); }
3378                 | a_expr NOT BETWEEN b_expr AND b_expr  %prec BETWEEN
3379                         { $$ = cat_str(5, $1, make_str("not between"), $4, make_str("and"), $6); }
3380                 | a_expr IN_P in_expr
3381                         { $$ = cat_str(3, $1, make_str("in"), $3); }
3382                 | a_expr NOT IN_P in_expr
3383                         { $$ = cat_str(3, $1, make_str("not in"), $4); }
3384                 | a_expr qual_all_Op sub_type select_with_parens %prec Op
3385                         { $$ = cat_str(4, $1, $2, $3, $4); }
3386                 | UNIQUE select_with_parens %prec Op
3387                         { $$ = cat2_str(make_str("unique"), $2); }
3388                 | r_expr
3389                         { $$ = $1; }
3390                 ;
3391
3392 /* Restricted expressions
3393  *
3394  * b_expr is a subset of the complete expression syntax
3395  *
3396  * Presently, AND, NOT, IS and IN are the a_expr keywords that would
3397  * cause trouble in the places where b_expr is used.  For simplicity, we
3398  * just eliminate all the boolean-keyword-operator productions from b_expr.
3399  */
3400 b_expr:  c_expr
3401                         { $$ = $1; }
3402                 | b_expr TYPECAST Typename
3403                         { $$ = cat_str(3, $1, make_str("::"), $3); }
3404                 | '-' b_expr %prec UMINUS
3405                         { $$ = cat2_str(make_str("-"), $2); }
3406                 | '%' b_expr
3407                         { $$ = cat2_str(make_str("%"), $2); }
3408                 | '^' b_expr
3409                         { $$ = cat2_str(make_str("^"), $2); }
3410                 | b_expr '%'
3411                         { $$ = cat2_str($1, make_str("%")); }
3412                 | b_expr '^'
3413                         { $$ = cat2_str($1, make_str("^")); }
3414                 | b_expr '+' b_expr
3415                         { $$ = cat_str(3, $1, make_str("+"), $3); }
3416                 | b_expr '-' b_expr
3417                         { $$ = cat_str(3, $1, make_str("-"), $3); }
3418                 | b_expr '*' b_expr
3419                         { $$ = cat_str(3, $1, make_str("*"), $3); }
3420                 | b_expr '/' b_expr
3421                         { $$ = cat_str(3, $1, make_str("/"), $3); }
3422                 | b_expr '%' b_expr
3423                         { $$ = cat_str(3, $1, make_str("%"), $3); }
3424                 | b_expr '^' b_expr
3425                         { $$ = cat_str(3, $1, make_str("^"), $3); }
3426                 | b_expr '<' b_expr
3427                         { $$ = cat_str(3, $1, make_str("<"), $3); }
3428                 | b_expr '>' b_expr
3429                         { $$ = cat_str(3, $1, make_str(">"), $3); }
3430                 | b_expr '=' b_expr
3431                         { $$ = cat_str(3, $1, make_str("="), $3); }
3432                 | b_expr Op b_expr
3433                         { $$ = cat_str(3, $1, $2, $3); }
3434                 | qual_Op b_expr                %prec Op
3435                         { $$ = cat2_str($1, $2); }
3436                 | b_expr qual_Op                %prec POSTFIXOP
3437                         { $$ = cat2_str($1, $2); }
3438                 | b_expr IS DISTINCT FROM b_expr %prec IS
3439                         { $$ = cat_str(3, $1, make_str("is distinct from"), $5); }
3440                 | b_expr IS OF '(' b_expr ')' %prec IS
3441                         { $$ = cat_str(4, $1, make_str("is of ("), $5, make_str(")")); }
3442                 | b_expr IS NOT OF '(' b_expr ')' %prec IS
3443                         { $$ = cat_str(4, $1, make_str("is not of ("), $6, make_str(")")); }
3444                 ;
3445
3446 /*
3447  * Productions that can be used in both a_expr and b_expr.
3448  *
3449  * Note: productions that refer recursively to a_expr or b_expr mostly
3450  * cannot appear here.  However, it's OK to refer to a_exprs that occur
3451  * inside parentheses, such as function arguments; that cannot introduce
3452  * ambiguity to the b_expr syntax.
3453  */
3454 c_expr: columnref
3455                         { $$ = $1;      }
3456                 | AexprConst
3457                         { $$ = $1;      }
3458                 | PARAM attrs opt_indirection
3459                         { $$ = cat_str(3, make_str("param"), $2, $3); }
3460                 | '(' a_expr ')'
3461                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3462                 | '(' a_expr ')' attrs opt_indirection
3463                         { $$ = cat_str(5, make_str("("), $2, make_str(")"), $4, $5); }
3464                 | case_expr
3465                         { $$ = $1; }
3466                 | func_name '(' ')'
3467                         { $$ = cat2_str($1, make_str("()"));    }
3468                 | func_name '(' expr_list ')'
3469                         { $$ = cat_str(4, $1, make_str("("), $3, make_str(")"));        }
3470                 | func_name '(' ALL expr_list ')'
3471                         { $$ = cat_str(4, $1, make_str("( all"), $4, make_str(")"));    }
3472                 | func_name '(' DISTINCT expr_list ')'
3473                         { $$ = cat_str(4, $1, make_str("( distinct"), $4, make_str(")"));  }
3474                 | func_name '(' '*' ')'
3475                         { $$ = cat2_str($1, make_str("(*)")); }
3476                 | CURRENT_DATE
3477                         { $$ = make_str("current_date"); }
3478                 | CURRENT_TIME opt_empty_parentheses
3479                         { $$ = cat2_str(make_str("current_time"), $2); }
3480                 | CURRENT_TIME '(' PosIntConst ')'
3481                         { $$ = make_str("current_time"); }
3482                 | CURRENT_TIMESTAMP opt_empty_parentheses
3483                         { $$ = cat2_str(make_str("current_timestamp"), $2); }
3484                 | CURRENT_TIMESTAMP '(' PosIntConst ')'
3485                         { $$ = make_str("current_timestamp"); }
3486                 | CURRENT_USER opt_empty_parentheses
3487                         { $$ = cat2_str(make_str("current_user"), $2); }
3488                 | SESSION_USER opt_empty_parentheses
3489                         { $$ = cat2_str(make_str("session_user"), $2); }
3490                 | USER opt_empty_parentheses
3491                         { $$ = cat2_str(make_str("user"), $2); }
3492                 | CAST '(' a_expr AS Typename ')'
3493                         { $$ = cat_str(5, make_str("cast("), $3, make_str("as"), $5, make_str(")")); }
3494                 | EXTRACT '(' extract_list ')'
3495                         { $$ = cat_str(3, make_str("extract("), $3, make_str(")")); }
3496                 | OVERLAY '(' overlay_list ')'
3497                         { $$ = cat_str(3, make_str("overlay("), $3, make_str(")")); }
3498                 | POSITION '(' position_list ')'
3499                         { $$ = cat_str(3, make_str("position("), $3, make_str(")")); }
3500                 | SUBSTRING '(' substr_list ')'
3501                         { $$ = cat_str(3, make_str("substring("), $3, make_str(")")); }
3502                 | TREAT '(' a_expr AS Typename ')'
3503                         { $$ = cat_str(5, make_str("treat("), $3, make_str("as"), $5, make_str(")")); }
3504                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3505                 | TRIM '(' BOTH trim_list ')'
3506                         { $$ = cat_str(3, make_str("trim(both"), $4, make_str(")")); }
3507                 | TRIM '(' LEADING trim_list ')'
3508                         { $$ = cat_str(3, make_str("trim(leading"), $4, make_str(")")); }
3509                 | TRIM '(' TRAILING trim_list ')'
3510                         { $$ = cat_str(3, make_str("trim(trailing"), $4, make_str(")")); }
3511                 | TRIM '(' trim_list ')'
3512                         { $$ = cat_str(3, make_str("trim("), $3, make_str(")")); }
3513                 | CONVERT '(' a_expr USING any_name ')'
3514                         { $$ = cat_str(5, make_str("convert("), $3, make_str("using"), $5, make_str(")"));}
3515                 | CONVERT '(' expr_list ')'
3516                         { $$ = cat_str(3, make_str("convert("), $3, make_str(")")); }
3517                 | select_with_parens    %prec UMINUS
3518                         { $$ = $1; }
3519                 | EXISTS select_with_parens
3520                         { $$ = cat2_str(make_str("exists"), $2); }
3521                 | VALUE
3522                         { $$ = make_str("value"); }
3523                 ;
3524 /*
3525  * This used to use ecpg_expr, but since there is no shift/reduce conflict
3526  * anymore, we can remove ecpg_expr. - MM
3527  */
3528 opt_indirection:  '[' a_expr ']' opt_indirection
3529                         { $$ = cat_str(4, make_str("["), $2, make_str("]"), $4); }
3530                 | '[' a_expr ':' a_expr ']' opt_indirection
3531                         { $$ = cat_str(6, make_str("["), $2, make_str(":"), $4, make_str("]"), $6); }
3532                 | /* EMPTY */
3533                         { $$ = EMPTY; }
3534                 ;
3535
3536 expr_list:      a_expr
3537                         { $$ = $1; }
3538                 | expr_list ',' a_expr
3539                         { $$ = cat_str(3, $1, make_str(","), $3); }
3540                 ;
3541
3542 extract_list:  extract_arg FROM a_expr
3543                         { $$ = cat_str(3, $1, make_str("from"), $3); }
3544                 | /* EMPTY */
3545                         { $$ = EMPTY; }
3546                 ;
3547
3548 type_list:      type_list ',' Typename
3549                         { $$ = cat_str(3, $1, ',', $3); }
3550                 | Typename
3551                         { $$ = $1; }
3552                 ;
3553
3554 /* Allow delimited string SCONST in extract_arg as an SQL extension.
3555  * - thomas 2001-04-12
3556  */
3557
3558 extract_arg:  ident                             { $$ = $1; }
3559                 | YEAR_P                                { $$ = make_str("year"); }
3560                 | MONTH_P                               { $$ = make_str("month"); }
3561                 | DAY_P                                 { $$ = make_str("day"); }
3562                 | HOUR_P                                { $$ = make_str("hour"); }
3563                 | MINUTE_P                              { $$ = make_str("minute"); }
3564                 | SECOND_P                              { $$ = make_str("second"); }
3565                 | StringConst                   { $$ = $1; }
3566                 ;
3567
3568 overlay_list:
3569                 a_expr overlay_placing substr_from substr_for
3570                         { $$ = cat_str(4, $1, 42, $3, $4); }
3571                 | a_expr overlay_placing substr_from
3572                         { $$ = cat_str(3, $1, $2, $3); }
3573                 ;
3574
3575 overlay_placing:
3576                         PLACING a_expr          { $$ = cat2_str(make_str("placing"), $2); }
3577                         ;
3578
3579 /* position_list uses b_expr not a_expr to avoid conflict with general IN */
3580 position_list:  b_expr IN_P b_expr
3581                         { $$ = cat_str(3, $1, make_str("in"), $3); }
3582                 | /* EMPTY */
3583                         { $$ = EMPTY; }
3584                 ;
3585
3586 substr_list:  a_expr substr_from substr_for
3587                         { $$ = cat_str(3, $1, $2, $3); }
3588                 | a_expr substr_for substr_from
3589                         { $$ = cat_str(3, $1, $2, $3); }
3590                 | a_expr substr_from
3591                         { $$ = cat2_str($1, $2); }
3592                 | a_expr substr_for
3593                         { $$ = cat2_str($1, $2); }
3594                 | expr_list
3595                         { $$ = $1; }
3596                 | /* EMPTY */
3597                         { $$ = EMPTY; }
3598                 ;
3599
3600 substr_from:  FROM a_expr
3601                         { $$ = cat2_str(make_str("from"), $2); }
3602                 ;
3603
3604 substr_for:  FOR a_expr
3605                         { $$ = cat2_str(make_str("for"), $2); }
3606                 ;
3607
3608 trim_list:      a_expr FROM expr_list
3609                         { $$ = cat_str(3, $1, make_str("from"), $3); }
3610                 | FROM expr_list
3611                         { $$ = cat2_str(make_str("from"), $2); }
3612                 | expr_list
3613                         { $$ = $1; }
3614                 ;
3615
3616 in_expr:  select_with_parens
3617                         { $$ = $1; }
3618                 | '(' expr_list ')'
3619                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
3620                 ;
3621
3622 /* Case clause
3623  * Define SQL92-style case clause.
3624  * Allow all four forms described in the standard:
3625  * - Full specification
3626  *      CASE WHEN a = b THEN c ... ELSE d END
3627  * - Implicit argument
3628  *      CASE a WHEN b THEN c ... ELSE d END
3629  * - Conditional NULL
3630  *      NULLIF(x,y)
3631  *      same as CASE WHEN x = y THEN NULL ELSE x END
3632  * - Conditional substitution from list, use first non-null argument
3633  *      COALESCE(a,b,...)
3634  * same as CASE WHEN a IS NOT NULL THEN a WHEN b IS NOT NULL THEN b ... END
3635  * - thomas 1998-11-09
3636  */
3637 case_expr:      CASE case_arg when_clause_list case_default END_P
3638                         { $$ = cat_str(5, make_str("case"), $2, $3, $4, make_str("end")); }
3639                 | NULLIF '(' a_expr ',' a_expr ')'
3640                         { $$ = cat_str(5, make_str("nullif("), $3, make_str(","), $5, make_str(")")); }
3641                 | COALESCE '(' expr_list ')'
3642                         { $$ = cat_str(3, make_str("coalesce("), $3, make_str(")")); }
3643                 ;
3644
3645 when_clause_list:  when_clause_list when_clause
3646                         { $$ = cat2_str($1, $2); }
3647                 | when_clause
3648                         { $$ = $1; }
3649                 ;
3650
3651 when_clause:  WHEN a_expr THEN a_expr
3652                         { $$ = cat_str(4, make_str("when"), $2, make_str("then"), $4); }
3653                 ;
3654
3655 case_default:  ELSE a_expr
3656                         { $$ = cat2_str(make_str("else"), $2); }
3657                 | /*EMPTY*/
3658                         { $$ = EMPTY; }
3659                 ;
3660
3661 case_arg:  a_expr                       { $$ = $1; }
3662                 | /*EMPTY*/                     { $$ = EMPTY; }
3663                 ;
3664
3665 columnref: relation_name opt_indirection
3666                 { $$ = cat2_str($1, $2); }
3667         | dotted_name opt_indirection
3668                 { $$ = cat2_str($1, $2); }
3669         ;
3670
3671 dotted_name: relation_name attrs
3672                         { $$ = cat2_str($1, $2); }
3673                 ;
3674
3675 attrs: '.' attr_name
3676                         { $$ = cat2_str(make_str("."), $2); }
3677                 | '.' '*'
3678                         { $$ = make_str(".*"); }
3679                 | '.' attr_name attrs
3680                         { $$ = cat_str(3, make_str("."), $2, $3); }
3681                 ;
3682
3683 opt_empty_parentheses: '(' ')'  { $$ = make_str("()"); }
3684                 | /*EMPTY*/                             { $$ = EMPTY; }
3685                 ;
3686
3687
3688 /*****************************************************************************
3689  *
3690  *      target lists
3691  *
3692  *****************************************************************************/
3693
3694 /* Target lists as found in SELECT ... and INSERT VALUES ( ... ) */
3695 target_list:  target_list ',' target_el
3696                         { $$ = cat_str(3, $1, make_str(","), $3);  }
3697                 | target_el
3698                         { $$ = $1;      }
3699                 ;
3700
3701 /* AS is not optional because shift/red conflict with unary ops */
3702 target_el:      a_expr AS ColLabel
3703                         { $$ = cat_str(3, $1, make_str("as"), $3); }
3704                 | a_expr
3705                         { $$ = $1; }
3706                 | '*'
3707                         { $$ = make_str("*"); }
3708                 ;
3709
3710 /* Target list as found in UPDATE table SET ... */
3711 update_target_list:  update_target_list ',' update_target_el
3712                         { $$ = cat_str(3, $1, make_str(","),$3);        }
3713                 | update_target_el
3714                         { $$ = $1;      }
3715                 | '*'
3716                         { $$ = make_str("*"); }
3717                 ;
3718
3719 update_target_el:  ColId opt_indirection '=' a_expr
3720                         { $$ = cat_str(4, $1, $2, make_str("="), $4); }
3721                 ;
3722
3723 insert_target_list:  insert_target_list ',' insert_target_el
3724                                 {       $$ = cat_str(3, $1, make_str(","), $3);  }
3725                 | insert_target_el
3726                                 {       $$ = $1;  }
3727                 ;
3728
3729 insert_target_el:  target_el    {       $$ = $1;  }
3730                 | DEFAULT       {       $$ = make_str("default"); }
3731                 ;
3732
3733
3734 /*****************************************************************************
3735  *
3736  *         Names and constants
3737  *
3738  *****************************************************************************/
3739
3740 relation_name:  SpecialRuleRelation     { $$ = $1; }
3741                 | ColId                 { $$ = $1; }
3742                 ;
3743
3744 qualified_name_list:  qualified_name
3745                                 { $$ = $1; }
3746                 | qualified_name_list ',' qualified_name
3747                                 { $$ = cat_str(3, $1, make_str(","), $3); }
3748                 ;
3749
3750 qualified_name: relation_name
3751                 { $$ = $1; }
3752                 | dotted_name
3753                 { $$ = $1; }
3754                 ;
3755
3756 name_list:  name
3757                         { $$ = $1; }
3758                 | name_list ',' name
3759                         { $$ = cat_str(3, $1, make_str(","), $3); }
3760                 ;
3761
3762
3763 name:                                   ColId                   { $$ = $1; };
3764 database_name:                  ColId                   { $$ = $1; };
3765 access_method:                  ColId                   { $$ = $1; };
3766 attr_name:                              ColId                   { $$ = $1; };
3767 index_name:                             ColId                   { $$ = $1; };
3768
3769 file_name:                              StringConst             { $$ = $1; };
3770
3771 /* func_name will soon return a List ... but not yet */
3772 /*
3773 func_name: function_name
3774                         { $$ = makeList1(makeString($1)); }
3775                 | dotted_name
3776                         { $$ = $1; }
3777                 ;
3778 */
3779 func_name: function_name
3780                         { $$ = $1; }
3781                 | dotted_name
3782                         { $$ = $1; }
3783                 ;
3784
3785
3786 /* Constants
3787  * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
3788  */
3789 AexprConst:  PosAllConst
3790                         { $$ = $1; }
3791                 | ConstTypename StringConst
3792                         { $$ = cat2_str($1, $2); }
3793                 | ConstInterval StringConst opt_interval
3794                         { $$ = cat_str(3, $1, $2, $3); }
3795                 | ConstInterval  '(' PosIntConst ')' StringConst opt_interval
3796                         { $$ = cat_str(6, $1, make_str("("), $3, make_str(")"), $5, $6); }
3797                 | PARAM opt_indirection
3798                         { $$ = cat2_str(make_str("param"), $2); }
3799                 | TRUE_P
3800                         { $$ = make_str("true"); }
3801                 | FALSE_P
3802                         { $$ = make_str("false"); }
3803                 | NULL_P
3804                         { $$ = make_str("null"); }
3805                 | civarind
3806                         { $$ = make_str("?"); }
3807                 ;
3808
3809 Iconst:  ICONST                         { $$ = make_name();};
3810 Fconst:  FCONST                         { $$ = make_name();};
3811 Bconst:  BCONST                         { $$ = make_name();};
3812 Xconst:  XCONST                         { $$ = make_name();};
3813 Sconst:  SCONST
3814                 {
3815                         $$ = (char *)mm_alloc(strlen($1) + 3);
3816                         $$[0]='\'';
3817                                         strcpy($$+1, $1);
3818                         $$[strlen($1)+2]='\0';
3819                         $$[strlen($1)+1]='\'';
3820                         free($1);
3821                 }
3822                 ;
3823
3824 PosIntConst:    Iconst          { $$ = $1; }
3825                 | civar                         { $$ = make_str("?"); }
3826                 ;
3827
3828 IntConst:       PosIntConst             { $$ = $1; }
3829                 | '-' PosIntConst       { $$ = cat2_str(make_str("-"), $2); }
3830                 ;
3831
3832 StringConst:    Sconst          { $$ = $1; }
3833                 | civar                         { $$ = make_str("?"); }
3834                 ;
3835
3836 PosIntStringConst:      Iconst  { $$ = $1; }
3837                 | Sconst                        { $$ = $1; }
3838                 | civar                         { $$ = make_str("?"); }
3839                 ;
3840
3841 NumConst:       Fconst                  { $$ = $1; }
3842                 | Iconst                        { $$ = $1; }
3843                 | '-' Fconst            { $$ = cat2_str(make_str("-"), $2); }
3844                 | '-' Iconst            { $$ = cat2_str(make_str("-"), $2); }
3845                 | civar                         { $$ = make_str("?"); }
3846                 ;
3847
3848 AllConst:       Sconst                  { $$ = $1; }
3849                 | NumConst                      { $$ = $1; }
3850                 ;
3851
3852 PosAllConst:    Sconst          { $$ = $1; }
3853                 | Fconst        { $$ = $1; }
3854                 | Iconst        { $$ = $1; }
3855                 | Bconst        { $$ = $1; }
3856                 | Xconst        { $$ = $1; }
3857                 | civar         { $$ = make_str("?"); }
3858                 ;
3859
3860 UserId:  ColId                          { $$ = $1;};
3861
3862 SpecialRuleRelation:  OLD
3863                 {
3864                         if (!QueryIsRule)
3865                                 mmerror(PARSE_ERROR, ET_ERROR, "OLD used in non-rule query");
3866
3867                         $$ = make_str("old");
3868                 }
3869                 | NEW
3870                 {
3871                         if (!QueryIsRule)
3872                                 mmerror(PARSE_ERROR, ET_ERROR, "NEW used in non-rule query");
3873
3874                         $$ = make_str("new");
3875                 }
3876                 ;
3877
3878 /*
3879  * and now special embedded SQL stuff
3880  */
3881
3882 /*
3883  * the exec sql connect statement: connect to the given database
3884  */
3885 ECPGConnect: SQL_CONNECT TO connection_target opt_connection_name opt_user
3886                         { $$ = cat_str(5, $3, make_str(","), $5, make_str(","), $4); }
3887                 | SQL_CONNECT TO DEFAULT
3888                         { $$ = make_str("NULL,NULL,NULL,\"DEFAULT\""); }
3889                   /* also allow ORACLE syntax */
3890                 | SQL_CONNECT ora_user
3891                         { $$ = cat_str(3, make_str("NULL,"), $2, make_str(",NULL")); }
3892                 ;
3893
3894 connection_target: database_name opt_server opt_port
3895                 {
3896                         /* old style: dbname[@server][:port] */
3897                         if (strlen($2) > 0 && *($2) != '@')
3898                         {
3899                                 snprintf(errortext, sizeof(errortext),
3900                                                  "Expected '@', found '%s'", $2);
3901                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3902                         }
3903
3904                         $$ = make3_str(make_str("\""), make3_str($1, $2, $3), make_str("\""));
3905                 }
3906                 |  db_prefix ':' server opt_port '/' database_name opt_options
3907                 {
3908                         /* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
3909                         if (strncmp($1, "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp($1, "tcp:postgresql", strlen("tcp:postgresql")) != 0)
3910                         {
3911                                 snprintf(errortext, sizeof(errortext), "only protocols 'tcp' and 'unix' and database type 'postgresql' are supported");
3912                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3913                         }
3914
3915                         if (strncmp($3, "//", strlen("//")) != 0)
3916                         {
3917                                 snprintf(errortext, sizeof(errortext), "Expected '://', found '%s'", $3);
3918                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3919                         }
3920
3921                         if (strncmp($1, "unix", strlen("unix")) == 0 &&
3922                                 strncmp($3 + strlen("//"), "localhost", strlen("localhost")) != 0 &&
3923                                 strncmp($3 + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
3924                         {
3925                                 snprintf(errortext, sizeof(errortext), "unix domain sockets only work on 'localhost' but not on '%9.9s'", $3 + strlen("//"));
3926                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3927                         }
3928
3929                         $$ = make3_str(make3_str(make_str("\""), $1, make_str(":")), $3, make3_str(make3_str($4, make_str("/"), $6),    $7, make_str("\"")));
3930                 }
3931                 | StringConst
3932                 {
3933                         if ($1[0] == '\"')
3934                                 $$ = $1;
3935                         else if (strcmp($1, "?") == 0) /* variable */
3936                         {
3937                                 enum ECPGttype type = argsinsert->variable->type->type;
3938
3939                                 /* if array see what's inside */
3940                                 if (type == ECPGt_array)
3941                                         type = argsinsert->variable->type->u.element->type;
3942
3943                                 /* handle varchars */
3944                                 if (type == ECPGt_varchar)
3945                                         $$ = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
3946                                 else
3947                                         $$ = mm_strdup(argsinsert->variable->name);
3948                         }
3949                         else
3950                                 $$ = make3_str(make_str("\""), $1, make_str("\""));
3951                 }
3952                 ;
3953
3954 db_prefix: ident CVARIABLE
3955                 {
3956                         if (strcmp($2, "postgresql") != 0 && strcmp($2, "postgres") != 0)
3957                         {
3958                                 snprintf(errortext, sizeof(errortext), "Expected 'postgresql', found '%s'", $2);
3959                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3960                         }
3961
3962                         if (strcmp($1, "tcp") != 0 && strcmp($1, "unix") != 0)
3963                         {
3964                                 snprintf(errortext, sizeof(errortext), "Illegal connection type %s", $1);
3965                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3966                         }
3967
3968                         $$ = make3_str($1, make_str(":"), $2);
3969                 }
3970                 ;
3971
3972 server: Op server_name
3973                 {
3974                         if (strcmp($1, "@") != 0 && strcmp($1, "//") != 0)
3975                         {
3976                                 snprintf(errortext, sizeof(errortext), "Expected '@' or '://', found '%s'", $1);
3977                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
3978                         }
3979
3980                         $$ = make2_str($1, $2);
3981                 }
3982                 ;
3983
3984 opt_server: server                      { $$ = $1; }
3985                 | /*EMPTY*/                     { $$ = EMPTY; }
3986                 ;
3987
3988 server_name: ColId                                      { $$ = $1; }
3989                 | ColId '.' server_name         { $$ = make3_str($1, make_str("."), $3); }
3990                 | IP                                            { $$ = make_name(); }
3991                 ;
3992
3993 opt_port: ':' PosIntConst       { $$ = make2_str(make_str(":"), $2); }
3994                 | /*EMPTY*/                     { $$ = EMPTY; }
3995                 ;
3996
3997 opt_connection_name: AS connection_target { $$ = $2; }
3998                 | /*EMPTY*/                     { $$ = make_str("NULL"); }
3999                 ;
4000
4001 opt_user: USER ora_user         { $$ = $2; }
4002                 | /*EMPTY*/                     { $$ = make_str("NULL,NULL"); }
4003                 ;
4004
4005 ora_user: user_name
4006                         { $$ = cat2_str($1, make_str(", NULL")); }
4007                 | user_name '/' user_name
4008                         { $$ = cat_str(3, $1, make_str(","), $3); }
4009                 | user_name SQL_IDENTIFIED BY user_name
4010                         { $$ = cat_str(3, $1, make_str(","), $4); }
4011                 | user_name USING user_name
4012                         { $$ = cat_str(3, $1, make_str(","), $3); }
4013                 ;
4014
4015 user_name: UserId
4016                 {
4017                         if ($1[0] == '\"')
4018                                 $$ = $1;
4019                         else
4020                                 $$ = make3_str(make_str("\""), $1, make_str("\""));
4021                 }
4022                 | StringConst
4023                 {
4024                         if ($1[0] == '\"')
4025                                 $$ = $1;
4026                         else if (strcmp($1, "?") == 0) /* variable */
4027                         {
4028                                 enum ECPGttype type = argsinsert->variable->type->type;
4029
4030                                 /* if array see what's inside */
4031                                 if (type == ECPGt_array)
4032                                         type = argsinsert->variable->type->u.element->type;
4033
4034                                 /* handle varchars */
4035                                 if (type == ECPGt_varchar)
4036                                         $$ = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
4037                                 else
4038                                         $$ = mm_strdup(argsinsert->variable->name);
4039                         }
4040                         else
4041                                 $$ = make3_str(make_str("\""), $1, make_str("\""));
4042                 }
4043                 ;
4044
4045 char_variable: CVARIABLE
4046                 {
4047                         /* check if we have a char variable */
4048                         struct variable *p = find_variable($1);
4049                         enum ECPGttype type = p->type->type;
4050
4051                         /* if array see what's inside */
4052                         if (type == ECPGt_array)
4053                                 type = p->type->u.element->type;
4054
4055                         switch (type)
4056                         {
4057                                 case ECPGt_char:
4058                                 case ECPGt_unsigned_char:
4059                                         $$ = $1;
4060                                         break;
4061                                 case ECPGt_varchar:
4062                                         $$ = make2_str($1, make_str(".arr"));
4063                                         break;
4064                                 default:
4065                                         mmerror(PARSE_ERROR, ET_ERROR, "invalid datatype");
4066                                         break;
4067                         }
4068                 }
4069                 ;
4070
4071 opt_options: Op ColId
4072                 {
4073                         if (strlen($1) == 0)
4074                                 mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
4075
4076                         if (strcmp($1, "?") != 0)
4077                         {
4078                                 snprintf(errortext, sizeof(errortext), "unrecognised token '%s'", $1);
4079                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
4080                         }
4081
4082                         $$ = make2_str(make_str("?"), $2);
4083                 }
4084                 | /*EMPTY*/     { $$ = EMPTY; }
4085                 ;
4086
4087 /*
4088  * Declare a prepared cursor. The syntax is different from the standard
4089  * declare statement, so we create a new rule.
4090  */
4091 ECPGCursorStmt:  DECLARE name opt_cursor CURSOR FOR ident
4092                 {
4093                         struct cursor *ptr, *this;
4094                         struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
4095
4096                         for (ptr = cur; ptr != NULL; ptr = ptr->next)
4097                         {
4098                                 if (strcmp($2, ptr->name) == 0)
4099                                 {
4100                                                 /* re-definition is a bug */
4101                                         snprintf(errortext, sizeof(errortext), "cursor %s already defined", $2);
4102                                         mmerror(PARSE_ERROR, ET_ERROR, errortext);
4103                                 }
4104                         }
4105
4106                         this = (struct cursor *) mm_alloc(sizeof(struct cursor));
4107
4108                         /* initial definition */
4109                         this->next = cur;
4110                         this->name = $2;
4111                         this->connection = connection;
4112                         this->command =  cat_str(4, make_str("declare"), mm_strdup($2), $3, make_str("cursor for ?"));
4113                         this->argsresult = NULL;
4114
4115                         thisquery->type = &ecpg_query;
4116                         thisquery->brace_level = 0;
4117                         thisquery->next = NULL;
4118                         thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(\"\")") + strlen($6));
4119                         sprintf(thisquery->name, "ECPGprepared_statement(\"%s\")", $6);
4120
4121                         this->argsinsert = NULL;
4122                         add_variable(&(this->argsinsert), thisquery, &no_indicator);
4123
4124                         cur = this;
4125
4126                         $$ = cat_str(3, make_str("/*"), mm_strdup(this->command), make_str("*/"));
4127                 }
4128                 ;
4129
4130 /*
4131  * the exec sql deallocate prepare command to deallocate a previously
4132  * prepared statement
4133  */
4134 ECPGDeallocate: DEALLOCATE PREPARE ident
4135                         { $$ = cat_str(3, make_str("ECPGdeallocate(__LINE__, \""), $3, make_str("\");")); }
4136                 | DEALLOCATE ident
4137                         { $$ = cat_str(2, make_str("ECPGdeallocate(__LINE__, \""), $2, make_str("\");")); }
4138                 ;
4139
4140 /*
4141  * variable decalartion outside exec sql declare block
4142  */
4143 ECPGVarDeclaration: single_vt_declaration;
4144
4145 single_vt_declaration: type_declaration         { $$ = $1; }
4146                 | single_var_declaration        { $$ = $1; }
4147                 ;
4148
4149 single_var_declaration: storage_declaration
4150                 single_vt_type
4151                 {
4152                         actual_type[struct_level].type_enum = $2.type_enum;
4153                         actual_type[struct_level].type_dimension = $2.type_dimension;
4154                         actual_type[struct_level].type_index = $2.type_index;
4155                         actual_type[struct_level].type_sizeof = $2.type_sizeof;
4156
4157                         /* we do not need the string "varchar" for output */
4158                         /* so replace it with an empty string */
4159                         if ($2.type_enum == ECPGt_varchar)
4160                         {
4161                                 free($2.type_str);
4162                                 $2.type_str=EMPTY;
4163                         }
4164                 }
4165                 variable_list ';'
4166                 {
4167                         $$ = cat_str(5, actual_startline[struct_level], $1, $2.type_str, $4, make_str(";\n"));
4168                 }
4169                 ;
4170
4171 single_vt_type: common_type
4172                 | ECPGColLabelCommon
4173                 {
4174                         /*
4175                          * Check for type names that the SQL grammar treats as
4176                          * unreserved keywords
4177                          */
4178                         if (strcmp($1, "varchar") == 0)
4179                         {
4180                                 $$.type_enum = ECPGt_varchar;
4181                                 $$.type_str = make_str("varchar");
4182                                 $$.type_dimension = -1;
4183                                 $$.type_index = -1;
4184                                 $$.type_sizeof = NULL;
4185                         }
4186                         else if (strcmp($1, "float") == 0)
4187                         {
4188                                 $$.type_enum = ECPGt_float;
4189                                 $$.type_str = make_str("float");
4190                                 $$.type_dimension = -1;
4191                                 $$.type_index = -1;
4192                                 $$.type_sizeof = NULL;
4193                         }
4194                         else if (strcmp($1, "double") == 0)
4195                         {
4196                                 $$.type_enum = ECPGt_double;
4197                                 $$.type_str = make_str("double");
4198                                 $$.type_dimension = -1;
4199                                 $$.type_index = -1;
4200                                 $$.type_sizeof = NULL;
4201                         }
4202                         else
4203                         {
4204                                 /* this is for typedef'ed types */
4205                                 struct typedefs *this = get_typedef($1);
4206
4207                                 $$.type_str = (this->type->type_enum == ECPGt_varchar) ? EMPTY : mm_strdup(this->name);
4208                                 $$.type_enum = this->type->type_enum;
4209                                 $$.type_dimension = this->type->type_dimension;
4210                                 $$.type_index = this->type->type_index;
4211                                 $$.type_sizeof = this->type->type_sizeof;
4212                                 struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
4213                         }
4214                 }
4215                 ;
4216
4217 /*
4218  * variable declaration inside exec sql declare block
4219  */
4220 ECPGDeclaration: sql_startdeclare
4221                 { fputs("/* exec sql begin declare section */", yyout); }
4222                 var_type_declarations sql_enddeclare
4223                 {
4224                         fprintf(yyout, "%s/* exec sql end declare section */", $3);
4225                         free($3);
4226                         output_line_number();
4227                 }
4228                 ;
4229
4230 sql_startdeclare: ecpgstart BEGIN_P DECLARE SQL_SECTION ';' {};
4231
4232 sql_enddeclare: ecpgstart END_P DECLARE SQL_SECTION ';' {};
4233
4234 var_type_declarations:  /*EMPTY*/                       { $$ = EMPTY; }
4235                 | vt_declarations                       { $$ = $1; }
4236                 ;
4237
4238 vt_declarations:  var_declaration                       { $$ = $1; }
4239                 | type_declaration                      { $$ = $1; }
4240                 | vt_declarations var_declaration       { $$ = cat2_str($1, $2); }
4241                 | vt_declarations type_declaration      { $$ = cat2_str($1, $2); }
4242                 ;
4243
4244 variable_declarations:  var_declaration                         { $$ = $1; }
4245                 | variable_declarations var_declaration         { $$ = cat2_str($1, $2); }
4246                 ;
4247
4248 type_declaration: S_TYPEDEF
4249         {
4250                 /* reset this variable so we see if there was */
4251                 /* an initializer specified */
4252                 initializer = 0;
4253         }
4254         type opt_pointer ECPGColLabel opt_type_array_bounds ';'
4255         {
4256                 /* add entry to list */
4257                 struct typedefs *ptr, *this;
4258                 int dimension = $6.index1;
4259                 int length = $6.index2;
4260
4261                 if (($3.type_enum == ECPGt_struct ||
4262                      $3.type_enum == ECPGt_union) &&
4263                     initializer == 1)
4264                 {
4265                         mmerror(PARSE_ERROR, ET_ERROR, "Initializer not allowed in typedef command");
4266
4267                 }
4268                 else
4269                 {
4270                         for (ptr = types; ptr != NULL; ptr = ptr->next)
4271                         {
4272                                 if (strcmp($5, ptr->name) == 0)
4273                                 {
4274                                         /* re-definition is a bug */
4275                                         snprintf(errortext, sizeof(errortext), "Type %s already defined", $5);
4276                                         mmerror(PARSE_ERROR, ET_ERROR, errortext);
4277                                 }
4278                         }
4279
4280                         adjust_array($3.type_enum, &dimension, &length, $3.type_dimension, $3.type_index, *$4?1:0);
4281
4282                         this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
4283
4284                         /* initial definition */
4285                         this->next = types;
4286                         this->name = $5;
4287                         this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
4288                         this->type->type_enum = $3.type_enum;
4289                         this->type->type_str = mm_strdup($5);
4290                         this->type->type_dimension = dimension; /* dimension of array */
4291                         this->type->type_index = length;    /* lenght of string */
4292                         this->type->type_sizeof = ECPGstruct_sizeof;
4293                         this->struct_member_list = ($3.type_enum == ECPGt_struct || $3.type_enum == ECPGt_union) ?
4294                                 struct_member_list[struct_level] : NULL;
4295
4296                         if ($3.type_enum != ECPGt_varchar &&
4297                             $3.type_enum != ECPGt_char &&
4298                             $3.type_enum != ECPGt_unsigned_char &&
4299                             this->type->type_index >= 0)
4300                                 mmerror(PARSE_ERROR, ET_ERROR, "No multi-dimensional array support for simple data types");
4301
4302                         types = this;
4303                 }
4304
4305                 fprintf(yyout, "typedef %s %s %s %s;\n", $3.type_str, *$4?"*":"", $5, $6.str);
4306                 output_line_number();
4307                 $$ = make_str("");
4308         };
4309
4310 var_declaration: storage_declaration
4311                 type
4312                 {
4313                         actual_type[struct_level].type_enum = $2.type_enum;
4314                         actual_type[struct_level].type_dimension = $2.type_dimension;
4315                         actual_type[struct_level].type_index = $2.type_index;
4316                         actual_type[struct_level].type_sizeof = $2.type_sizeof;
4317
4318                         /* we do not need the string "varchar" for output */
4319                         /* so replace it with an empty string */
4320                         if ($2.type_enum == ECPGt_varchar)
4321                         {
4322                                 free($2.type_str);
4323                                 $2.type_str=EMPTY;
4324                         }
4325                 }
4326                 variable_list ';'
4327                 {
4328                         $$ = cat_str(5, actual_startline[struct_level], $1, $2.type_str, $4, make_str(";\n"));
4329                 }
4330                 ;
4331
4332 storage_declaration: storage_clause storage_modifier
4333                 {
4334                         actual_storage[struct_level] = cat2_str(mm_strdup($1), mm_strdup($2));
4335                         actual_startline[struct_level] = hashline_number();
4336                 }
4337                 ;
4338
4339 storage_clause : S_EXTERN               { $$ = make_str("extern"); }
4340                 | S_STATIC                              { $$ = make_str("static"); }
4341                 | S_REGISTER                    { $$ = make_str("register"); }
4342                 | S_AUTO                                { $$ = make_str("auto"); }
4343                 | /*EMPTY*/                             { $$ = EMPTY; }
4344                 ;
4345
4346 storage_modifier : S_CONST              { $$ = make_str("const"); }
4347                 | S_VOLATILE                    { $$ = make_str("volatile"); }
4348                 | /*EMPTY*/                             { $$ = EMPTY; }
4349                 ;
4350
4351 common_type: simple_type
4352                 {
4353                         $$.type_enum = $1;
4354                         $$.type_str = mm_strdup(ECPGtype_name($1));
4355                         $$.type_dimension = -1;
4356                         $$.type_index = -1;
4357                         $$.type_sizeof = NULL;
4358                 }
4359                 | struct_type
4360                 {
4361                         $$.type_enum = ECPGt_struct;
4362                         $$.type_str = $1;
4363                         $$.type_dimension = -1;
4364                         $$.type_index = -1;
4365                         $$.type_sizeof = ECPGstruct_sizeof;
4366                 }
4367                 | union_type
4368                 {
4369                         $$.type_enum = ECPGt_union;
4370                         $$.type_str = $1;
4371                         $$.type_dimension = -1;
4372                         $$.type_index = -1;
4373                         $$.type_sizeof = NULL;
4374                 }
4375                 | enum_type
4376                 {
4377                         $$.type_str = $1;
4378                         $$.type_enum = ECPGt_int;
4379                         $$.type_dimension = -1;
4380                         $$.type_index = -1;
4381                         $$.type_sizeof = NULL;
4382                 }
4383                 ;
4384
4385 type:           common_type
4386                 | ECPGColLabel
4387                 {
4388                         /*
4389                          * Check for type names that the SQL grammar treats as
4390                          * unreserved keywords
4391                          */
4392                         if (strcmp($1, "varchar") == 0)
4393                         {
4394                                 $$.type_enum = ECPGt_varchar;
4395                                 $$.type_str = make_str("varchar");
4396                                 $$.type_dimension = -1;
4397                                 $$.type_index = -1;
4398                                 $$.type_sizeof = NULL;
4399                         }
4400                         else if (strcmp($1, "float") == 0)
4401                         {
4402                                 $$.type_enum = ECPGt_float;
4403                                 $$.type_str = make_str("float");
4404                                 $$.type_dimension = -1;
4405                                 $$.type_index = -1;
4406                                 $$.type_sizeof = NULL;
4407                         }
4408                         else if (strcmp($1, "double") == 0)
4409                         {
4410                                 $$.type_enum = ECPGt_double;
4411                                 $$.type_str = make_str("double");
4412                                 $$.type_dimension = -1;
4413                                 $$.type_index = -1;
4414                                 $$.type_sizeof = NULL;
4415                         }
4416                         else
4417                         {
4418                                 /* this is for typedef'ed types */
4419                                 struct typedefs *this = get_typedef($1);
4420
4421                                 $$.type_str = (this->type->type_enum == ECPGt_varchar) ? EMPTY : mm_strdup(this->name);
4422                                 $$.type_enum = this->type->type_enum;
4423                                 $$.type_dimension = this->type->type_dimension;
4424                                 $$.type_index = this->type->type_index;
4425                                 $$.type_sizeof = this->type->type_sizeof;
4426                                 struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
4427                         }
4428                 }
4429                 ;
4430
4431 enum_type: SQL_ENUM opt_symbol enum_definition
4432                         { $$ = cat_str(3, make_str("enum"), $2, $3); }
4433                 |  SQL_ENUM symbol
4434                         { $$ = cat2_str(make_str("enum"), $2); }
4435                 ;
4436
4437 enum_definition: '{' c_list '}'
4438                         { $$ = cat_str(3, make_str("{"), $2, make_str("}")); };
4439
4440 struct_type: s_struct '{' variable_declarations '}'
4441                 {
4442                         ECPGfree_struct_member(struct_member_list[struct_level]);
4443                         free(actual_storage[struct_level--]);
4444                         $$ = cat_str(4, $1, make_str("{"), $3, make_str("}"));
4445                 }
4446                 ;
4447
4448 union_type: s_union '{' variable_declarations '}'
4449                 {
4450                         ECPGfree_struct_member(struct_member_list[struct_level]);
4451                         free(actual_storage[struct_level--]);
4452                         $$ = cat_str(4, $1, make_str("{"), $3, make_str("}"));
4453                 }
4454                 ;
4455
4456 s_struct: SQL_STRUCT opt_symbol
4457                 {
4458                         struct_member_list[struct_level++] = NULL;
4459                         $$ = cat2_str(make_str("struct"), $2);
4460                         ECPGstruct_sizeof = cat_str(3, make_str("sizeof("), strdup($$), make_str(")"));
4461                         if (struct_level >= STRUCT_DEPTH)
4462                                  mmerror(PARSE_ERROR, ET_ERROR, "Too many levels in nested structure definition");
4463                 }
4464                 ;
4465
4466 s_union: UNION opt_symbol
4467                 {
4468                         struct_member_list[struct_level++] = NULL;
4469                         if (struct_level >= STRUCT_DEPTH)
4470                                  mmerror(PARSE_ERROR, ET_ERROR, "Too many levels in nested structure definition");
4471
4472                         $$ = cat2_str(make_str("union"), $2);
4473                 }
4474                 ;
4475
4476 simple_type: unsigned_type                                      { $$=$1; }
4477                 |       opt_signed signed_type                  { $$=$2; }
4478                 ;
4479
4480 unsigned_type: SQL_UNSIGNED SQL_SHORT           { $$ = ECPGt_unsigned_short; }
4481                 | SQL_UNSIGNED SQL_SHORT INT    { $$ = ECPGt_unsigned_short; }
4482                 | SQL_UNSIGNED                                          { $$ = ECPGt_unsigned_int; }
4483                 | SQL_UNSIGNED INT                              { $$ = ECPGt_unsigned_int; }
4484                 | SQL_UNSIGNED SQL_LONG                         { $$ = ECPGt_unsigned_long; }
4485                 | SQL_UNSIGNED SQL_LONG INT             { $$ = ECPGt_unsigned_long; }
4486                 | SQL_UNSIGNED SQL_LONG SQL_LONG
4487                 {
4488 #ifdef HAVE_LONG_LONG_INT_64
4489                         $$ = ECPGt_unsigned_long_long;
4490 #else
4491                         $$ = ECPGt_unsigned_long;
4492 #endif
4493                 }
4494                 | SQL_UNSIGNED SQL_LONG SQL_LONG INT
4495                 {
4496 #ifdef HAVE_LONG_LONG_INT_64
4497                         $$ = ECPGt_unsigned_long_long;
4498 #else
4499                         $$ = ECPGt_unsigned_long;
4500 #endif
4501                 }
4502                 | SQL_UNSIGNED CHAR_P                   { $$ = ECPGt_unsigned_char; }
4503                 ;
4504
4505 signed_type: SQL_SHORT                          { $$ = ECPGt_short; }
4506                 | SQL_SHORT INT                 { $$ = ECPGt_short; }
4507                 | INT                                   { $$ = ECPGt_int; }
4508                 | SQL_LONG                                      { $$ = ECPGt_long; }
4509                 | SQL_LONG INT                  { $$ = ECPGt_long; }
4510                 | SQL_LONG SQL_LONG
4511                 {
4512 #ifdef HAVE_LONG_LONG_INT_64
4513                         $$ = ECPGt_long_long;
4514 #else
4515                         $$ = ECPGt_long;
4516 #endif
4517                 }
4518                 | SQL_LONG SQL_LONG INT
4519                 {
4520 #ifdef HAVE_LONG_LONG_INT_64
4521                         $$ = ECPGt_long_long;
4522 #else
4523                         $$ = ECPGt_long;
4524 #endif
4525                 }
4526                 | SQL_BOOL                                      { $$ = ECPGt_bool; }
4527                 | CHAR_P                                        { $$ = ECPGt_char; }
4528                 ;
4529
4530 opt_signed: SQL_SIGNED
4531                 |       /* EMPTY */
4532                 ;
4533
4534 variable_list: variable
4535                         { $$ = $1; }
4536                 | variable_list ',' variable
4537                         { $$ = cat_str(3, $1, make_str(","), $3); }
4538                 ;
4539
4540 variable: opt_pointer ECPGColLabel opt_array_bounds opt_initializer
4541                 {
4542                         struct ECPGtype * type;
4543                         int dimension = $3.index1; /* dimension of array */
4544                         int length = $3.index2;    /* lenght of string */
4545                         char dim[14L], ascii_len[12];
4546
4547                         adjust_array(actual_type[struct_level].type_enum, &dimension, &length, actual_type[struct_level].type_dimension, actual_type[struct_level].type_index, strlen($1));
4548
4549                         switch (actual_type[struct_level].type_enum)
4550                         {
4551                                 case ECPGt_struct:
4552                                 case ECPGt_union:
4553                                         if (dimension < 0)
4554                                                 type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_sizeof);
4555                                         else
4556                                                 type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_sizeof), dimension);
4557
4558                                         $$ = cat_str(4, $1, mm_strdup($2), $3.str, $4);
4559                                         break;
4560
4561                                 case ECPGt_varchar:
4562                                         if (dimension < 0)
4563                                                 type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
4564                                         else
4565                                                 type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
4566
4567                                         switch(dimension)
4568                                         {
4569                                                 case 0:
4570                                                 case -1:
4571                                                 case 1:
4572                                                         *dim = '\0';
4573                                                         break;
4574                                                 default:
4575                                                         sprintf(dim, "[%d]", dimension);
4576                                                         break;
4577                                         }
4578                                         sprintf(ascii_len, "%d", length);
4579
4580                                         if (length == 0)
4581                                                 mmerror(PARSE_ERROR, ET_ERROR, "pointer to varchar are not implemented");
4582
4583                                         if (dimension == 0)
4584                                                 $$ = cat_str(7, mm_strdup(actual_storage[struct_level]), make2_str(make_str(" struct varchar_"), mm_strdup($2)), make_str(" { int len; char arr["), mm_strdup(ascii_len), make_str("]; } *"), mm_strdup($2), $4);
4585                                         else
4586                                            $$ = cat_str(8, mm_strdup(actual_storage[struct_level]), make2_str(make_str(" struct varchar_"), mm_strdup($2)), make_str(" { int len; char arr["), mm_strdup(ascii_len), make_str("]; } "), mm_strdup($2), mm_strdup(dim), $4);
4587                                         break;
4588
4589                                 case ECPGt_char:
4590                                 case ECPGt_unsigned_char:
4591                                         if (dimension == -1)
4592                                                 type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
4593                                         else
4594                                                 type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
4595
4596                                         $$ = cat_str(4, $1, mm_strdup($2), $3.str, $4);
4597                                         break;
4598
4599                                 default:
4600                                         if (dimension < 0)
4601                                                 type = ECPGmake_simple_type(actual_type[struct_level].type_enum, 1);
4602                                         else
4603                                                 type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, 1), dimension);
4604
4605                                         $$ = cat_str(4, $1, mm_strdup($2), $3.str, $4);
4606                                         break;
4607                         }
4608
4609                         if (struct_level == 0)
4610                                 new_variable($2, type, braces_open);
4611                         else
4612                                 ECPGmake_struct_member($2, type, &(struct_member_list[struct_level - 1]));
4613
4614                         free($2);
4615                 }
4616                 ;
4617
4618 opt_initializer: /*EMPTY*/
4619                         { $$ = EMPTY; }
4620                 | '=' c_term
4621                 {
4622                         initializer = 1;
4623                         $$ = cat2_str(make_str("="), $2);
4624                 }
4625                 ;
4626
4627 opt_pointer: /*EMPTY*/                          { $$ = EMPTY; }
4628                 | '*'                                           { $$ = make_str("*"); }
4629                 | '*' '*'                                       { $$ = make_str("**"); }
4630                 ;
4631
4632 /*
4633  * As long as the prepare statement is not supported by the backend, we will
4634  * try to simulate it here so we get dynamic SQL
4635  */
4636 ECPGDeclare: DECLARE STATEMENT ident
4637                 {
4638                         /* this is only supported for compatibility */
4639                         $$ = cat_str(3, make_str("/* declare statement"), $3, make_str("*/"));
4640                 }
4641                 ;
4642 /*
4643  * the exec sql disconnect statement: disconnect from the given database
4644  */
4645 ECPGDisconnect: SQL_DISCONNECT dis_name { $$ = $2; }
4646                 ;
4647
4648 dis_name: connection_object                             { $$ = $1; }
4649                 | SQL_CURRENT                                           { $$ = make_str("\"CURRENT\""); }
4650                 | ALL                                                   { $$ = make_str("\"ALL\""); }
4651                 | /*EMPTY*/                                             { $$ = make_str("\"CURRENT\""); }
4652                 ;
4653
4654 connection_object: connection_target    { $$ = $1; }
4655                 | DEFAULT                                               { $$ = make_str("\"DEFAULT\""); }
4656                 ;
4657
4658 /*
4659  * execute a given string as sql command
4660  */
4661 ECPGExecute : EXECUTE IMMEDIATE execstring
4662                 {
4663                         struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
4664
4665                         thisquery->type = &ecpg_query;
4666                         thisquery->brace_level = 0;
4667                         thisquery->next = NULL;
4668                         thisquery->name = $3;
4669
4670                         add_variable(&argsinsert, thisquery, &no_indicator);
4671
4672                         $$ = make_str("?");
4673                 }
4674                 | EXECUTE name
4675                 {
4676                         struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
4677
4678                         thisquery->type = &ecpg_query;
4679                         thisquery->brace_level = 0;
4680                         thisquery->next = NULL;
4681                         thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(\"\")") + strlen($2));
4682                         sprintf(thisquery->name, "ECPGprepared_statement(\"%s\")", $2);
4683
4684                         add_variable(&argsinsert, thisquery, &no_indicator);
4685                 }
4686                 opt_ecpg_using opt_ecpg_into
4687                 {
4688                         $$ = make_str("?");
4689                 }
4690                 ;
4691
4692 execstring: char_variable
4693                         { $$ = $1; }
4694                 |       CSTRING
4695                         { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
4696                 ;
4697
4698 /*
4699  * the exec sql free command to deallocate a previously
4700  * prepared statement
4701  */
4702 ECPGFree:       SQL_FREE name   { $$ = $2; };
4703
4704 /*
4705  * open is an open cursor, at the moment this has to be removed
4706  */
4707 ECPGOpen: SQL_OPEN name opt_ecpg_using { $$ = $2; };
4708
4709 opt_ecpg_using: /*EMPTY*/               { $$ = EMPTY; }
4710                 | USING variablelist
4711                 {
4712                         /* mmerror ("open cursor with variables not implemented yet"); */
4713                         $$ = EMPTY;
4714                 }
4715                 ;
4716
4717 opt_sql: /*EMPTY*/ | SQL_SQL;
4718
4719 ecpg_into: INTO into_list
4720                 {
4721                         $$ = EMPTY;
4722                 }
4723                 | INTO opt_sql SQL_DESCRIPTOR quoted_ident_stringvar
4724                 {
4725                         add_variable(&argsresult, descriptor_variable($4,0), &no_indicator);
4726                         $$ = EMPTY;
4727                 }
4728                 ;
4729
4730 opt_ecpg_into: /*EMPTY*/                        { $$ = EMPTY; }
4731                 | ecpg_into                                     { $$ = $1; }
4732                 ;
4733
4734 variable: civarind | civar
4735                 ;
4736 variablelist: variable | variable ',' variablelist;
4737
4738 /*
4739  * As long as the prepare statement is not supported by the backend, we will
4740  * try to simulate it here so we get dynamic SQL
4741  */
4742 ECPGPrepare: PREPARE name FROM execstring
4743                         { $$ = cat2_str(make3_str(make_str("\""), $2, make_str("\",")), $4); }
4744                 ;
4745
4746 /*
4747  * dynamic SQL: descriptor based access
4748  *      written by Christof Petig <christof.petig@wtal.de>
4749  */
4750
4751 /*
4752  * deallocate a descriptor
4753  */
4754 ECPGDeallocateDescr:    DEALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
4755                 {
4756                         drop_descriptor($3,connection);
4757                         $$ = $3;
4758                 }
4759                 ;
4760
4761 /*
4762  * allocate a descriptor
4763  */
4764 ECPGAllocateDescr:      SQL_ALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
4765                 {
4766                         add_descriptor($3,connection);
4767                         $$ = $3;
4768                 };
4769
4770 /*
4771  * read from descriptor
4772  */
4773
4774 ECPGGetDescHeaderItem: CVARIABLE '=' desc_header_item
4775                         { push_assignment($1, $3); }
4776                 ;
4777
4778 desc_header_item:       SQL_COUNT                       { $$ = ECPGd_count; }
4779                 ;
4780
4781 ECPGGetDescItem: CVARIABLE '=' descriptor_item  { push_assignment($1, $3); };
4782
4783 descriptor_item:        SQL_CARDINALITY         { $$ = ECPGd_cardinality; }
4784                 | SQL_DATA                                              { $$ = ECPGd_data; }
4785                 | SQL_DATETIME_INTERVAL_CODE    { $$ = ECPGd_di_code; }
4786                 | SQL_DATETIME_INTERVAL_PRECISION { $$ = ECPGd_di_precision; }
4787                 | SQL_INDICATOR                                 { $$ = ECPGd_indicator; }
4788                 | SQL_KEY_MEMBER                                { $$ = ECPGd_key_member; }
4789                 | SQL_LENGTH                                    { $$ = ECPGd_length; }
4790                 | SQL_NAME                                              { $$ = ECPGd_name; }
4791                 | SQL_NULLABLE                                  { $$ = ECPGd_nullable; }
4792                 | SQL_OCTET_LENGTH                              { $$ = ECPGd_octet; }
4793                 | PRECISION                                             { $$ = ECPGd_precision; }
4794                 | SQL_RETURNED_LENGTH                   { $$ = ECPGd_length; }
4795                 | SQL_RETURNED_OCTET_LENGTH             { $$ = ECPGd_ret_octet; }
4796                 | SQL_SCALE                                             { $$ = ECPGd_scale; }
4797                 | TYPE_P                                                { $$ = ECPGd_type; }
4798                 ;
4799
4800 ECPGGetDescHeaderItems: ECPGGetDescHeaderItem
4801                 | ECPGGetDescHeaderItems ',' ECPGGetDescHeaderItem
4802                 ;
4803
4804 ECPGGetDescItems: ECPGGetDescItem
4805                 | ECPGGetDescItems ',' ECPGGetDescItem
4806                 ;
4807
4808 ECPGGetDescriptorHeader:        GET SQL_DESCRIPTOR quoted_ident_stringvar
4809                                                                 ECPGGetDescHeaderItems
4810                         {  $$ = $3; }
4811                 ;
4812
4813 ECPGGetDescriptor:      GET SQL_DESCRIPTOR quoted_ident_stringvar SQL_VALUE CVARIABLE ECPGGetDescItems
4814                         {  $$.str = $5; $$.name = $3; }
4815                 |       GET SQL_DESCRIPTOR quoted_ident_stringvar SQL_VALUE Iconst ECPGGetDescItems
4816                         {  $$.str = $5; $$.name = $3; }
4817                 ;
4818
4819 /*
4820  * for compatibility with ORACLE we will also allow the keyword RELEASE
4821  * after a transaction statement to disconnect from the database.
4822  */
4823
4824 ECPGRelease: TransactionStmt SQL_RELEASE
4825                 {
4826                         if (strcmp($1, "begin") == 0)
4827                                                         mmerror(PARSE_ERROR, ET_ERROR, "RELEASE does not make sense when beginning a transaction");
4828
4829                         fprintf(yyout, "ECPGtrans(__LINE__, %s, \"%s\");",
4830                                         connection ? connection : "NULL", $1);
4831                         whenever_action(0);
4832                         fprintf(yyout, "ECPGdisconnect(__LINE__, %s);",
4833                                         connection ? connection : "\"CURRENT\"");
4834                         whenever_action(0);
4835                         free($1);
4836                 }
4837                 ;
4838
4839 /*
4840  * set/reset the automatic transaction mode, this needs a differnet handling
4841  * as the other set commands
4842  */
4843 ECPGSetAutocommit:      SET SQL_AUTOCOMMIT '=' on_off   { $$ = $4; }
4844                 |  SET SQL_AUTOCOMMIT TO on_off   { $$ = $4; }
4845                 ;
4846
4847 on_off: ON                              { $$ = make_str("on"); }
4848                 | OFF                   { $$ = make_str("off"); }
4849                 ;
4850
4851 /*
4852  * set the actual connection, this needs a differnet handling as the other
4853  * set commands
4854  */
4855 ECPGSetConnection:      SET SQL_CONNECTION TO connection_object { $$ = $4; }
4856                 | SET SQL_CONNECTION '=' connection_object { $$ = $4; }
4857                 ;
4858
4859 /*
4860  * define a new type for embedded SQL
4861  */
4862 ECPGTypedef: TYPE_P
4863                 {
4864                         /* reset this variable so we see if there was */
4865                         /* an initializer specified */
4866                         initializer = 0;
4867                 }
4868                 ColLabel IS type opt_type_array_bounds opt_reference
4869                 {
4870                         /* add entry to list */
4871                         struct typedefs *ptr, *this;
4872                         int dimension = $6.index1;
4873                         int length = $6.index2;
4874
4875                         if (($5.type_enum == ECPGt_struct ||
4876                                  $5.type_enum == ECPGt_union) &&
4877                                 initializer == 1)
4878                                 mmerror(PARSE_ERROR, ET_ERROR, "Initializer not allowed in EXEC SQL TYPE command");
4879                         else
4880                         {
4881                                 for (ptr = types; ptr != NULL; ptr = ptr->next)
4882                                 {
4883                                         if (strcmp($3, ptr->name) == 0)
4884                                         {
4885                                                 /* re-definition is a bug */
4886                                                 snprintf(errortext, sizeof(errortext), "Type %s already defined", $3);
4887                                                 mmerror(PARSE_ERROR, ET_ERROR, errortext);
4888                                         }
4889                                 }
4890
4891                                 adjust_array($5.type_enum, &dimension, &length, $5.type_dimension, $5.type_index, *$7?1:0);
4892
4893                                 this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
4894
4895                                 /* initial definition */
4896                                 this->next = types;
4897                                 this->name = $3;
4898                                 this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
4899                                 this->type->type_enum = $5.type_enum;
4900                                 this->type->type_str = mm_strdup($3);
4901                                 this->type->type_dimension = dimension; /* dimension of array */
4902                                 this->type->type_index = length;        /* lenght of string */
4903                                 this->type->type_sizeof = ECPGstruct_sizeof;
4904                                 this->struct_member_list = ($5.type_enum == ECPGt_struct || $5.type_enum == ECPGt_union) ?
4905                                         struct_member_list[struct_level] : NULL;
4906
4907                                 if ($5.type_enum != ECPGt_varchar &&
4908                                         $5.type_enum != ECPGt_char &&
4909                                         $5.type_enum != ECPGt_unsigned_char &&
4910                                         this->type->type_index >= 0)
4911                                         mmerror(PARSE_ERROR, ET_ERROR, "No multi-dimensional array support for simple data types");
4912
4913                                 types = this;
4914                         }
4915
4916                         if (auto_create_c == false)
4917                                 $$ = cat_str(7, make_str("/* exec sql type"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, make_str("*/"));
4918                         else
4919                                 $$ = cat_str(6, make_str("typedef "), mm_strdup($5.type_str), *$7?make_str("*"):make_str(""), mm_strdup($6.str), mm_strdup($3), make_str(";"));
4920                 }
4921                 ;
4922
4923 opt_type_array_bounds:  '[' ']' opt_type_array_bounds
4924                 {
4925                         $$.index1 = 0;
4926                         $$.index2 = $3.index1;
4927                         $$.str = cat2_str(make_str("[]"), $3.str);
4928                 }
4929                 | '(' ')' opt_type_array_bounds
4930                 {
4931                         $$.index1 = 0;
4932                         $$.index2 = $3.index1;
4933                         $$.str = cat2_str(make_str("[]"), $3.str);
4934                 }
4935                 | '[' Iresult ']' opt_type_array_bounds
4936                 {
4937                         char *txt = mm_alloc(20L);
4938
4939                         sprintf (txt, "%d", $2);
4940                         $$.index1 = $2;
4941                         $$.index2 = $4.index1;
4942                         $$.str = cat_str(4, make_str("["), txt, make_str("]"), $4.str);
4943                 }
4944                 | '(' Iresult ')' opt_type_array_bounds
4945                 {
4946                         char *txt = mm_alloc(20L);
4947
4948                         sprintf (txt, "%d", $2);
4949                         $$.index1 = $2;
4950                         $$.index2 = $4.index1;
4951                         $$.str = cat_str(4, make_str("["), txt, make_str("]"), $4.str);
4952                 }
4953                 | /* EMPTY */
4954                 {
4955                         $$.index1 = -1;
4956                         $$.index2 = -1;
4957                         $$.str= EMPTY;
4958                 }
4959                 ;
4960
4961 opt_reference: SQL_REFERENCE            { $$ = make_str("reference"); }
4962                 | /*EMPTY*/                                     { $$ = EMPTY; }
4963                 ;
4964
4965 /*
4966  * define the type of one variable for embedded SQL
4967  */
4968 ECPGVar: SQL_VAR
4969                 {
4970                         /* reset this variable so we see if there was */
4971                         /* an initializer specified */
4972                         initializer = 0;
4973                 }
4974                 ColLabel IS type opt_type_array_bounds opt_reference
4975                 {
4976                         struct variable *p = find_variable($3);
4977                         int dimension = $6.index1;
4978                         int length = $6.index2;
4979                         struct ECPGtype * type;
4980
4981                         if (($5.type_enum == ECPGt_struct ||
4982                                  $5.type_enum == ECPGt_union) &&
4983                                 initializer == 1)
4984                                 mmerror(PARSE_ERROR, ET_ERROR, "Initializer not allowed in EXEC SQL VAR command");
4985                         else
4986                         {
4987                                 adjust_array($5.type_enum, &dimension, &length, $5.type_dimension, $5.type_index, *$7?1:0);
4988
4989                                 switch ($5.type_enum)
4990                                 {
4991                                         case ECPGt_struct:
4992                                         case ECPGt_union:
4993                                                 if (dimension < 0)
4994                                                         type = ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, $5.type_sizeof);
4995                                                 else
4996                                                         type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum,$5.type_sizeof), dimension);
4997                                                 break;
4998
4999                                         case ECPGt_varchar:
5000                                                 if (dimension == -1)
5001                                                         type = ECPGmake_simple_type($5.type_enum, length);
5002                                                 else
5003                                                         type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length), dimension);
5004                                                 break;
5005
5006                                         case ECPGt_char:
5007                                         case ECPGt_unsigned_char:
5008                                                 if (dimension == -1)
5009                                                         type = ECPGmake_simple_type($5.type_enum, length);
5010                                                 else
5011                                                         type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length), dimension);
5012                                                 break;
5013
5014                                         default:
5015                                                 if (length >= 0)
5016                                                         mmerror(PARSE_ERROR, ET_ERROR, "No multi-dimensional array support for simple data types");
5017
5018                                                 if (dimension < 0)
5019                                                         type = ECPGmake_simple_type($5.type_enum, 1);
5020                                                 else
5021                                                         type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, 1), dimension);
5022                                                 break;
5023                                 }
5024
5025                                 ECPGfree_type(p->type);
5026                                 p->type = type;
5027                         }
5028
5029                         $$ = cat_str(7, make_str("/* exec sql var"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, make_str("*/"));
5030                 }
5031                 ;
5032
5033 /*
5034  * whenever statement: decide what to do in case of error/no data found
5035  * according to SQL standards we lack: SQLSTATE, CONSTRAINT and SQLEXCEPTION
5036  */
5037 ECPGWhenever: SQL_WHENEVER SQL_SQLERROR action
5038                 {
5039                         when_error.code = $<action>3.code;
5040                         when_error.command = $<action>3.command;
5041                         $$ = cat_str(3, make_str("/* exec sql whenever sqlerror "), $3.str, make_str("; */\n"));
5042                 }
5043                 | SQL_WHENEVER NOT SQL_FOUND action
5044                 {
5045                         when_nf.code = $<action>4.code;
5046                         when_nf.command = $<action>4.command;
5047                         $$ = cat_str(3, make_str("/* exec sql whenever not found "), $4.str, make_str("; */\n"));
5048                 }
5049                 | SQL_WHENEVER SQL_SQLWARNING action
5050                 {
5051                         when_warn.code = $<action>3.code;
5052                         when_warn.command = $<action>3.command;
5053                         $$ = cat_str(3, make_str("/* exec sql whenever sql_warning "), $3.str, make_str("; */\n"));
5054                 }
5055                 ;
5056
5057 action : SQL_CONTINUE
5058                 {
5059                         $<action>$.code = W_NOTHING;
5060                         $<action>$.command = NULL;
5061                         $<action>$.str = make_str("continue");
5062                 }
5063                 | SQL_SQLPRINT
5064                 {
5065                         $<action>$.code = W_SQLPRINT;
5066                         $<action>$.command = NULL;
5067                         $<action>$.str = make_str("sqlprint");
5068                 }
5069                 | SQL_STOP
5070                 {
5071                         $<action>$.code = W_STOP;
5072                         $<action>$.command = NULL;
5073                         $<action>$.str = make_str("stop");
5074                 }
5075                 | SQL_GOTO name
5076                 {
5077                         $<action>$.code = W_GOTO;
5078                         $<action>$.command = strdup($2);
5079                         $<action>$.str = cat2_str(make_str("goto "), $2);
5080                 }
5081                 | SQL_GO TO name
5082                 {
5083                         $<action>$.code = W_GOTO;
5084                         $<action>$.command = strdup($3);
5085                         $<action>$.str = cat2_str(make_str("goto "), $3);
5086                 }
5087                 | DO name '(' c_args ')'
5088                 {
5089                         $<action>$.code = W_DO;
5090                         $<action>$.command = cat_str(4, $2, make_str("("), $4, make_str(")"));
5091                         $<action>$.str = cat2_str(make_str("do"), mm_strdup($<action>$.command));
5092                 }
5093                 | DO SQL_BREAK
5094                 {
5095                         $<action>$.code = W_BREAK;
5096                         $<action>$.command = NULL;
5097                         $<action>$.str = make_str("break");
5098                 }
5099                 | SQL_CALL name '(' c_args ')'
5100                 {
5101                         $<action>$.code = W_DO;
5102                         $<action>$.command = cat_str(4, $2, make_str("("), $4, make_str(")"));
5103                         $<action>$.str = cat2_str(make_str("call"), mm_strdup($<action>$.command));
5104                 }
5105                 ;
5106
5107 /* some other stuff for ecpg */
5108
5109 /* additional unreserved keywords */
5110 ECPGKeywords:  SQL_BREAK                { $$ = make_str("break"); }
5111                 | SQL_CALL                              { $$ = make_str("call"); }
5112                 | SQL_CARDINALITY               { $$ = make_str("cardinality"); }
5113                 | SQL_CONNECT                   { $$ = make_str("connect"); }
5114                 | SQL_CONTINUE                  { $$ = make_str("continue"); }
5115                 | SQL_COUNT                             { $$ = make_str("count"); }
5116                 | SQL_DATA                              { $$ = make_str("data"); }
5117                 | SQL_DATETIME_INTERVAL_CODE    { $$ = make_str("datetime_interval_code"); }
5118                 | SQL_DATETIME_INTERVAL_PRECISION       { $$ = make_str("datetime_interval_precision"); }
5119                 | SQL_DISCONNECT                { $$ = make_str("disconnect"); }
5120                 | SQL_FOUND                             { $$ = make_str("found"); }
5121                 | SQL_GO                                { $$ = make_str("go"); }
5122                 | SQL_GOTO                              { $$ = make_str("goto"); }
5123                 | SQL_IDENTIFIED                { $$ = make_str("identified"); }
5124                 | SQL_INDICATOR                 { $$ = make_str("indicator"); }
5125                 | SQL_KEY_MEMBER                { $$ = make_str("key_member"); }
5126                 | SQL_LENGTH                    { $$ = make_str("length"); }
5127                 | SQL_NAME                              { $$ = make_str("name"); }
5128                 | SQL_NULLABLE                  { $$ = make_str("nullable"); }
5129                 | SQL_OCTET_LENGTH              { $$ = make_str("octet_length"); }
5130                 | SQL_OPEN                              { $$ = make_str("open"); }
5131                 | SQL_RELEASE                   { $$ = make_str("release"); }
5132                 | SQL_RETURNED_LENGTH           { $$ = make_str("returned_length"); }
5133                 | SQL_RETURNED_OCTET_LENGTH { $$ = make_str("returned_octet_length"); }
5134                 | SQL_SCALE                             { $$ = make_str("scale"); }
5135                 | SQL_SECTION                   { $$ = make_str("section"); }
5136                 | SQL_SQLERROR                  { $$ = make_str("sqlerror"); }
5137                 | SQL_SQLPRINT                  { $$ = make_str("sqlprint"); }
5138                 | SQL_SQLWARNING                { $$ = make_str("sqlwarning"); }
5139                 | SQL_STOP                              { $$ = make_str("stop"); }
5140                 | SQL_VAR                               { $$ = make_str("var"); }
5141                 | SQL_WHENEVER                  { $$ = make_str("whenever"); }
5142                 ;
5143
5144 /* additional keywords that can be SQL type names (but not ECPGColLabels) */
5145 ECPGTypeName:  SQL_BOOL                         { $$ = make_str("bool"); }
5146                 | SQL_LONG                      { $$ = make_str("long"); }
5147                 | SQL_SHORT                     { $$ = make_str("short"); }
5148                 | SQL_STRUCT                    { $$ = make_str("struct"); }
5149                 | SQL_SIGNED                    { $$ = make_str("signed"); }
5150                 | SQL_UNSIGNED                  { $$ = make_str("unsigned"); }
5151                 ;
5152
5153 opt_symbol: symbol                              { $$ = $1; }
5154                 | /*EMPTY*/                             { $$ = EMPTY; }
5155                 ;
5156
5157 symbol: ColLabel                                { $$ = $1; }
5158                 ;
5159
5160 /*
5161  * Name classification hierarchy.
5162  *
5163  * IDENT is the lexeme returned by the lexer for identifiers that match
5164  * no known keyword.  In most cases, we can accept certain keywords as
5165  * names, not only IDENTs.      We prefer to accept as many such keywords
5166  * as possible to minimize the impact of "reserved words" on programmers.
5167  * So, we divide names into several possible classes.  The classification
5168  * is chosen in part to make keywords acceptable as names wherever possible.
5169  */
5170
5171 /* Column identifier --- names that can be column, table, etc names.
5172  */
5173 ColId:  ident                                                   { $$ = $1; }
5174                 | unreserved_keyword                    { $$ = $1; }
5175                 | col_name_keyword                              { $$ = $1; }
5176                 | ECPGKeywords                                  { $$ = $1; }
5177                 | CHAR_P                                                { $$ = make_str("char"); }
5178                 ;
5179
5180 /* Type identifier --- names that can be type names.
5181  */
5182 type_name:      ident                                           { $$ = $1; }
5183                 | unreserved_keyword                    { $$ = $1; }
5184                 | ECPGKeywords                                  { $$ = $1; }
5185                 | ECPGTypeName                                  { $$ = $1; }
5186                 ;
5187
5188 /* Function identifier --- names that can be function names.
5189  */
5190 function_name:  ident                                           { $$ = $1; }
5191                 | unreserved_keyword                    { $$ = $1; }
5192                 | func_name_keyword                             { $$ = $1; }
5193                 | ECPGKeywords                                  { $$ = $1; }
5194                 ;
5195
5196 /* Column label --- allowed labels in "AS" clauses.
5197  * This presently includes *all* Postgres keywords.
5198  */
5199 ColLabel:  ECPGColLabel                                 { $$ = $1; }
5200                 | ECPGTypeName                                  { $$ = $1; }
5201                 | CHAR_P                                                { $$ = make_str("char"); }
5202                 | INT                                                   { $$ = make_str("int"); }
5203                 | UNION                                                 { $$ = make_str("union"); }
5204                 ;
5205
5206 ECPGColLabelCommon:  ident                              { $$ = $1; }
5207                 | col_name_keyword                      { $$ = $1; }
5208                 | func_name_keyword                     { $$ = $1; }
5209                 ;
5210
5211 ECPGColLabel:  ECPGColLabelCommon                       { $$ = $1; }
5212                 | unreserved_keyword                    { $$ = $1; }
5213                 | reserved_keyword                      { $$ = $1; }
5214                 | ECPGKeywords                          { $$ = $1; }
5215                 ;
5216
5217 /*
5218  * Keyword classification lists.  Generally, every keyword present in
5219  * the Postgres grammar should appear in exactly one of these lists.
5220  *
5221  * Put a new keyword into the first list that it can go into without causing
5222  * shift or reduce conflicts.  The earlier lists define "less reserved"
5223  * categories of keywords.
5224  */
5225
5226 /* "Unreserved" keywords --- available for use as any kind of name.
5227  */
5228 unreserved_keyword:
5229                   ABORT_P                                       { $$ = make_str("abort"); }
5230                 | ABSOLUTE                                              { $$ = make_str("absolute"); }
5231                 | ACCESS                                                { $$ = make_str("access"); }
5232                 | ACTION                                                { $$ = make_str("action"); }
5233                 | ADD                                                   { $$ = make_str("add"); }
5234                 | AFTER                                                 { $$ = make_str("after"); }
5235                 | AGGREGATE                                             { $$ = make_str("aggregate"); }
5236                 | ALTER                                                 { $$ = make_str("alter"); }
5237                 | ASSERTION                                             { $$ = make_str("assertion"); }
5238                 | ASSIGNMENT                                            { $$ = make_str("assignment"); }
5239                 | AT                                                    { $$ = make_str("at"); }
5240                 | BACKWARD                                              { $$ = make_str("backward"); }
5241                 | BEFORE                                                { $$ = make_str("before"); }
5242                 | BEGIN_P                                       { $$ = make_str("begin"); }
5243                 | BY                                                    { $$ = make_str("by"); }
5244                 | CACHE                                                 { $$ = make_str("cache"); }
5245                 | CASCADE                                               { $$ = make_str("cascade"); }
5246                 | CHAIN                                                 { $$ = make_str("chain"); }
5247                 | CHARACTERISTICS                               { $$ = make_str("characteristics"); }
5248                 | CHECKPOINT                                    { $$ = make_str("checkpoint"); }
5249                 | CLASS                                                 { $$ = make_str("class"); }
5250                 | CLOSE                                                 { $$ = make_str("close"); }
5251                 | CLUSTER                                               { $$ = make_str("cluster"); }
5252                 | COMMENT                                               { $$ = make_str("comment"); }
5253                 | COMMIT                                                { $$ = make_str("commit"); }
5254                 | COMMITTED                                             { $$ = make_str("committed"); }
5255                 | CONSTRAINTS                                           { $$ = make_str("constraints"); }
5256                 | CONVERSION_P                                          { $$ = make_str("conversion"); }
5257                 | COPY                                                  { $$ = make_str("copy"); }
5258                 | CREATEDB                                              { $$ = make_str("createdb"); }
5259                 | CREATEUSER                                    { $$ = make_str("createuser"); }
5260                 | CURSOR                                                { $$ = make_str("cursor"); }
5261                 | CYCLE                                                 { $$ = make_str("cycle"); }
5262                 | DATABASE                                              { $$ = make_str("database"); }
5263                 | DAY_P                                                 { $$ = make_str("day"); }
5264                 | DEALLOCATE                                            { $$ = make_str("deallocate"); }
5265                 | DECLARE                                               { $$ = make_str("declare"); }
5266                 | DEFERRED                                              { $$ = make_str("deferred"); }
5267                 | DELETE_P                                              { $$ = make_str("delete"); }
5268                 | DELIMITER                                     { $$ = make_str("delimiter"); }
5269                 | DELIMITERS                                    { $$ = make_str("delimiters"); }
5270                 | DOMAIN_P                                      { $$ = make_str("domain"); }
5271                 | DOUBLE                                                { $$ = make_str("double"); }
5272                 | DROP                                                  { $$ = make_str("drop"); }
5273                 | EACH                                                  { $$ = make_str("each"); }
5274                 | ENCODING                                              { $$ = make_str("encoding"); }
5275                 | ENCRYPTED                                             { $$ = make_str("encrypted"); }
5276                 | ESCAPE                                                { $$ = make_str("escape"); }
5277                 | EXCLUSIVE                                             { $$ = make_str("exclusive"); }
5278                 | EXECUTE                                               { $$ = make_str("execute"); }
5279                 | EXPLAIN                                               { $$ = make_str("explain"); }
5280                 | FETCH                                                 { $$ = make_str("fetch"); }
5281                 | FORCE                                                 { $$ = make_str("force"); }
5282                 | FORWARD                                               { $$ = make_str("forward"); }
5283                 | FUNCTION                                              { $$ = make_str("function"); }
5284                 | GLOBAL                                                { $$ = make_str("global"); }
5285                 | HANDLER                                               { $$ = make_str("handler"); }
5286                 | HOUR_P                                                { $$ = make_str("hour"); }
5287                 | IMMEDIATE                                             { $$ = make_str("immediate"); }
5288                 | IMMUTABLE                                             { $$ = make_str("immutable"); }
5289                 | IMPLICIT_P                                            { $$ = make_str("implicit"); }
5290                 | INCREMENT                                             { $$ = make_str("increment"); }
5291                 | INDEX                                                 { $$ = make_str("index"); }
5292                 | INHERITS                                              { $$ = make_str("inherits"); }
5293                 | INOUT                                                 { $$ = make_str("inout"); }
5294                 | INSENSITIVE                                   { $$ = make_str("insensitive"); }
5295                 | INSERT                                                { $$ = make_str("insert"); }
5296                 | INSTEAD                                               { $$ = make_str("instead"); }
5297                 | ISOLATION                                             { $$ = make_str("isolation"); }
5298                 | KEY                                                   { $$ = make_str("key"); }
5299                 | LANCOMPILER                                           { $$ = make_str("lancompiler"); }
5300                 | LANGUAGE                                              { $$ = make_str("language"); }
5301                 | LEVEL                                                 { $$ = make_str("level"); }
5302                 | LISTEN                                                { $$ = make_str("listen"); }
5303                 | LOAD                                                  { $$ = make_str("load"); }
5304                 | LOCAL                                                 { $$ = make_str("local"); }
5305                 | LOCATION                                              { $$ = make_str("location"); }
5306                 | LOCK_P                                                { $$ = make_str("lock"); }
5307                 | MATCH                                                 { $$ = make_str("match"); }
5308                 | MAXVALUE                                              { $$ = make_str("maxvalue"); }
5309                 | MINUTE_P                                              { $$ = make_str("minute"); }
5310                 | MINVALUE                                              { $$ = make_str("minvalue"); }
5311                 | MODE                                                  { $$ = make_str("mode"); }
5312                 | MONTH_P                                               { $$ = make_str("month"); }
5313                 | MOVE                                                  { $$ = make_str("move"); }
5314                 | NAMES                                                 { $$ = make_str("names"); }
5315                 | NATIONAL                                              { $$ = make_str("national"); }
5316                 | NEXT                                                  { $$ = make_str("next"); }
5317                 | NO                                                    { $$ = make_str("no"); }
5318                 | NOCREATEDB                                    { $$ = make_str("nocreatedb"); }
5319                 | NOCREATEUSER                                  { $$ = make_str("nocreateuser"); }
5320                 | NOTHING                                               { $$ = make_str("nothing"); }
5321                 | NOTIFY                                                { $$ = make_str("notify"); }
5322                 | OF                                                    { $$ = make_str("of"); }
5323                 | OIDS                                                  { $$ = make_str("oids"); }
5324                 | OPERATOR                                              { $$ = make_str("operator"); }
5325                 | OPTION                                                { $$ = make_str("option"); }
5326                 | OUT_P                                                 { $$ = make_str("out"); }
5327                 | OWNER                                                 { $$ = make_str("owner"); }
5328                 | PARTIAL                                               { $$ = make_str("partial"); }
5329                 | PASSWORD                                              { $$ = make_str("password"); }
5330                 | PATH_P                                                { $$ = make_str("path"); }
5331                 | PENDANT                                               { $$ = make_str("pendant"); }
5332                 | PRECISION                                             { $$ = make_str("precision"); }
5333                 | PREPARE                                               { $$ = make_str("prepare"); }
5334                 | PRESERVE                                              { $$ = make_str("preserver"); }
5335                 | PRIOR                                                 { $$ = make_str("prior"); }
5336                 | PRIVILEGES                                    { $$ = make_str("privileges"); }
5337                 | PROCEDURAL                                    { $$ = make_str("procedural"); }
5338                 | PROCEDURE                                             { $$ = make_str("procedure"); }
5339                 | READ                                                  { $$ = make_str("read"); }
5340                 | RECHECK                                               { $$ = make_str("recheck"); }
5341                 | REINDEX                                               { $$ = make_str("reindex"); }
5342                 | RELATIVE                                              { $$ = make_str("relative"); }
5343                 | RENAME                                                { $$ = make_str("rename"); }
5344                 | REPLACE                                               { $$ = make_str("replace"); }
5345                 | RESET                                                 { $$ = make_str("reset"); }
5346                 | RESTRICT                                              { $$ = make_str("restrict"); }
5347                 | RETURNS                                               { $$ = make_str("returns"); }
5348                 | REVOKE                                                { $$ = make_str("revoke"); }
5349                 | ROLLBACK                                              { $$ = make_str("rollback"); }
5350                 | ROWS                                                  { $$ = make_str("rows"); }
5351                 | RULE                                                  { $$ = make_str("rule"); }
5352                 | SCHEMA                                                { $$ = make_str("schema"); }
5353                 | SCROLL                                                { $$ = make_str("scroll"); }
5354                 | SECOND_P                                              { $$ = make_str("second"); }
5355                 | SESSION                                               { $$ = make_str("session"); }
5356                 | SEQUENCE                                              { $$ = make_str("sequence"); }
5357                 | SERIALIZABLE                                  { $$ = make_str("serializable"); }
5358                 | SET                                                   { $$ = make_str("set"); }
5359                 | SHARE                                                 { $$ = make_str("share"); }
5360                 | SHOW                                                  { $$ = make_str("show"); }
5361                 | SIMPLE                                                { $$ = make_str("simple"); }
5362                 | STABLE                                                { $$ = make_str("stable"); }
5363                 | START                                                 { $$ = make_str("start"); }
5364                 | STATEMENT                                             { $$ = make_str("statement"); }
5365                 | STATISTICS                                    { $$ = make_str("statistics"); }
5366                 | STDIN                                                 { $$ = make_str("stdin"); }
5367                 | STDOUT                                                { $$ = make_str("stdout"); }
5368                 | STORAGE                                               { $$ = make_str("storage"); }
5369                 | SYSID                                                 { $$ = make_str("sysid"); }
5370                 | TEMP                                                  { $$ = make_str("temp"); }
5371                 | TEMPLATE                                              { $$ = make_str("template"); }
5372                 | TEMPORARY                                             { $$ = make_str("temporary"); }
5373                 | TOAST                                                 { $$ = make_str("toast"); }
5374                 | TRANSACTION                                   { $$ = make_str("transaction"); }
5375                 | TRIGGER                                               { $$ = make_str("trigger"); }
5376                 | TRUNCATE                                              { $$ = make_str("truncate"); }
5377                 | TRUSTED                                               { $$ = make_str("trusted"); }
5378                 | TYPE_P                                                { $$ = make_str("type"); }
5379                 | UNENCRYPTED                                   { $$ = make_str("unencrypted"); }
5380                 | UNKNOWN                                               { $$ = make_str("unknown"); }
5381                 | UNLISTEN                                              { $$ = make_str("unlisten"); }
5382                 | UNTIL                                                 { $$ = make_str("until"); }
5383                 | UPDATE                                                { $$ = make_str("update"); }
5384                 | USAGE                                                 { $$ = make_str("usage"); }
5385                 | VACUUM                                                { $$ = make_str("vacuum"); }
5386                 | VALID                                                 { $$ = make_str("valid"); }
5387                 | VALUES                                                { $$ = make_str("values"); }
5388                 | VARYING                                               { $$ = make_str("varying"); }
5389                 | VERSION                                               { $$ = make_str("version"); }
5390                 | VIEW                                                  { $$ = make_str("view"); }
5391                 | WITH                                                  { $$ = make_str("with"); }
5392                 | WITHOUT                                               { $$ = make_str("without"); }
5393                 | WRITE                                                 { $$ = make_str("write"); }
5394                 | WORK                                                  { $$ = make_str("work"); }
5395                 | YEAR_P                                                { $$ = make_str("year"); }
5396                 | ZONE                                                  { $$ = make_str("zone"); }
5397                 ;
5398
5399 /* Column identifier --- keywords that can be column, table, etc names.
5400  *
5401  * Many of these keywords will in fact be recognized as type or function
5402  * names too; but they have special productions for the purpose, and so
5403  * can't be treated as "generic" type or function names.
5404  *
5405  * The type names appearing here are not usable as function names
5406  * because they can be followed by '(' in typename productions, which
5407  * looks too much like a function call for an LR(1) parser.
5408  */
5409 col_name_keyword:
5410                 BIGINT                  { $$ = make_str("bigint");}
5411                 | BIT                   { $$ = make_str("bit"); }
5412 /* CHAR must be excluded from ECPGColLabel because of conflict with UNSIGNED
5413                 | CHAR_P                { $$ = make_str("char"); }
5414  */
5415                 | CHARACTER             { $$ = make_str("character"); }
5416                 | COALESCE              { $$ = make_str("coalesce"); }
5417                 | CONVERT               { $$ = make_str("convert"); }
5418                 | DEC                   { $$ = make_str("dec"); }
5419                 | DECIMAL               { $$ = make_str("decimal"); }
5420                 | EXISTS                { $$ = make_str("exists"); }
5421                 | EXTRACT               { $$ = make_str("extract"); }
5422                 | FLOAT_P               { $$ = make_str("float"); }
5423 /* INT must be excluded from ECPGColLabel because of conflict
5424                 | INT                   { $$ = make_str("int"); }
5425  */
5426                 | INTEGER               { $$ = make_str("integer"); }
5427                 | INTERVAL              { $$ = make_str("interval"); }
5428                 | NCHAR                 { $$ = make_str("nchar"); }
5429                 | NONE                  { $$ = make_str("none"); }
5430                 | NULLIF                { $$ = make_str("nullif"); }
5431                 | NUMERIC               { $$ = make_str("numeric"); }
5432                 | POSITION              { $$ = make_str("position"); }
5433                 | REAL                  { $$ = make_str("real"); }
5434                 | ROW                   { $$ = make_str("row"); }
5435                 | SETOF                 { $$ = make_str("setof"); }
5436                 | SMALLINT              { $$ = make_str("smallint"); }
5437                 | SUBSTRING             { $$ = make_str("substring"); }
5438                 | TIME                  { $$ = make_str("time"); }
5439                 | TIMESTAMP             { $$ = make_str("timestamp"); }
5440                 | TREAT                 { $$ = make_str("treat"); }
5441                 | TRIM                  { $$ = make_str("trim"); }
5442                 | VARCHAR               { $$ = make_str("varchar"); }
5443                 ;
5444
5445 /* Function identifier --- keywords that can be function names.
5446  *
5447  * Most of these are keywords that are used as operators in expressions;
5448  * in general such keywords can't be column names because they would be
5449  * ambiguous with variables, but they are unambiguous as function identifiers.
5450  *
5451  * Do not include POSITION, SUBSTRING, etc here since they have explicit
5452  * productions in a_expr to support the goofy SQL9x argument syntax.
5453  *      - thomas 2000-11-28
5454  */
5455 func_name_keyword:
5456                   AUTHORIZATION                                 { $$ = make_str("authorization"); }
5457                 | BETWEEN                                               { $$ = make_str("between"); }
5458                 | BINARY                                                { $$ = make_str("binary"); }
5459                 | CROSS                                                 { $$ = make_str("cross"); }
5460                 | FREEZE                                                { $$ = make_str("freeze"); }
5461                 | FULL                                                  { $$ = make_str("full"); }
5462                 | ILIKE                                                 { $$ = make_str("ilike"); }
5463                 | IN_P                                                  { $$ = make_str("in"); }
5464                 | INNER_P                                               { $$ = make_str("inner"); }
5465                 | IS                                                    { $$ = make_str("is"); }
5466                 | ISNULL                                                { $$ = make_str("isnull"); }
5467                 | JOIN                                                  { $$ = make_str("join"); }
5468                 | LEFT                                                  { $$ = make_str("left"); }
5469                 | LIKE                                                  { $$ = make_str("like"); }
5470                 | NATURAL                                               { $$ = make_str("natural"); }
5471                 | NOTNULL                                               { $$ = make_str("notnull"); }
5472                 | OUTER_P                                               { $$ = make_str("outer"); }
5473                 | OVERLAPS                                              { $$ = make_str("overlaps"); }
5474                 | RIGHT                                                 { $$ = make_str("right"); }
5475                 | SIMILAR                                               { $$ = make_str("similar"); }
5476                 | VERBOSE                                               { $$ = make_str("verbose"); }
5477                 ;
5478
5479 /* Reserved keyword --- these keywords are usable only as a ColLabel.
5480  *
5481  * Keywords appear here if they could not be distinguished from variable,
5482  * type, or function names in some contexts.  Don't put things here unless
5483  * forced to.
5484  */
5485 reserved_keyword:
5486                   ALL                                                   { $$ = make_str("all"); }
5487                 | ANALYSE                                               { $$ = make_str("analyse"); } /* British */
5488                 | ANALYZE                                               { $$ = make_str("analyze"); }
5489                 | AND                                                   { $$ = make_str("and"); }
5490                 | ANY                                                   { $$ = make_str("any"); }
5491                 | AS                                                    { $$ = make_str("as"); }
5492                 | ASC                                                   { $$ = make_str("asc"); }
5493                 | BOTH                                                  { $$ = make_str("both"); }
5494                 | CASE                                                  { $$ = make_str("case"); }
5495                 | CAST                                                  { $$ = make_str("cast"); }
5496                 | CHECK                                                 { $$ = make_str("check"); }
5497                 | COLLATE                                               { $$ = make_str("collate"); }
5498                 | COLUMN                                                { $$ = make_str("column"); }
5499                 | CONSTRAINT                                    { $$ = make_str("constraint"); }
5500                 | CREATE                                                { $$ = make_str("create"); }
5501                 | CURRENT_DATE                                  { $$ = make_str("current_date"); }
5502                 | CURRENT_TIME                                  { $$ = make_str("current_time"); }
5503                 | CURRENT_TIMESTAMP                             { $$ = make_str("current_timestamp"); }
5504                 | CURRENT_USER                                  { $$ = make_str("current_user"); }
5505                 | DEFAULT                                               { $$ = make_str("default"); }
5506                 | DEFERRABLE                                    { $$ = make_str("deferrable"); }
5507                 | DESC                                                  { $$ = make_str("desc"); }
5508                 | DISTINCT                                              { $$ = make_str("distinct"); }
5509                 | DO                                                    { $$ = make_str("do"); }
5510                 | ELSE                                                  { $$ = make_str("else"); }
5511                 | END_P                                         { $$ = make_str("end"); }
5512                 | EXCEPT                                                { $$ = make_str("except"); }
5513                 | FALSE_P                                               { $$ = make_str("false"); }
5514                 | FOR                                                   { $$ = make_str("for"); }
5515                 | FOREIGN                                               { $$ = make_str("foreign"); }
5516                 | FROM                                                  { $$ = make_str("from"); }
5517                 | GRANT                                                 { $$ = make_str("grant"); }
5518                 | GROUP_P                                               { $$ = make_str("group"); }
5519                 | HAVING                                                { $$ = make_str("having"); }
5520                 | INITIALLY                                             { $$ = make_str("initially"); }
5521                 | INTERSECT                                             { $$ = make_str("intersect"); }
5522                 | INTO                                                  { $$ = make_str("into"); }
5523                 | LEADING                                               { $$ = make_str("leading"); }
5524                 | LIMIT                                                 { $$ = make_str("limit"); }
5525                 | NEW                                                   { $$ = make_str("new"); }
5526                 | NOT                                                   { $$ = make_str("not"); }
5527                 | NULL_P                                                { $$ = make_str("null"); }
5528                 | OFF                                                   { $$ = make_str("off"); }
5529                 | OFFSET                                                { $$ = make_str("offset"); }
5530                 | OLD                                                   { $$ = make_str("old"); }
5531                 | ON                                                    { $$ = make_str("on"); }
5532                 | ONLY                                                  { $$ = make_str("only"); }
5533                 | OR                                                    { $$ = make_str("or"); }
5534                 | ORDER                                                 { $$ = make_str("order"); }
5535                 | PRIMARY                                               { $$ = make_str("primary"); }
5536                 | REFERENCES                                    { $$ = make_str("references"); }
5537                 | SELECT                                                { $$ = make_str("select"); }
5538                 | SESSION_USER                                  { $$ = make_str("session_user"); }
5539                 | SOME                                                  { $$ = make_str("some"); }
5540                 | TABLE                                                 { $$ = make_str("table"); }
5541                 | THEN                                                  { $$ = make_str("then"); }
5542                 | TO                                                    { $$ = make_str("to"); }
5543                 | TRAILING                                              { $$ = make_str("trailing"); }
5544                 | TRUE_P                                                { $$ = make_str("true"); }
5545 /* UNION must be excluded from ECPGColLabel because of conflict with s_union
5546                 | UNION                                                 { $$ = make_str("union"); }
5547  */
5548                 | UNIQUE                                                { $$ = make_str("unique"); }
5549                 | USER                                                  { $$ = make_str("user"); }
5550                 | USING                                                 { $$ = make_str("using"); }
5551                 | WHEN                                                  { $$ = make_str("when"); }
5552                 | WHERE                                                 { $$ = make_str("where"); }
5553                 ;
5554
5555
5556 into_list : coutputvariable | into_list ',' coutputvariable
5557                 ;
5558
5559 ecpgstart: SQL_START    { reset_variables(); }
5560                 ;
5561
5562 c_args: /*EMPTY*/               { $$ = EMPTY; }
5563                 | c_list                { $$ = $1; }
5564                 ;
5565
5566 coutputvariable: CVARIABLE indicator
5567                         { add_variable(&argsresult, find_variable($1), find_variable($2)); }
5568                 | CVARIABLE
5569                         { add_variable(&argsresult, find_variable($1), &no_indicator); }
5570                 ;
5571
5572
5573 civarind: CVARIABLE indicator
5574                 {
5575                         if ($2 != NULL && (find_variable($2))->type->type == ECPGt_array)
5576                                 mmerror(PARSE_ERROR, ET_ERROR, "arrays of indicators are not allowed on input");
5577
5578                         add_variable(&argsinsert, find_variable($1), ($2 == NULL) ? &no_indicator : find_variable($2));
5579                 }
5580                 ;
5581
5582 civar: CVARIABLE
5583                 {
5584                         add_variable(&argsinsert, find_variable($1), &no_indicator);
5585                         $$ = $1;
5586                 }
5587                 ;
5588
5589 indicator: CVARIABLE                            { check_indicator((find_variable($1))->type); $$ = $1; }
5590                 | SQL_INDICATOR CVARIABLE       { check_indicator((find_variable($2))->type); $$ = $2; }
5591                 | SQL_INDICATOR name            { check_indicator((find_variable($2))->type); $$ = $2; }
5592                 ;
5593
5594 ident: IDENT                                            { $$ = $1; }
5595                 | CSTRING                                       { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
5596                 ;
5597
5598 quoted_ident_stringvar: name
5599                         { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
5600                 | char_variable
5601                         { $$ = make3_str(make_str("("), $1, make_str(")")); }
5602                 ;
5603
5604 /*
5605  * C stuff
5606  */
5607
5608 c_stuff_item: c_anything                        { $$ = $1; }
5609                 | '(' ')'                       { $$ = make_str("()"); }
5610                 | '(' c_stuff ')'
5611                         { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
5612                 ;
5613
5614 c_stuff: c_stuff_item   { $$ = $1; }
5615                 | c_stuff c_stuff_item
5616                         { $$ = cat2_str($1, $2); }
5617                 ;
5618
5619 c_list: c_term                          { $$ = $1; }
5620                 | c_list ',' c_term     { $$ = cat_str(3, $1, make_str(","), $3); }
5621                 ;
5622
5623 c_term:  c_stuff                        { $$ = $1; }
5624                 | '{' c_list '}'        { $$ = cat_str(3, make_str("{"), $2, make_str("}")); }
5625                 ;
5626
5627 c_thing:        c_anything      { $$ = $1; }
5628                 |       '('     { $$ = make_str("("); }
5629                 |       ')'     { $$ = make_str(")"); }
5630                 |       ','     { $$ = make_str(","); }
5631                 |       ';'     { $$ = make_str(";"); }
5632                 ;
5633
5634 c_anything:  IDENT                                      { $$ = $1; }
5635                 | CSTRING                                       { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
5636                 | PosIntConst                           { $$ = $1; }
5637                 | Fconst                                        { $$ = $1; }
5638                 | Sconst                                        { $$ = $1; }
5639                 | '*'                                           { $$ = make_str("*"); }
5640                 | '+'                                           { $$ = make_str("+"); }
5641                 | '-'                                           { $$ = make_str("-"); }
5642                 | '/'                                           { $$ = make_str("/"); }
5643                 | '%'                                           { $$ = make_str("%"); }
5644                 | NULL_P                                        { $$ = make_str("NULL"); }
5645                 | S_ADD                                         { $$ = make_str("+="); }
5646                 | S_AND                                         { $$ = make_str("&&"); }
5647                 | S_ANYTHING                            { $$ = make_name(); }
5648                 | S_AUTO                                        { $$ = make_str("auto"); }
5649                 | S_CONST                                       { $$ = make_str("const"); }
5650                 | S_DEC                                         { $$ = make_str("--"); }
5651                 | S_DIV                                         { $$ = make_str("/="); }
5652                 | S_DOTPOINT                            { $$ = make_str(".*"); }
5653                 | S_EQUAL                                       { $$ = make_str("=="); }
5654                 | S_EXTERN                                      { $$ = make_str("extern"); }
5655                 | S_INC                                         { $$ = make_str("++"); }
5656                 | S_LSHIFT                                      { $$ = make_str("<<"); }
5657                 | S_MEMBER                                      { $$ = make_str("->"); }
5658                 | S_MEMPOINT                            { $$ = make_str("->*"); }
5659                 | S_MOD                                         { $$ = make_str("%="); }
5660                 | S_MUL                                         { $$ = make_str("*="); }
5661                 | S_NEQUAL                                      { $$ = make_str("!="); }
5662                 | S_OR                                          { $$ = make_str("||"); }
5663                 | S_REGISTER                            { $$ = make_str("register"); }
5664                 | S_RSHIFT                                      { $$ = make_str(">>"); }
5665                 | S_STATIC                                      { $$ = make_str("static"); }
5666                 | S_SUB                                         { $$ = make_str("-="); }
5667                 | S_TYPEDEF                             { $$ = make_str("typedef"); }
5668                 | SQL_BOOL                                      { $$ = make_str("bool"); }
5669                 | SQL_ENUM                                      { $$ = make_str("enum"); }
5670                 | INT                                   { $$ = make_str("int"); }
5671                 | SQL_LONG                                      { $$ = make_str("long"); }
5672                 | SQL_SHORT                                     { $$ = make_str("short"); }
5673                 | SQL_SIGNED                            { $$ = make_str("signed"); }
5674                 | SQL_STRUCT                            { $$ = make_str("struct"); }
5675                 | SQL_UNSIGNED                          { $$ = make_str("unsigned"); }
5676                 | CHAR_P                                        { $$ = make_str("char"); }
5677                 | DOUBLE                                        { $$ = make_str("double"); }
5678                 | FLOAT_P                                       { $$ = make_str("float"); }
5679                 | UNION                                         { $$ = make_str("union"); }
5680                 | VARCHAR                                       { $$ = make_str("varchar"); }
5681                 | '['                                           { $$ = make_str("["); }
5682                 | ']'                                           { $$ = make_str("]"); }
5683                 | '='                                           { $$ = make_str("="); }
5684                 ;
5685
5686 %%
5687
5688 void yyerror( char * error)
5689 {
5690         char buf[1024];
5691
5692         snprintf(buf,sizeof buf,"%s at or near \"%s\"", error, token_start ? token_start : yytext);
5693         buf[sizeof(buf)-1]=0;
5694         mmerror(PARSE_ERROR, ET_ERROR, buf);
5695 }
5696
5697 #include "pgc.c"