granicus.if.org Git - postgresql/blob - src/backend/parser/gram.y

   1 %{ /* -*-text-*- */
   2
   3 /*#define YYDEBUG 1*/
   4 /*-------------------------------------------------------------------------
   5  *
   6  * gram.y--
   7  *        POSTGRES SQL YACC rules/actions
   8  *
   9  * Copyright (c) 1994, Regents of the University of California
  10  *
  11  *
  12  * IDENTIFICATION
  13  *        $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.90 1998/01/11 20:01:59 momjian Exp $
  14  *
  15  * HISTORY
  16  *        AUTHOR                        DATE                    MAJOR EVENT
  17  *        Andrew Yu                     Sept, 1994              POSTQUEL to SQL conversion
  18  *        Andrew Yu                     Oct, 1994               lispy code conversion
  19  *
  20  * NOTES
  21  *        CAPITALS are used to represent terminal symbols.
  22  *        non-capitals are used to represent non-terminals.
  23  *        SQL92-specific syntax is separated from plain SQL/Postgres syntax
  24  *        to help isolate the non-extensible portions of the parser.
  25  *
  26  *        if you use list, make sure the datum is a node so that the printing
  27  *        routines work
  28  *
  29  * WARNING
  30  *        sometimes we assign constants to makeStrings. Make sure we don't free
  31  *        those.
  32  *
  33  *-------------------------------------------------------------------------
  34  */
  35 #include <string.h>
  36 #include <ctype.h>
  37
  38 #include "postgres.h"
  39 #include "nodes/parsenodes.h"
  40 #include "nodes/print.h"
  41 #include "parser/gramparse.h"
  42 #include "parser/parse_type.h"
  43 #include "utils/acl.h"
  44 #include "utils/palloc.h"
  45 #include "catalog/catname.h"
  46 #include "utils/elog.h"
  47 #include "access/xact.h"
  48
  49 static char saved_relname[NAMEDATALEN];  /* need this for complex attributes */
  50 static bool QueryIsRule = FALSE;
  51 static Node *saved_In_Expr;
  52 static Oid      *param_type_info;
  53 static int      pfunc_num_args;
  54 extern List *parsetree;
  55
  56
  57 /*
  58  * If you need access to certain yacc-generated variables and find that
  59  * they're static by default, uncomment the next line.  (this is not a
  60  * problem, yet.)
  61  */
  62 /*#define __YYSCLASS*/
  63
  64 static char *xlateSqlType(char *);
  65 static Node *makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr);
  66 static Node *makeRowExpr(char *opr, List *largs, List *rargs);
  67 void mapTargetColumns(List *source, List *target);
  68 static List *makeConstantList( A_Const *node);
  69 static char *FlattenStringList(List *list);
  70 static char *fmtId(char *rawid);
  71 static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr);
  72 static void param_type_init(Oid *typev, int nargs);
  73
  74 Oid     param_type(int t); /* used in parse_expr.c */
  75
  76 /* old versions of flex define this as a macro */
  77 #if defined(yywrap)
  78 #undef yywrap
  79 #endif /* yywrap */
  80 %}
  81
  82
  83 %union
  84 {
  85         double                          dval;
  86         int                                     ival;
  87         char                            chr;
  88         char                            *str;
  89         bool                            boolean;
  90         bool*                           pboolean;       /* for pg_user privileges */
  91         List                            *list;
  92         Node                            *node;
  93         Value                           *value;
  94
  95         Attr                            *attr;
  96
  97         TypeName                        *typnam;
  98         DefElem                         *defelt;
  99         ParamString                     *param;
 100         SortGroupBy                     *sortgroupby;
 101         IndexElem                       *ielem;
 102         RangeVar                        *range;
 103         RelExpr                         *relexp;
 104         A_Indices                       *aind;
 105         ResTarget                       *target;
 106         ParamNo                         *paramno;
 107
 108         VersionStmt                     *vstmt;
 109         DefineStmt                      *dstmt;
 110         RuleStmt                        *rstmt;
 111         InsertStmt                      *astmt;
 112 }
 113
 114 %type <node>    stmt,
 115                 AddAttrStmt, ClosePortalStmt,
 116                 CopyStmt, CreateStmt, CreateAsStmt, CreateSeqStmt, DefineStmt, DestroyStmt,
 117                 ExtendStmt, FetchStmt,  GrantStmt, CreateTrigStmt, DropTrigStmt,
 118                 CreatePLangStmt, DropPLangStmt,
 119                 IndexStmt, ListenStmt, OptimizableStmt,
 120                 ProcedureStmt,  RecipeStmt, RemoveAggrStmt, RemoveOperStmt,
 121                 RemoveFuncStmt, RemoveStmt,
 122                 RenameStmt, RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
 123                 CreatedbStmt, DestroydbStmt, VacuumStmt, CursorStmt, SubSelect,
 124                 UpdateStmt, InsertStmt, SelectStmt, NotifyStmt, DeleteStmt, ClusterStmt,
 125                 ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt,
 126                 CreateUserStmt, AlterUserStmt, DropUserStmt
 127
 128 %type <rtstmt>
 129
 130 %type <str>             opt_database, location
 131
 132 %type <pboolean> user_createdb_clause, user_createuser_clause
 133 %type <str>   user_passwd_clause
 134 %type <str>   user_valid_clause
 135 %type <list>  user_group_list, user_group_clause
 136
 137 %type <str>             join_expr, join_outer, join_spec
 138 %type <boolean> TriggerActionTime, TriggerForSpec, PLangTrusted
 139
 140 %type <str>             TriggerEvents, TriggerFuncArg
 141
 142 %type <str>             relation_name, copy_file_name, copy_delimiter, def_name,
 143                 database_name, access_method_clause, access_method, attr_name,
 144                 class, index_name, name, file_name, recipe_name, aggr_argtype
 145
 146 %type <str>             opt_id, opt_portal_name,
 147                 all_Op, MathOp, opt_name, opt_unique,
 148                 result, OptUseOp, opt_class, SpecialRuleRelation
 149
 150 %type <str>             privileges, operation_commalist, grantee
 151 %type <chr>             operation, TriggerOneEvent
 152
 153 %type <list>    stmtblock, stmtmulti,
 154                 relation_name_list, OptTableElementList,
 155                 OptInherit, definition,
 156                 opt_with, def_args, def_name_list, func_argtypes,
 157                 oper_argtypes, OptStmtList, OptStmtBlock, OptStmtMulti,
 158                 opt_column_list, columnList, opt_va_list, va_list,
 159                 sort_clause, sortby_list, index_params, index_list, name_list,
 160                 from_clause, from_list, opt_array_bounds, nest_array_bounds,
 161                 expr_list, attrs, res_target_list, res_target_list2,
 162                 def_list, opt_indirection, group_clause, groupby_list, TriggerFuncArgs
 163
 164 %type <list>    union_clause, select_list
 165 %type <list>    join_list
 166 %type <sortgroupby>
 167                                 join_using
 168 %type <boolean> opt_union
 169
 170 %type <node>    position_expr
 171 %type <list>    extract_list, position_list
 172 %type <list>    substr_list, substr_from, substr_for, trim_list
 173 %type <list>    opt_interval
 174
 175 %type <boolean> opt_inh_star, opt_binary, opt_instead, opt_with_copy,
 176                                 index_opt_unique, opt_verbose, opt_analyze
 177
 178 %type <ival>    copy_dirn, def_type, opt_direction, remove_type,
 179                                 opt_column, event
 180
 181 %type <ival>    fetch_how_many
 182
 183 %type <list>    OptSeqList
 184 %type <defelt>  OptSeqElem
 185
 186 %type <dstmt>   def_rest
 187 %type <astmt>   insert_rest
 188
 189 %type <node>    OptTableElement, ConstraintElem
 190 %type <node>    columnDef, alter_clause
 191 %type <defelt>  def_elem
 192 %type <node>    def_arg, columnElem, where_clause,
 193                                 a_expr, a_expr_or_null, AexprConst,
 194                                 in_expr, in_expr_nodes, not_in_expr, not_in_expr_nodes,
 195                                 having_clause
 196 %type <list>    row_descriptor, row_list
 197 %type <node>    row_expr
 198 %type <list>    OptCreateAs, CreateAsList
 199 %type <node>    CreateAsElement
 200 %type <value>   NumConst
 201 %type <attr>    event_object, attr
 202 %type <sortgroupby>             groupby
 203 %type <sortgroupby>             sortby
 204 %type <ielem>   index_elem, func_index
 205 %type <range>   from_val
 206 %type <relexp>  relation_expr
 207 %type <target>  res_target_el, res_target_el2
 208 %type <paramno> ParamNo
 209
 210 %type <typnam>  Typename, opt_type, Array, Generic, Character, Datetime, Numeric
 211 %type <str>             generic, character, datetime
 212 %type <str>             opt_charset, opt_collate
 213 %type <str>             opt_float, opt_numeric, opt_decimal
 214 %type <boolean> opt_varying, opt_timezone
 215
 216 %type <ival>    Iconst
 217 %type <str>             Sconst
 218 %type <str>             Id, var_value, zone_value
 219 %type <str>             ColId, ColLabel
 220
 221 %type <node>    TableConstraint
 222 %type <list>    constraint_list, constraint_expr
 223 %type <list>    default_list, default_expr
 224 %type <list>    ColQualList, ColQualifier
 225 %type <node>    ColConstraint, ColConstraintElem
 226 %type <list>    key_actions, key_action
 227 %type <str>             key_match, key_reference
 228
 229 /*
 230  * If you make any token changes, remember to:
 231  *              - use "yacc -d" and update parse.h
 232  *              - update the keyword table in parser/keywords.c
 233  */
 234
 235 /* Reserved word tokens
 236  * SQL92 syntax has many type-specific constructs.
 237  * So, go ahead and make these types reserved words,
 238  *  and call-out the syntax explicitly.
 239  * This gets annoying when trying to also retain Postgres' nice
 240  *  type-extensible features, but we don't really have a choice.
 241  * - thomas 1997-10-11
 242  */
 243
 244 /* Keywords (in SQL92 reserved words) */
 245 %token  ACTION, ADD, ALL, ALTER, AND, AS, ASC,
 246                 BEGIN_TRANS, BETWEEN, BOTH, BY,
 247                 CASCADE, CAST, CHAR, CHARACTER, CHECK, CLOSE, COLLATE, COLUMN, COMMIT,
 248                 CONSTRAINT, CREATE, CROSS, CURRENT, CURRENT_DATE, CURRENT_TIME,
 249                 CURRENT_TIMESTAMP, CURRENT_USER, CURSOR,
 250                 DAY_P, DECIMAL, DECLARE, DEFAULT, DELETE, DESC, DISTINCT, DOUBLE, DROP,
 251                 END_TRANS, EXECUTE, EXISTS, EXTRACT,
 252                 FETCH, FLOAT, FOR, FOREIGN, FROM, FULL,
 253                 GRANT, GROUP, HAVING, HOUR_P,
 254                 IN, INNER_P, INSERT, INTERVAL, INTO, IS,
 255                 JOIN, KEY, LANGUAGE, LEADING, LEFT, LIKE, LOCAL,
 256                 MATCH, MINUTE_P, MONTH_P,
 257                 NATIONAL, NATURAL, NCHAR, NO, NOT, NOTIFY, NULL_P, NUMERIC,
 258                 ON, OPTION, OR, ORDER, OUTER_P,
 259                 PARTIAL, POSITION, PRECISION, PRIMARY, PRIVILEGES, PROCEDURE, PUBLIC,
 260                 REFERENCES, REVOKE, RIGHT, ROLLBACK,
 261                 SECOND_P, SELECT, SET, SUBSTRING,
 262                 TABLE, TIME, TIMESTAMP, TO, TRAILING, TRANSACTION, TRIM,
 263                 UNION, UNIQUE, UPDATE, USING,
 264                 VALUES, VARCHAR, VARYING, VERBOSE, VERSION, VIEW,
 265                 WHERE, WITH, WORK, YEAR_P, ZONE
 266
 267 /* Keywords (in SQL3 reserved words) */
 268 %token  FALSE_P, TRIGGER, TRUE_P
 269
 270 /* Keywords (in SQL92 non-reserved words) */
 271 %token  TYPE_P
 272
 273 /* Keywords for Postgres support (not in SQL92 reserved words) */
 274 %token  ABORT_TRANS, ACL, AFTER, AGGREGATE, ANALYZE,
 275                 APPEND, BACKWARD, BEFORE, BINARY, CHANGE, CLUSTER, COPY,
 276                 DATABASE, DELIMITERS, DO, EXPLAIN, EXTEND,
 277                 FORWARD, FUNCTION, HANDLER,
 278                 INDEX, INHERITS, INSTEAD, ISNULL,
 279                 LANCOMPILER, LISTEN, LOAD, LOCATION, MERGE, MOVE,
 280                 NEW, NONE, NOTHING, NOTNULL, OIDS, OPERATOR, PROCEDURAL,
 281                 RECIPE, RENAME, REPLACE, RESET, RETRIEVE, RETURNS, RULE,
 282                 SEQUENCE, SETOF, SHOW, STDIN, STDOUT, TRUSTED,
 283                 VACUUM, VERBOSE, VERSION
 284
 285 /* Keywords (obsolete; retain temporarily for parser - thomas 1997-12-04) */
 286 %token  ARCHIVE
 287
 288 /*
 289  * Tokens for pg_passwd support.  The CREATEDB and CREATEUSER tokens should go away
 290  * when some sort of pg_privileges relation is introduced.
 291  *
 292  *                                    Todd A. Brandys
 293  */
 294 %token  USER, PASSWORD, CREATEDB, NOCREATEDB, CREATEUSER, NOCREATEUSER, VALID, UNTIL
 295
 296 /* Special keywords, not in the query language - see the "lex" file */
 297 %token <str>    IDENT, SCONST, Op
 298 %token <ival>   ICONST, PARAM
 299 %token <dval>   FCONST
 300
 301 /* these are not real. they are here so that they get generated as #define's*/
 302 %token                  OP
 303
 304 /* precedence */
 305 %left           OR
 306 %left           AND
 307 %right          NOT
 308 %right          '='
 309 %nonassoc       '<' '>'
 310 %nonassoc       LIKE
 311 %nonassoc       BETWEEN
 312 %nonassoc       IN
 313 %nonassoc       Op                              /* multi-character ops and user-defined operators */
 314 %nonassoc       NOTNULL
 315 %nonassoc       ISNULL
 316 %nonassoc       IS
 317 %left           '+' '-'
 318 %left           '*' '/'
 319 %left           '|'                             /* this is the relation union op, not logical or */
 320 /* Unary Operators */
 321 %right          ':'
 322 %left           ';'                             /* end of statement or natural log */
 323 %right          UMINUS
 324 %left           '.'
 325 %left           '[' ']'
 326 %nonassoc       TYPECAST
 327 %nonassoc       REDUCE
 328 %left           UNION
 329 %%
 330
 331 stmtblock:  stmtmulti
 332                                 { parsetree = $1; }
 333                 | stmt
 334                                 { parsetree = lcons($1,NIL); }
 335                 ;
 336
 337 stmtmulti:  stmtmulti stmt ';'
 338                                 { $$ = lappend($1, $2); }
 339                 | stmtmulti stmt
 340                                 { $$ = lappend($1, $2); }
 341                 | stmt ';'
 342                                 { $$ = lcons($1,NIL); }
 343                 ;
 344
 345 stmt :    AddAttrStmt
 346                 | AlterUserStmt
 347                 | ClosePortalStmt
 348                 | CopyStmt
 349                 | CreateStmt
 350                 | CreateAsStmt
 351                 | CreateSeqStmt
 352                 | CreatePLangStmt
 353                 | CreateTrigStmt
 354                 | CreateUserStmt
 355                 | ClusterStmt
 356                 | DefineStmt
 357                 | DestroyStmt
 358                 | DropPLangStmt
 359                 | DropTrigStmt
 360                 | DropUserStmt
 361                 | ExtendStmt
 362                 | ExplainStmt
 363                 | FetchStmt
 364                 | GrantStmt
 365                 | IndexStmt
 366                 | ListenStmt
 367                 | ProcedureStmt
 368                 | RecipeStmt
 369                 | RemoveAggrStmt
 370                 | RemoveOperStmt
 371                 | RemoveFuncStmt
 372                 | RemoveStmt
 373                 | RenameStmt
 374                 | RevokeStmt
 375                 | OptimizableStmt
 376                 | RuleStmt
 377                 | TransactionStmt
 378                 | ViewStmt
 379                 | LoadStmt
 380                 | CreatedbStmt
 381                 | DestroydbStmt
 382                 | VacuumStmt
 383                 | VariableSetStmt
 384                 | VariableShowStmt
 385                 | VariableResetStmt
 386                 ;
 387
 388 /*****************************************************************************
 389  *
 390  * Create a new Postgres DBMS user
 391  *
 392  *
 393  *****************************************************************************/
 394
 395 CreateUserStmt:  CREATE USER Id user_passwd_clause user_createdb_clause
 396                         user_createuser_clause user_group_clause user_valid_clause
 397                                 {
 398                                         CreateUserStmt *n = makeNode(CreateUserStmt);
 399                                         n->user = $3;
 400                                         n->password = $4;
 401                                         n->createdb = $5;
 402                                         n->createuser = $6;
 403                                         n->groupElts = $7;
 404                                         n->validUntil = $8;
 405                                         $$ = (Node *)n;
 406                                 }
 407                 ;
 408
 409 /*****************************************************************************
 410  *
 411  * Alter a postresql DBMS user
 412  *
 413  *
 414  *****************************************************************************/
 415
 416 AlterUserStmt:  ALTER USER Id user_passwd_clause user_createdb_clause
 417                         user_createuser_clause user_group_clause user_valid_clause
 418                                 {
 419                                         AlterUserStmt *n = makeNode(AlterUserStmt);
 420                                         n->user = $3;
 421                                         n->password = $4;
 422                                         n->createdb = $5;
 423                                         n->createuser = $6;
 424                                         n->groupElts = $7;
 425                                         n->validUntil = $8;
 426                                         $$ = (Node *)n;
 427                                 }
 428                 ;
 429
 430 /*****************************************************************************
 431  *
 432  * Drop a postresql DBMS user
 433  *
 434  *
 435  *****************************************************************************/
 436
 437 DropUserStmt:  DROP USER Id
 438                                 {
 439                                         DropUserStmt *n = makeNode(DropUserStmt);
 440                                         n->user = $3;
 441                                         $$ = (Node *)n;
 442                                 }
 443                 ;
 444
 445 user_passwd_clause:  WITH PASSWORD Id                   { $$ = $3; }
 446                         | /*EMPTY*/                                                     { $$ = NULL; }
 447                 ;
 448
 449 user_createdb_clause:  CREATEDB
 450                                 {
 451                                         bool*  b;
 452                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 453                                         *b = true;
 454                                 }
 455                         | NOCREATEDB
 456                                 {
 457                                         bool*  b;
 458                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 459                                         *b = false;
 460                                 }
 461                         | /*EMPTY*/                                                     { $$ = NULL; }
 462                 ;
 463
 464 user_createuser_clause:  CREATEUSER
 465                                 {
 466                                         bool*  b;
 467                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 468                                         *b = true;
 469                                 }
 470                         | NOCREATEUSER
 471                                 {
 472                                         bool*  b;
 473                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 474                                         *b = false;
 475                                 }
 476                         | /*EMPTY*/                                                     { $$ = NULL; }
 477                 ;
 478
 479 user_group_list:  user_group_list ',' Id
 480                                 {
 481                                         $$ = lcons((void*)makeString($3), $1);
 482                                 }
 483                         | Id
 484                                 {
 485                                         $$ = lcons((void*)makeString($1), NIL);
 486                                 }
 487                 ;
 488
 489 user_group_clause:  IN GROUP user_group_list    { $$ = $3; }
 490                         | /*EMPTY*/                                                     { $$ = NULL; }
 491                 ;
 492
 493 user_valid_clause:  VALID UNTIL SCONST                  { $$ = $3; }
 494                         | /*EMPTY*/                                                     { $$ = NULL; }
 495                 ;
 496
 497 /*****************************************************************************
 498  *
 499  * Set PG internal variable
 500  *        SET name TO 'var_value'
 501  * Include SQL92 syntax (thomas 1997-10-22):
 502  *    SET TIME ZONE 'var_value'
 503  *
 504  *****************************************************************************/
 505
 506 VariableSetStmt:  SET ColId TO var_value
 507                                 {
 508                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 509                                         n->name  = $2;
 510                                         n->value = $4;
 511                                         $$ = (Node *) n;
 512                                 }
 513                 | SET ColId '=' var_value
 514                                 {
 515                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 516                                         n->name  = $2;
 517                                         n->value = $4;
 518                                         $$ = (Node *) n;
 519                                 }
 520                 | SET TIME ZONE zone_value
 521                                 {
 522                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 523                                         n->name  = "timezone";
 524                                         n->value = $4;
 525                                         $$ = (Node *) n;
 526                                 }
 527                 ;
 528
 529 var_value:  Sconst                      { $$ = $1; }
 530                 | DEFAULT                       { $$ = NULL; }
 531                 ;
 532
 533 zone_value:  Sconst                     { $$ = $1; }
 534                 | DEFAULT                       { $$ = NULL; }
 535                 | LOCAL                         { $$ = "default"; }
 536                 ;
 537
 538 VariableShowStmt:  SHOW ColId
 539                                 {
 540                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 541                                         n->name  = $2;
 542                                         $$ = (Node *) n;
 543                                 }
 544                 | SHOW TIME ZONE
 545                                 {
 546                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 547                                         n->name  = "timezone";
 548                                         $$ = (Node *) n;
 549                                 }
 550                 ;
 551
 552 VariableResetStmt:      RESET ColId
 553                                 {
 554                                         VariableResetStmt *n = makeNode(VariableResetStmt);
 555                                         n->name  = $2;
 556                                         $$ = (Node *) n;
 557                                 }
 558                 | RESET TIME ZONE
 559                                 {
 560                                         VariableResetStmt *n = makeNode(VariableResetStmt);
 561                                         n->name  = "timezone";
 562                                         $$ = (Node *) n;
 563                                 }
 564                 ;
 565
 566
 567 /*****************************************************************************
 568  *
 569  *              QUERY :
 570  *                              addattr ( attr1 = type1 .. attrn = typen ) to <relname> [*]
 571  *
 572  *****************************************************************************/
 573
 574 AddAttrStmt:  ALTER TABLE relation_name opt_inh_star alter_clause
 575                                 {
 576                                         AddAttrStmt *n = makeNode(AddAttrStmt);
 577                                         n->relname = $3;
 578                                         n->inh = $4;
 579                                         n->colDef = $5;
 580                                         $$ = (Node *)n;
 581                                 }
 582                 ;
 583
 584 alter_clause:  ADD opt_column columnDef
 585                                 {
 586                                         $$ = $3;
 587                                 }
 588                         | ADD '(' OptTableElementList ')'
 589                                 {
 590                                         Node *lp = lfirst($3);
 591
 592                                         if (length($3) != 1)
 593                                                 elog(ERROR,"ALTER TABLE/ADD() allows one column only");
 594                                         $$ = lp;
 595                                 }
 596                         | DROP opt_column ColId
 597                                 {       elog(ERROR,"ALTER TABLE/DROP COLUMN not yet implemented"); }
 598                         | ALTER opt_column ColId SET DEFAULT default_expr
 599                                 {       elog(ERROR,"ALTER TABLE/ALTER COLUMN/SET DEFAULT not yet implemented"); }
 600                         | ALTER opt_column ColId DROP DEFAULT
 601                                 {       elog(ERROR,"ALTER TABLE/ALTER COLUMN/DROP DEFAULT not yet implemented"); }
 602                         | ADD ConstraintElem
 603                                 {       elog(ERROR,"ALTER TABLE/ADD CONSTRAINT not yet implemented"); }
 604                 ;
 605
 606
 607 /*****************************************************************************
 608  *
 609  *              QUERY :
 610  *                              close <optname>
 611  *
 612  *****************************************************************************/
 613
 614 ClosePortalStmt:  CLOSE opt_id
 615                                 {
 616                                         ClosePortalStmt *n = makeNode(ClosePortalStmt);
 617                                         n->portalname = $2;
 618                                         $$ = (Node *)n;
 619                                 }
 620                 ;
 621
 622
 623 /*****************************************************************************
 624  *
 625  *              QUERY :
 626  *                              COPY [BINARY] <relname> FROM/TO
 627  *                              [USING DELIMITERS <delimiter>]
 628  *
 629  *****************************************************************************/
 630
 631 CopyStmt:  COPY opt_binary relation_name opt_with_copy copy_dirn copy_file_name copy_delimiter
 632                                 {
 633                                         CopyStmt *n = makeNode(CopyStmt);
 634                                         n->binary = $2;
 635                                         n->relname = $3;
 636                                         n->oids = $4;
 637                                         n->direction = $5;
 638                                         n->filename = $6;
 639                                         n->delimiter = $7;
 640                                         $$ = (Node *)n;
 641                                 }
 642                 ;
 643
 644 copy_dirn:      TO
 645                                 { $$ = TO; }
 646                 | FROM
 647                                 { $$ = FROM; }
 648                 ;
 649
 650 /*
 651  * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
 652  * used depends on the direction. (It really doesn't make sense to copy from
 653  * stdout. We silently correct the "typo".               - AY 9/94
 654  */
 655 copy_file_name:  Sconst                                                 { $$ = $1; }
 656                 | STDIN                                                                 { $$ = NULL; }
 657                 | STDOUT                                                                { $$ = NULL; }
 658                 ;
 659
 660 opt_binary:  BINARY                                                             { $$ = TRUE; }
 661                 | /*EMPTY*/                                                             { $$ = FALSE; }
 662                 ;
 663
 664 opt_with_copy:  WITH OIDS                                               { $$ = TRUE; }
 665                 | /*EMPTY*/                                                             { $$ = FALSE; }
 666                 ;
 667
 668 /*
 669  * the default copy delimiter is tab but the user can configure it
 670  */
 671 copy_delimiter:  USING DELIMITERS Sconst                { $$ = $3; }
 672                 | /*EMPTY*/                                                             { $$ = "\t"; }
 673                 ;
 674
 675
 676 /*****************************************************************************
 677  *
 678  *              QUERY :
 679  *                              CREATE relname
 680  *
 681  *****************************************************************************/
 682
 683 CreateStmt:  CREATE TABLE relation_name '(' OptTableElementList ')'
 684                                 OptInherit OptArchiveType
 685                                 {
 686                                         CreateStmt *n = makeNode(CreateStmt);
 687                                         n->relname = $3;
 688                                         n->tableElts = $5;
 689                                         n->inhRelnames = $7;
 690                                         n->constraints = NIL;
 691                                         $$ = (Node *)n;
 692                                 }
 693                 ;
 694
 695 OptTableElementList:  OptTableElementList ',' OptTableElement
 696                                                                                                 { $$ = lappend($1, $3); }
 697                         | OptTableElement                                       { $$ = lcons($1, NIL); }
 698                         | /*EMPTY*/                                                     { $$ = NULL; }
 699                 ;
 700
 701 OptTableElement:  columnDef                                             { $$ = $1; }
 702                         | TableConstraint                                       { $$ = $1; }
 703                 ;
 704
 705 columnDef:  ColId Typename ColQualifier
 706                                 {
 707                                         ColumnDef *n = makeNode(ColumnDef);
 708                                         n->colname = $1;
 709                                         n->typename = $2;
 710                                         n->defval = NULL;
 711                                         n->is_not_null = FALSE;
 712                                         n->constraints = $3;
 713                                         $$ = (Node *)n;
 714                                 }
 715                 ;
 716
 717 ColQualifier:  ColQualList                                              { $$ = $1; }
 718                         | /*EMPTY*/                                                     { $$ = NULL; }
 719                 ;
 720
 721 ColQualList:  ColQualList ColConstraint                 { $$ = lappend($1,$2); }
 722                         | ColConstraint                                         { $$ = lcons($1, NIL); }
 723                 ;
 724
 725 ColConstraint:
 726                 CONSTRAINT name ColConstraintElem
 727                                 {
 728                                                 Constraint *n = (Constraint *)$3;
 729                                                 n->name = fmtId($2);
 730                                                 $$ = $3;
 731                                 }
 732                 | ColConstraintElem
 733                                 { $$ = $1; }
 734                 ;
 735
 736 ColConstraintElem:  CHECK '(' constraint_expr ')'
 737                                 {
 738                                         Constraint *n = makeNode(Constraint);
 739                                         n->contype = CONSTR_CHECK;
 740                                         n->name = NULL;
 741                                         n->def = FlattenStringList($3);
 742                                         n->keys = NULL;
 743                                         $$ = (Node *)n;
 744                                 }
 745                         | DEFAULT default_expr
 746                                 {
 747                                         Constraint *n = makeNode(Constraint);
 748                                         n->contype = CONSTR_DEFAULT;
 749                                         n->name = NULL;
 750                                         n->def = FlattenStringList($2);
 751                                         n->keys = NULL;
 752                                         $$ = (Node *)n;
 753                                 }
 754                         | NOT NULL_P
 755                                 {
 756                                         Constraint *n = makeNode(Constraint);
 757                                         n->contype = CONSTR_NOTNULL;
 758                                         n->name = NULL;
 759                                         n->def = NULL;
 760                                         n->keys = NULL;
 761                                         $$ = (Node *)n;
 762                                 }
 763                         | UNIQUE
 764                                 {
 765                                         Constraint *n = makeNode(Constraint);
 766                                         n->contype = CONSTR_UNIQUE;
 767                                         n->name = NULL;
 768                                         n->def = NULL;
 769                                         n->keys = NULL;
 770                                         $$ = (Node *)n;
 771                                 }
 772                         | PRIMARY KEY
 773                                 {
 774                                         Constraint *n = makeNode(Constraint);
 775                                         n->contype = CONSTR_PRIMARY;
 776                                         n->name = NULL;
 777                                         n->def = NULL;
 778                                         n->keys = NULL;
 779                                         $$ = (Node *)n;
 780                                 }
 781                         | REFERENCES ColId opt_column_list key_match key_actions
 782                                 {
 783                                         elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented");
 784                                         $$ = NULL;
 785                                 }
 786                 ;
 787
 788 default_list:  default_list ',' default_expr
 789                                 {
 790                                         $$ = lappend($1,makeString(","));
 791                                         $$ = nconc($$, $3);
 792                                 }
 793                         | default_expr
 794                                 {
 795                                         $$ = $1;
 796                                 }
 797                 ;
 798
 799 default_expr:  AexprConst
 800                                 {       $$ = makeConstantList((A_Const *) $1); }
 801                         | NULL_P
 802                                 {       $$ = lcons( makeString("NULL"), NIL); }
 803                         | '-' default_expr %prec UMINUS
 804                                 {       $$ = lcons( makeString( "-"), $2); }
 805                         | default_expr '+' default_expr
 806                                 {       $$ = nconc( $1, lcons( makeString( "+"), $3)); }
 807                         | default_expr '-' default_expr
 808                                 {       $$ = nconc( $1, lcons( makeString( "-"), $3)); }
 809                         | default_expr '/' default_expr
 810                                 {       $$ = nconc( $1, lcons( makeString( "/"), $3)); }
 811                         | default_expr '*' default_expr
 812                                 {       $$ = nconc( $1, lcons( makeString( "*"), $3)); }
 813                         | default_expr '=' default_expr
 814                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 815                         | default_expr '<' default_expr
 816                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 817                         | default_expr '>' default_expr
 818                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 819                         | ':' default_expr
 820                                 {       $$ = lcons( makeString( ":"), $2); }
 821                         | ';' default_expr
 822                                 {       $$ = lcons( makeString( ";"), $2); }
 823                         | '|' default_expr
 824                                 {       $$ = lcons( makeString( "|"), $2); }
 825                         | default_expr TYPECAST Typename
 826                                 {
 827                                         $3->name = fmtId($3->name);
 828                                         $$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
 829                                 }
 830                         | CAST default_expr AS Typename
 831                                 {
 832                                         $4->name = fmtId($4->name);
 833                                         $$ = nconc( lcons( makeString( "CAST"), $2), makeList( makeString("AS"), $4, -1));
 834                                 }
 835                         | '(' default_expr ')'
 836                                 {       $$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
 837                         | name '(' ')'
 838                                 {
 839                                         $$ = makeList( makeString($1), makeString("("), -1);
 840                                         $$ = lappend( $$, makeString(")"));
 841                                 }
 842                         | name '(' default_list ')'
 843                                 {
 844                                         $$ = makeList( makeString($1), makeString("("), -1);
 845                                         $$ = nconc( $$, $3);
 846                                         $$ = lappend( $$, makeString(")"));
 847                                 }
 848                         | default_expr Op default_expr
 849                                 {
 850                                         if (!strcmp("<=", $2) || !strcmp(">=", $2))
 851                                                 elog(ERROR,"boolean expressions not supported in DEFAULT");
 852                                         $$ = nconc( $1, lcons( makeString( $2), $3));
 853                                 }
 854                         | Op default_expr
 855                                 {       $$ = lcons( makeString( $1), $2); }
 856                         | default_expr Op
 857                                 {       $$ = lappend( $1, makeString( $2)); }
 858                         /* XXX - thomas 1997-10-07 v6.2 function-specific code to be changed */
 859                         | CURRENT_DATE
 860                                 {       $$ = lcons( makeString( "date( 'current'::datetime + '0 sec')"), NIL); }
 861                         | CURRENT_TIME
 862                                 {       $$ = lcons( makeString( "'now'::time"), NIL); }
 863                         | CURRENT_TIME '(' Iconst ')'
 864                                 {
 865                                         if ($3 != 0)
 866                                                 elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
 867                                         $$ = lcons( makeString( "'now'::time"), NIL);
 868                                 }
 869                         | CURRENT_TIMESTAMP
 870                                 {       $$ = lcons( makeString( "now()"), NIL); }
 871                         | CURRENT_TIMESTAMP '(' Iconst ')'
 872                                 {
 873                                         if ($3 != 0)
 874                                                 elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
 875                                         $$ = lcons( makeString( "now()"), NIL);
 876                                 }
 877                         | CURRENT_USER
 878                                 {       $$ = lcons( makeString( "CURRENT_USER"), NIL); }
 879                 ;
 880
 881 /* ConstraintElem specifies constraint syntax which is not embedded into
 882  *  a column definition. ColConstraintElem specifies the embedded form.
 883  * - thomas 1997-12-03
 884  */
 885 TableConstraint:  CONSTRAINT name ConstraintElem
 886                                 {
 887                                                 Constraint *n = (Constraint *)$3;
 888                                                 n->name = fmtId($2);
 889                                                 $$ = $3;
 890                                 }
 891                 | ConstraintElem
 892                                 { $$ = $1; }
 893                 ;
 894
 895 ConstraintElem:  CHECK '(' constraint_expr ')'
 896                                 {
 897                                         Constraint *n = makeNode(Constraint);
 898                                         n->contype = CONSTR_CHECK;
 899                                         n->name = NULL;
 900                                         n->def = FlattenStringList($3);
 901                                         $$ = (Node *)n;
 902                                 }
 903                 | UNIQUE '(' columnList ')'
 904                                 {
 905                                         Constraint *n = makeNode(Constraint);
 906                                         n->contype = CONSTR_UNIQUE;
 907                                         n->name = NULL;
 908                                         n->def = NULL;
 909                                         n->keys = $3;
 910                                         $$ = (Node *)n;
 911                                 }
 912                 | PRIMARY KEY '(' columnList ')'
 913                                 {
 914                                         Constraint *n = makeNode(Constraint);
 915                                         n->contype = CONSTR_PRIMARY;
 916                                         n->name = NULL;
 917                                         n->def = NULL;
 918                                         n->keys = $4;
 919                                         $$ = (Node *)n;
 920                                 }
 921                 | FOREIGN KEY '(' columnList ')' REFERENCES ColId opt_column_list key_match key_actions
 922                                 {       elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented"); }
 923                 ;
 924
 925 constraint_list:  constraint_list ',' constraint_expr
 926                                 {
 927                                         $$ = lappend($1,makeString(","));
 928                                         $$ = nconc($$, $3);
 929                                 }
 930                         | constraint_expr
 931                                 {
 932                                         $$ = $1;
 933                                 }
 934                 ;
 935
 936 constraint_expr:  AexprConst
 937                                 {       $$ = makeConstantList((A_Const *) $1); }
 938                         | NULL_P
 939                                 {       $$ = lcons( makeString("NULL"), NIL); }
 940                         | ColId
 941                                 {
 942                                         $$ = lcons( makeString(fmtId($1)), NIL);
 943                                 }
 944                         | '-' constraint_expr %prec UMINUS
 945                                 {       $$ = lcons( makeString( "-"), $2); }
 946                         | constraint_expr '+' constraint_expr
 947                                 {       $$ = nconc( $1, lcons( makeString( "+"), $3)); }
 948                         | constraint_expr '-' constraint_expr
 949                                 {       $$ = nconc( $1, lcons( makeString( "-"), $3)); }
 950                         | constraint_expr '/' constraint_expr
 951                                 {       $$ = nconc( $1, lcons( makeString( "/"), $3)); }
 952                         | constraint_expr '*' constraint_expr
 953                                 {       $$ = nconc( $1, lcons( makeString( "*"), $3)); }
 954                         | constraint_expr '=' constraint_expr
 955                                 {       $$ = nconc( $1, lcons( makeString( "="), $3)); }
 956                         | constraint_expr '<' constraint_expr
 957                                 {       $$ = nconc( $1, lcons( makeString( "<"), $3)); }
 958                         | constraint_expr '>' constraint_expr
 959                                 {       $$ = nconc( $1, lcons( makeString( ">"), $3)); }
 960                         | ':' constraint_expr
 961                                 {       $$ = lcons( makeString( ":"), $2); }
 962                         | ';' constraint_expr
 963                                 {       $$ = lcons( makeString( ";"), $2); }
 964                         | '|' constraint_expr
 965                                 {       $$ = lcons( makeString( "|"), $2); }
 966                         | constraint_expr TYPECAST Typename
 967                                 {
 968                                         $3->name = fmtId($3->name);
 969                                         $$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
 970                                 }
 971                         | CAST constraint_expr AS Typename
 972                                 {
 973                                         $4->name = fmtId($4->name);
 974                                         $$ = nconc( lcons( makeString( "CAST"), $2), makeList( makeString("AS"), $4, -1));
 975                                 }
 976                         | '(' constraint_expr ')'
 977                                 {       $$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
 978                         | name '(' ')'
 979                                 {
 980                                         $$ = makeList( makeString($1), makeString("("), -1);
 981                                         $$ = lappend( $$, makeString(")"));
 982                                 }
 983                         | name '(' constraint_list ')'
 984                                 {
 985                                         $$ = makeList( makeString($1), makeString("("), -1);
 986                                         $$ = nconc( $$, $3);
 987                                         $$ = lappend( $$, makeString(")"));
 988                                 }
 989                         | constraint_expr Op constraint_expr
 990                                 {       $$ = nconc( $1, lcons( makeString( $2), $3)); }
 991                         | constraint_expr AND constraint_expr
 992                                 {       $$ = nconc( $1, lcons( makeString( "AND"), $3)); }
 993                         | constraint_expr OR constraint_expr
 994                                 {       $$ = nconc( $1, lcons( makeString( "OR"), $3)); }
 995                         | NOT constraint_expr
 996                                 {       $$ = lcons( makeString( "NOT"), $2); }
 997                         | Op constraint_expr
 998                                 {       $$ = lcons( makeString( $1), $2); }
 999                         | constraint_expr Op
1000                                 {       $$ = lappend( $1, makeString( $2)); }
1001                         | constraint_expr ISNULL
1002                                 {       $$ = lappend( $1, makeString( "IS NULL")); }
1003                         | constraint_expr IS NULL_P
1004                                 {       $$ = lappend( $1, makeString( "IS NULL")); }
1005                         | constraint_expr NOTNULL
1006                                 {       $$ = lappend( $1, makeString( "IS NOT NULL")); }
1007                         | constraint_expr IS NOT NULL_P
1008                                 {       $$ = lappend( $1, makeString( "IS NOT NULL")); }
1009                         | constraint_expr IS TRUE_P
1010                                 {       $$ = lappend( $1, makeString( "IS TRUE")); }
1011                         | constraint_expr IS FALSE_P
1012                                 {       $$ = lappend( $1, makeString( "IS FALSE")); }
1013                         | constraint_expr IS NOT TRUE_P
1014                                 {       $$ = lappend( $1, makeString( "IS NOT TRUE")); }
1015                         | constraint_expr IS NOT FALSE_P
1016                                 {       $$ = lappend( $1, makeString( "IS NOT FALSE")); }
1017                 ;
1018
1019 key_match:  MATCH FULL                                  { $$ = NULL; }
1020                 | MATCH PARTIAL                                 { $$ = NULL; }
1021                 | /*EMPTY*/                                             { $$ = NULL; }
1022                 ;
1023
1024 key_actions:  key_action key_action             { $$ = NIL; }
1025                 | key_action                                    { $$ = NIL; }
1026                 | /*EMPTY*/                                             { $$ = NIL; }
1027                 ;
1028
1029 key_action:  ON DELETE key_reference    { $$ = NIL; }
1030                 | ON UPDATE key_reference               { $$ = NIL; }
1031                 ;
1032
1033 key_reference:  NO ACTION                               { $$ = NULL; }
1034                 | CASCADE                                               { $$ = NULL; }
1035                 | SET DEFAULT                                   { $$ = NULL; }
1036                 | SET NULL_P                                    { $$ = NULL; }
1037                 ;
1038
1039 OptInherit:  INHERITS '(' relation_name_list ')'                { $$ = $3; }
1040                 | /*EMPTY*/                                                                             { $$ = NIL; }
1041                 ;
1042
1043 /*
1044  *      "ARCHIVE" keyword was removed in 6.3, but we keep it for now
1045  *  so people can upgrade with old pg_dump scripts. - momjian 1997-11-20(?)
1046  */
1047 OptArchiveType:  ARCHIVE '=' NONE                                               { }
1048                 | /*EMPTY*/                                                                             { }
1049                 ;
1050
1051 CreateAsStmt:  CREATE TABLE relation_name OptCreateAs AS SubSelect
1052                                 {
1053                                         SelectStmt *n = (SelectStmt *)$6;
1054                                         if ($4 != NIL)
1055                                                 mapTargetColumns($4, n->targetList);
1056                                         n->into = $3;
1057                                         $$ = (Node *)n;
1058                                 }
1059                 ;
1060
1061 OptCreateAs:  '(' CreateAsList ')'                              { $$ = $2; }
1062                         | /*EMPTY*/                                                     { $$ = NULL; }
1063                 ;
1064
1065 CreateAsList:  CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
1066                         | CreateAsElement                                       { $$ = lcons($1, NIL); }
1067                 ;
1068
1069 CreateAsElement:  ColId
1070                                 {
1071                                         ColumnDef *n = makeNode(ColumnDef);
1072                                         n->colname = $1;
1073                                         n->typename = NULL;
1074                                         n->defval = NULL;
1075                                         n->is_not_null = FALSE;
1076                                         n->constraints = NULL;
1077                                         $$ = (Node *)n;
1078                                 }
1079                 ;
1080
1081
1082 /*****************************************************************************
1083  *
1084  *              QUERY :
1085  *                              CREATE SEQUENCE seqname
1086  *
1087  *****************************************************************************/
1088
1089 CreateSeqStmt:  CREATE SEQUENCE relation_name OptSeqList
1090                                 {
1091                                         CreateSeqStmt *n = makeNode(CreateSeqStmt);
1092                                         n->seqname = $3;
1093                                         n->options = $4;
1094                                         $$ = (Node *)n;
1095                                 }
1096                 ;
1097
1098 OptSeqList:
1099                                 OptSeqList OptSeqElem
1100                                 { $$ = lappend($1, $2); }
1101                 |               { $$ = NIL; }
1102                 ;
1103
1104 OptSeqElem:             IDENT NumConst
1105                                 {
1106                                         $$ = makeNode(DefElem);
1107                                         $$->defname = $1;
1108                                         $$->arg = (Node *)$2;
1109                                 }
1110                 |               IDENT
1111                                 {
1112                                         $$ = makeNode(DefElem);
1113                                         $$->defname = $1;
1114                                         $$->arg = (Node *)NULL;
1115                                 }
1116                 ;
1117
1118 /*****************************************************************************
1119  *
1120  *              QUERIES :
1121  *                              CREATE PROCEDURAL LANGUAGE ...
1122  *                              DROP PROCEDURAL LANGUAGE ...
1123  *
1124  *****************************************************************************/
1125
1126 CreatePLangStmt:  CREATE PLangTrusted PROCEDURAL LANGUAGE Sconst
1127                         HANDLER def_name LANCOMPILER Sconst
1128                         {
1129                                 CreatePLangStmt *n = makeNode(CreatePLangStmt);
1130                                 n->plname = $5;
1131                                 n->plhandler = $7;
1132                                 n->plcompiler = $9;
1133                                 n->pltrusted = $2;
1134                                 $$ = (Node *)n;
1135                         }
1136                 ;
1137
1138 PLangTrusted:           TRUSTED { $$ = TRUE; }
1139                         |       { $$ = FALSE; }
1140
1141 DropPLangStmt:  DROP PROCEDURAL LANGUAGE Sconst
1142                         {
1143                                 DropPLangStmt *n = makeNode(DropPLangStmt);
1144                                 n->plname = $4;
1145                                 $$ = (Node *)n;
1146                         }
1147                 ;
1148
1149 /*****************************************************************************
1150  *
1151  *              QUERIES :
1152  *                              CREATE TRIGGER ...
1153  *                              DROP TRIGGER ...
1154  *
1155  *****************************************************************************/
1156
1157 CreateTrigStmt:  CREATE TRIGGER name TriggerActionTime TriggerEvents ON
1158                                 relation_name TriggerForSpec EXECUTE PROCEDURE
1159                                 name '(' TriggerFuncArgs ')'
1160                                 {
1161                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
1162                                         n->trigname = $3;
1163                                         n->relname = $7;
1164                                         n->funcname = $11;
1165                                         n->args = $13;
1166                                         n->before = $4;
1167                                         n->row = $8;
1168                                         memcpy (n->actions, $5, 4);
1169                                         $$ = (Node *)n;
1170                                 }
1171                 ;
1172
1173 TriggerActionTime:              BEFORE  { $$ = TRUE; }
1174                                 |               AFTER   { $$ = FALSE; }
1175                 ;
1176
1177 TriggerEvents:  TriggerOneEvent
1178                                         {
1179                                                         char *e = palloc (4);
1180                                                         e[0] = $1; e[1] = 0; $$ = e;
1181                                         }
1182                                 | TriggerOneEvent OR TriggerOneEvent
1183                                         {
1184                                                         char *e = palloc (4);
1185                                                         e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
1186                                         }
1187                                 | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
1188                                         {
1189                                                         char *e = palloc (4);
1190                                                         e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
1191                                                         $$ = e;
1192                                         }
1193                 ;
1194
1195 TriggerOneEvent:                INSERT  { $$ = 'i'; }
1196                                 |               DELETE  { $$ = 'd'; }
1197                                 |               UPDATE  { $$ = 'u'; }
1198                 ;
1199
1200 TriggerForSpec:  FOR name name
1201                                 {
1202                                                 if ( strcmp ($2, "each") != 0 )
1203                                                                 elog(ERROR,"parser: syntax error near %s",$2);
1204                                                 if ( strcmp ($3, "row") == 0 )
1205                                                                 $$ = TRUE;
1206                                                 else if ( strcmp ($3, "statement") == 0 )
1207                                                                 $$ = FALSE;
1208                                                 else
1209                                                                 elog(ERROR,"parser: syntax error near %s",$3);
1210                                 }
1211                 ;
1212
1213 TriggerFuncArgs:  TriggerFuncArg
1214                                 { $$ = lcons($1, NIL); }
1215                 | TriggerFuncArgs ',' TriggerFuncArg
1216                                 { $$ = lappend($1, $3); }
1217                 | /*EMPTY*/
1218                                 { $$ = NIL; }
1219                 ;
1220
1221 TriggerFuncArg:  ICONST
1222                                         {
1223                                                 char *s = (char *) palloc (256);
1224                                                 sprintf (s, "%d", $1);
1225                                                 $$ = s;
1226                                         }
1227                                 | FCONST
1228                                         {
1229                                                 char *s = (char *) palloc (256);
1230                                                 sprintf (s, "%g", $1);
1231                                                 $$ = s;
1232                                         }
1233                                 | Sconst                {  $$ = $1; }
1234                                 | IDENT                 {  $$ = $1; }
1235                 ;
1236
1237 DropTrigStmt:   DROP TRIGGER name ON relation_name
1238                                 {
1239                                         DropTrigStmt *n = makeNode(DropTrigStmt);
1240                                         n->trigname = $3;
1241                                         n->relname = $5;
1242                                         $$ = (Node *) n;
1243                                 }
1244                 ;
1245
1246
1247 /*****************************************************************************
1248  *
1249  *              QUERY :
1250  *                              define (type,operator,aggregate)
1251  *
1252  *****************************************************************************/
1253
1254 DefineStmt:  CREATE def_type def_rest
1255                                 {
1256                                         $3->defType = $2;
1257                                         $$ = (Node *)$3;
1258                                 }
1259                 ;
1260
1261 def_rest:  def_name definition
1262                                 {
1263                                         $$ = makeNode(DefineStmt);
1264                                         $$->defname = $1;
1265                                         $$->definition = $2;
1266                                 }
1267                 ;
1268
1269 def_type:  OPERATOR                                                     { $$ = OPERATOR; }
1270                 | TYPE_P                                                        { $$ = TYPE_P; }
1271                 | AGGREGATE                                                     { $$ = AGGREGATE; }
1272                 ;
1273
1274 def_name:  PROCEDURE                                            { $$ = "procedure"; }
1275                 | JOIN                                                          { $$ = "join"; }
1276                 | ColId                                                         { $$ = $1; }
1277                 | MathOp                                                        { $$ = $1; }
1278                 | Op                                                            { $$ = $1; }
1279                 ;
1280
1281 definition:  '(' def_list ')'                           { $$ = $2; }
1282                 ;
1283
1284 def_list:  def_elem                                                     { $$ = lcons($1, NIL); }
1285                 | def_list ',' def_elem                         { $$ = lappend($1, $3); }
1286                 ;
1287
1288 def_elem:  def_name '=' def_arg
1289                                 {
1290                                         $$ = makeNode(DefElem);
1291                                         $$->defname = $1;
1292                                         $$->arg = (Node *)$3;
1293                                 }
1294                 | def_name
1295                                 {
1296                                         $$ = makeNode(DefElem);
1297                                         $$->defname = $1;
1298                                         $$->arg = (Node *)NULL;
1299                                 }
1300                 | DEFAULT '=' def_arg
1301                                 {
1302                                         $$ = makeNode(DefElem);
1303                                         $$->defname = "default";
1304                                         $$->arg = (Node *)$3;
1305                                 }
1306                 ;
1307
1308 def_arg:  ColId                                                 {  $$ = (Node *)makeString($1); }
1309                 | all_Op                                                {  $$ = (Node *)makeString($1); }
1310                 | NumConst                                              {  $$ = (Node *)$1; /* already a Value */ }
1311                 | Sconst                                                {  $$ = (Node *)makeString($1); }
1312                 | SETOF ColId
1313                                 {
1314                                         TypeName *n = makeNode(TypeName);
1315                                         n->name = $2;
1316                                         n->setof = TRUE;
1317                                         n->arrayBounds = NULL;
1318                                         $$ = (Node *)n;
1319                                 }
1320                 | DOUBLE                                                {  $$ = (Node *)makeString("double"); }
1321                 ;
1322
1323
1324 /*****************************************************************************
1325  *
1326  *              QUERY:
1327  *                              destroy <relname1> [, <relname2> .. <relnameN> ]
1328  *
1329  *****************************************************************************/
1330
1331 DestroyStmt:  DROP TABLE relation_name_list
1332                                 {
1333                                         DestroyStmt *n = makeNode(DestroyStmt);
1334                                         n->relNames = $3;
1335                                         n->sequence = FALSE;
1336                                         $$ = (Node *)n;
1337                                 }
1338                 | DROP SEQUENCE relation_name_list
1339                                 {
1340                                         DestroyStmt *n = makeNode(DestroyStmt);
1341                                         n->relNames = $3;
1342                                         n->sequence = TRUE;
1343                                         $$ = (Node *)n;
1344                                 }
1345                 ;
1346
1347
1348 /*****************************************************************************
1349  *
1350  *              QUERY:
1351  *                      fetch/move [forward | backward] [number | all ] [ in <portalname> ]
1352  *
1353  *****************************************************************************/
1354
1355 FetchStmt:      FETCH opt_direction fetch_how_many opt_portal_name
1356                                 {
1357                                         FetchStmt *n = makeNode(FetchStmt);
1358                                         n->direction = $2;
1359                                         n->howMany = $3;
1360                                         n->portalname = $4;
1361                                         n->ismove = false;
1362                                         $$ = (Node *)n;
1363                                 }
1364                 |       MOVE opt_direction fetch_how_many opt_portal_name
1365                                 {
1366                                         FetchStmt *n = makeNode(FetchStmt);
1367                                         n->direction = $2;
1368                                         n->howMany = $3;
1369                                         n->portalname = $4;
1370                                         n->ismove = TRUE;
1371                                         $$ = (Node *)n;
1372                                 }
1373                 ;
1374
1375 opt_direction:  FORWARD                                                 { $$ = FORWARD; }
1376                 | BACKWARD                                                              { $$ = BACKWARD; }
1377                 | /*EMPTY*/                                                             { $$ = FORWARD; /* default */ }
1378                 ;
1379
1380 fetch_how_many:  Iconst
1381                            { $$ = $1;
1382                                  if ($1 <= 0) elog(ERROR,"Please specify nonnegative count for fetch"); }
1383                 | ALL                                                   { $$ = 0; /* 0 means fetch all tuples*/ }
1384                 | /*EMPTY*/                                             { $$ = 1; /*default*/ }
1385                 ;
1386
1387 opt_portal_name:  IN name                               { $$ = $2; }
1388                 | /*EMPTY*/                                             { $$ = NULL; }
1389                 ;
1390
1391
1392 /*****************************************************************************
1393  *
1394  *              QUERY:
1395  *                              GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
1396  *
1397  *****************************************************************************/
1398
1399 GrantStmt:  GRANT privileges ON relation_name_list TO grantee opt_with_grant
1400                                 {
1401                                         $$ = (Node*)makeAclStmt($2,$4,$6,'+');
1402                                         free($2);
1403                                         free($6);
1404                                 }
1405                 ;
1406
1407 privileges:  ALL PRIVILEGES
1408                                 {
1409                                  $$ = aclmakepriv("rwaR",0);
1410                                 }
1411                 | ALL
1412                                 {
1413                                  $$ = aclmakepriv("rwaR",0);
1414                                 }
1415                 | operation_commalist
1416                                 {
1417                                  $$ = $1;
1418                                 }
1419                 ;
1420
1421 operation_commalist:  operation
1422                                 {
1423                                                 $$ = aclmakepriv("",$1);
1424                                 }
1425                 | operation_commalist ',' operation
1426                                 {
1427                                                 $$ = aclmakepriv($1,$3);
1428                                                 free($1);
1429                                 }
1430                 ;
1431
1432 operation:  SELECT
1433                                 {
1434                                                 $$ = ACL_MODE_RD_CHR;
1435                                 }
1436                 | INSERT
1437                                 {
1438                                                 $$ = ACL_MODE_AP_CHR;
1439                                 }
1440                 | UPDATE
1441                                 {
1442                                                 $$ = ACL_MODE_WR_CHR;
1443                                 }
1444                 | DELETE
1445                                 {
1446                                                 $$ = ACL_MODE_WR_CHR;
1447                                 }
1448                 | RULE
1449                                 {
1450                                                 $$ = ACL_MODE_RU_CHR;
1451                                 }
1452                 ;
1453
1454 grantee:  PUBLIC
1455                                 {
1456                                                 $$ = aclmakeuser("A","");
1457                                 }
1458                 | GROUP ColId
1459                                 {
1460                                                 $$ = aclmakeuser("G",$2);
1461                                 }
1462                 | ColId
1463                                 {
1464                                                 $$ = aclmakeuser("U",$1);
1465                                 }
1466                 ;
1467
1468 opt_with_grant:  WITH GRANT OPTION
1469                                 {
1470                                         yyerror("WITH GRANT OPTION is not supported.  Only relation owners can set privileges");
1471                                  }
1472                 | /*EMPTY*/
1473                 ;
1474
1475
1476 /*****************************************************************************
1477  *
1478  *              QUERY:
1479  *                              REVOKE [privileges] ON [relation_name] FROM [user]
1480  *
1481  *****************************************************************************/
1482
1483 RevokeStmt:  REVOKE privileges ON relation_name_list FROM grantee
1484                                 {
1485                                         $$ = (Node*)makeAclStmt($2,$4,$6,'-');
1486                                         free($2);
1487                                         free($6);
1488                                 }
1489                 ;
1490
1491
1492 /*****************************************************************************
1493  *
1494  *              QUERY:
1495  *                              create index <indexname> on <relname>
1496  *                                using <access> "(" (<col> with <op>)+ ")" [with
1497  *                                <target_list>]
1498  *
1499  *      [where <qual>] is not supported anymore
1500  *****************************************************************************/
1501
1502 IndexStmt:      CREATE index_opt_unique INDEX index_name ON relation_name
1503                         access_method_clause '(' index_params ')' opt_with
1504                                 {
1505                                         /* should check that access_method is valid,
1506                                            etc ... but doesn't */
1507                                         IndexStmt *n = makeNode(IndexStmt);
1508                                         n->unique = $2;
1509                                         n->idxname = $4;
1510                                         n->relname = $6;
1511                                         n->accessMethod = $7;
1512                                         n->indexParams = $9;
1513                                         n->withClause = $11;
1514                                         n->whereClause = NULL;
1515                                         $$ = (Node *)n;
1516                                 }
1517                 ;
1518
1519 index_opt_unique:  UNIQUE                                               { $$ = TRUE; }
1520                 | /*EMPTY*/                                                             { $$ = FALSE; }
1521                 ;
1522
1523 access_method_clause:  USING access_method              { $$ = $2; }
1524                 | /*EMPTY*/                                                             { $$ = "btree"; }
1525                 ;
1526
1527 index_params:  index_list                                               { $$ = $1; }
1528                 | func_index                                                    { $$ = lcons($1,NIL); }
1529                 ;
1530
1531 index_list:  index_list ',' index_elem                  { $$ = lappend($1, $3); }
1532                 | index_elem                                                    { $$ = lcons($1, NIL); }
1533                 ;
1534
1535 func_index:  name '(' name_list ')' opt_type opt_class
1536                                 {
1537                                         $$ = makeNode(IndexElem);
1538                                         $$->name = $1;
1539                                         $$->args = $3;
1540                                         $$->class = $6;
1541                                         $$->tname = $5;
1542                                 }
1543                   ;
1544
1545 index_elem:  attr_name opt_type opt_class
1546                                 {
1547                                         $$ = makeNode(IndexElem);
1548                                         $$->name = $1;
1549                                         $$->args = NIL;
1550                                         $$->class = $3;
1551                                         $$->tname = $2;
1552                                 }
1553                 ;
1554
1555 opt_type:  ':' Typename                                                 { $$ = $2; }
1556                 | FOR Typename                                                  { $$ = $2; }
1557                 | /*EMPTY*/                                                             { $$ = NULL; }
1558                 ;
1559
1560 /* opt_class "WITH class" conflicts with preceeding opt_type
1561  *  for Typename of "TIMESTAMP WITH TIME ZONE"
1562  * So, remove "WITH class" from the syntax. OK??
1563  * - thomas 1997-10-12
1564  *              | WITH class                                                    { $$ = $2; }
1565  */
1566 opt_class:  class                                                               { $$ = $1; }
1567                 | USING class                                                   { $$ = $2; }
1568                 | /*EMPTY*/                                                             { $$ = NULL; }
1569                 ;
1570
1571
1572 /*****************************************************************************
1573  *
1574  *              QUERY:
1575  *                              extend index <indexname> [where <qual>]
1576  *
1577  *****************************************************************************/
1578
1579 ExtendStmt:  EXTEND INDEX index_name where_clause
1580                                 {
1581                                         ExtendStmt *n = makeNode(ExtendStmt);
1582                                         n->idxname = $3;
1583                                         n->whereClause = $4;
1584                                         $$ = (Node *)n;
1585                                 }
1586                 ;
1587
1588
1589 /*****************************************************************************
1590  *
1591  *              QUERY:
1592  *                              execute recipe <recipeName>
1593  *
1594  *****************************************************************************/
1595
1596 RecipeStmt:  EXECUTE RECIPE recipe_name
1597                                 {
1598                                         RecipeStmt *n;
1599                                         if (!IsTransactionBlock())
1600                                                 elog(ERROR,"EXECUTE RECIPE may only be used in begin/end transaction blocks");
1601
1602                                         n = makeNode(RecipeStmt);
1603                                         n->recipeName = $3;
1604                                         $$ = (Node *)n;
1605                                 }
1606                 ;
1607
1608
1609 /*****************************************************************************
1610  *
1611  *              QUERY:
1612  *                              define function <fname>
1613  *                                         (language = <lang>, returntype = <typename>
1614  *                                              [, arch_pct = <percentage | pre-defined>]
1615  *                                              [, disk_pct = <percentage | pre-defined>]
1616  *                                              [, byte_pct = <percentage | pre-defined>]
1617  *                                              [, perbyte_cpu = <int | pre-defined>]
1618  *                                              [, percall_cpu = <int | pre-defined>]
1619  *                                              [, iscachable])
1620  *                                              [arg is (<type-1> { , <type-n>})]
1621  *                                              as <filename or code in language as appropriate>
1622  *
1623  *****************************************************************************/
1624
1625 ProcedureStmt:  CREATE FUNCTION def_name def_args
1626                          RETURNS def_arg opt_with AS Sconst LANGUAGE Sconst
1627                                 {
1628                                         ProcedureStmt *n = makeNode(ProcedureStmt);
1629                                         n->funcname = $3;
1630                                         n->defArgs = $4;
1631                                         n->returnType = (Node *)$6;
1632                                         n->withClause = $7;
1633                                         n->as = $9;
1634                                         n->language = $11;
1635                                         $$ = (Node *)n;
1636                                 };
1637
1638 opt_with:  WITH definition                                              { $$ = $2; }
1639                 | /*EMPTY*/                                                     { $$ = NIL; }
1640                 ;
1641
1642 def_args:  '(' def_name_list ')'                                { $$ = $2; }
1643                 | '(' ')'                                                               { $$ = NIL; }
1644                 ;
1645
1646 def_name_list:  name_list;
1647
1648 /*****************************************************************************
1649  *
1650  *              QUERY:
1651  *
1652  *              remove function <funcname>
1653  *                              (REMOVE FUNCTION "funcname" (arg1, arg2, ...))
1654  *              remove aggregate <aggname>
1655  *                              (REMOVE AGGREGATE "aggname" "aggtype")
1656  *              remove operator <opname>
1657  *                              (REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
1658  *              remove type <typename>
1659  *                              (REMOVE TYPE "typename")
1660  *              remove rule <rulename>
1661  *                              (REMOVE RULE "rulename")
1662  *
1663  *****************************************************************************/
1664
1665 RemoveStmt:  DROP remove_type name
1666                                 {
1667                                         RemoveStmt *n = makeNode(RemoveStmt);
1668                                         n->removeType = $2;
1669                                         n->name = $3;
1670                                         $$ = (Node *)n;
1671                                 }
1672                 ;
1673
1674 remove_type:  TYPE_P                                                    {  $$ = TYPE_P; }
1675                 | INDEX                                                                 {  $$ = INDEX; }
1676                 | RULE                                                                  {  $$ = RULE; }
1677                 | VIEW                                                                  {  $$ = VIEW; }
1678                 ;
1679
1680 RemoveAggrStmt:  DROP AGGREGATE name aggr_argtype
1681                                 {
1682                                                 RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
1683                                                 n->aggname = $3;
1684                                                 n->aggtype = $4;
1685                                                 $$ = (Node *)n;
1686                                 }
1687                 ;
1688
1689 aggr_argtype:  name                                                             { $$ = $1; }
1690                 | '*'                                                                   { $$ = NULL; }
1691                 ;
1692
1693 RemoveFuncStmt:  DROP FUNCTION name '(' func_argtypes ')'
1694                                 {
1695                                         RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
1696                                         n->funcname = $3;
1697                                         n->args = $5;
1698                                         $$ = (Node *)n;
1699                                 }
1700                 ;
1701
1702 func_argtypes:  name_list                                               { $$ = $1; }
1703                 | /*EMPTY*/                                                             { $$ = NIL; }
1704                 ;
1705
1706 RemoveOperStmt:  DROP OPERATOR all_Op '(' oper_argtypes ')'
1707                                 {
1708                                         RemoveOperStmt *n = makeNode(RemoveOperStmt);
1709                                         n->opname = $3;
1710                                         n->args = $5;
1711                                         $$ = (Node *)n;
1712                                 }
1713                 ;
1714
1715 all_Op:  Op | MathOp;
1716
1717 MathOp: '+'                             { $$ = "+"; }
1718                 | '-'                   { $$ = "-"; }
1719                 | '*'                   { $$ = "*"; }
1720                 | '/'                   { $$ = "/"; }
1721                 | '<'                   { $$ = "<"; }
1722                 | '>'                   { $$ = ">"; }
1723                 | '='                   { $$ = "="; }
1724                 ;
1725
1726 oper_argtypes:  name
1727                                 {
1728                                    elog(ERROR,"parser: argument type missing (use NONE for unary operators)");
1729                                 }
1730                 | name ',' name
1731                                 { $$ = makeList(makeString($1), makeString($3), -1); }
1732                 | NONE ',' name                 /* left unary */
1733                                 { $$ = makeList(NULL, makeString($3), -1); }
1734                 | name ',' NONE                 /* right unary */
1735                                 { $$ = makeList(makeString($1), NULL, -1); }
1736                 ;
1737
1738
1739 /*****************************************************************************
1740  *
1741  *              QUERY:
1742  *                              rename <attrname1> in <relname> [*] to <attrname2>
1743  *                              rename <relname1> to <relname2>
1744  *
1745  *****************************************************************************/
1746
1747 RenameStmt:  ALTER TABLE relation_name opt_inh_star
1748                                   RENAME opt_column opt_name TO name
1749                                 {
1750                                         RenameStmt *n = makeNode(RenameStmt);
1751                                         n->relname = $3;
1752                                         n->inh = $4;
1753                                         n->column = $7;
1754                                         n->newname = $9;
1755                                         $$ = (Node *)n;
1756                                 }
1757                 ;
1758
1759 opt_name:  name                                                 { $$ = $1; }
1760                 | /*EMPTY*/                                             { $$ = NULL; }
1761                 ;
1762
1763 opt_column:  COLUMN                                             { $$ = COLUMN; }
1764                 | /*EMPTY*/                                             { $$ = 0; }
1765                 ;
1766
1767
1768 /*****************************************************************************
1769  *
1770  *              QUERY:  Define Rewrite Rule , Define Tuple Rule
1771  *                              Define Rule <old rules >
1772  *
1773  *              only rewrite rule is supported -- ay 9/94
1774  *
1775  *****************************************************************************/
1776
1777 RuleStmt:  CREATE RULE name AS
1778                    { QueryIsRule=TRUE; }
1779                    ON event TO event_object where_clause
1780                    DO opt_instead OptStmtList
1781                                 {
1782                                         RuleStmt *n = makeNode(RuleStmt);
1783                                         n->rulename = $3;
1784                                         n->event = $7;
1785                                         n->object = $9;
1786                                         n->whereClause = $10;
1787                                         n->instead = $12;
1788                                         n->actions = $13;
1789                                         $$ = (Node *)n;
1790                                 }
1791                 ;
1792
1793 OptStmtList:  NOTHING                                   { $$ = NIL; }
1794                 | OptimizableStmt                               { $$ = lcons($1, NIL); }
1795                 | '[' OptStmtBlock ']'                  { $$ = $2; }
1796                 ;
1797
1798 OptStmtBlock:  OptStmtMulti
1799                                 {  $$ = $1; }
1800                 | OptimizableStmt
1801                                 { $$ = lcons($1, NIL); }
1802                 ;
1803
1804 OptStmtMulti:  OptStmtMulti OptimizableStmt ';'
1805                                 {  $$ = lappend($1, $2); }
1806                 | OptStmtMulti OptimizableStmt
1807                                 {  $$ = lappend($1, $2); }
1808                 | OptimizableStmt ';'
1809                                 { $$ = lcons($1, NIL); }
1810                 ;
1811
1812 event_object:  relation_name '.' attr_name
1813                                 {
1814                                         $$ = makeNode(Attr);
1815                                         $$->relname = $1;
1816                                         $$->paramNo = NULL;
1817                                         $$->attrs = lcons(makeString($3), NIL);
1818                                         $$->indirection = NIL;
1819                                 }
1820                 | relation_name
1821                                 {
1822                                         $$ = makeNode(Attr);
1823                                         $$->relname = $1;
1824                                         $$->paramNo = NULL;
1825                                         $$->attrs = NIL;
1826                                         $$->indirection = NIL;
1827                                 }
1828                 ;
1829
1830 /* change me to select, update, etc. some day */
1831 event:  SELECT                                                  { $$ = CMD_SELECT; }
1832                 | UPDATE                                                { $$ = CMD_UPDATE; }
1833                 | DELETE                                                { $$ = CMD_DELETE; }
1834                 | INSERT                                                { $$ = CMD_INSERT; }
1835                  ;
1836
1837 opt_instead:  INSTEAD                                   { $$ = TRUE; }
1838                 | /*EMPTY*/                                     { $$ = FALSE; }
1839                 ;
1840
1841
1842 /*****************************************************************************
1843  *
1844  *              QUERY:
1845  *                              NOTIFY <relation_name>  can appear both in rule bodies and
1846  *                              as a query-level command
1847  *
1848  *****************************************************************************/
1849
1850 NotifyStmt:  NOTIFY relation_name
1851                                 {
1852                                         NotifyStmt *n = makeNode(NotifyStmt);
1853                                         n->relname = $2;
1854                                         $$ = (Node *)n;
1855                                 }
1856                 ;
1857
1858 ListenStmt:  LISTEN relation_name
1859                                 {
1860                                         ListenStmt *n = makeNode(ListenStmt);
1861                                         n->relname = $2;
1862                                         $$ = (Node *)n;
1863                                 }
1864 ;
1865
1866
1867 /*****************************************************************************
1868  *
1869  *              Transactions:
1870  *
1871  *              abort transaction
1872  *                              (ABORT)
1873  *              begin transaction
1874  *                              (BEGIN)
1875  *              end transaction
1876  *                              (END)
1877  *
1878  *****************************************************************************/
1879
1880 TransactionStmt:  ABORT_TRANS TRANSACTION
1881                                 {
1882                                         TransactionStmt *n = makeNode(TransactionStmt);
1883                                         n->command = ABORT_TRANS;
1884                                         $$ = (Node *)n;
1885                                 }
1886                 | BEGIN_TRANS TRANSACTION
1887                                 {
1888                                         TransactionStmt *n = makeNode(TransactionStmt);
1889                                         n->command = BEGIN_TRANS;
1890                                         $$ = (Node *)n;
1891                                 }
1892                 | BEGIN_TRANS WORK
1893                                 {
1894                                         TransactionStmt *n = makeNode(TransactionStmt);
1895                                         n->command = BEGIN_TRANS;
1896                                         $$ = (Node *)n;
1897                                 }
1898                 | COMMIT WORK
1899                                 {
1900                                         TransactionStmt *n = makeNode(TransactionStmt);
1901                                         n->command = END_TRANS;
1902                                         $$ = (Node *)n;
1903                                 }
1904                 | END_TRANS TRANSACTION
1905                                 {
1906                                         TransactionStmt *n = makeNode(TransactionStmt);
1907                                         n->command = END_TRANS;
1908                                         $$ = (Node *)n;
1909                                 }
1910                 | ROLLBACK WORK
1911                                 {
1912                                         TransactionStmt *n = makeNode(TransactionStmt);
1913                                         n->command = ABORT_TRANS;
1914                                         $$ = (Node *)n;
1915                                 }
1916
1917                 | ABORT_TRANS
1918                                 {
1919                                         TransactionStmt *n = makeNode(TransactionStmt);
1920                                         n->command = ABORT_TRANS;
1921                                         $$ = (Node *)n;
1922                                 }
1923                 | BEGIN_TRANS
1924                                 {
1925                                         TransactionStmt *n = makeNode(TransactionStmt);
1926                                         n->command = BEGIN_TRANS;
1927                                         $$ = (Node *)n;
1928                                 }
1929                 | COMMIT
1930                                 {
1931                                         TransactionStmt *n = makeNode(TransactionStmt);
1932                                         n->command = END_TRANS;
1933                                         $$ = (Node *)n;
1934                                 }
1935
1936                 | END_TRANS
1937                                 {
1938                                         TransactionStmt *n = makeNode(TransactionStmt);
1939                                         n->command = END_TRANS;
1940                                         $$ = (Node *)n;
1941                                 }
1942                 | ROLLBACK
1943                                 {
1944                                         TransactionStmt *n = makeNode(TransactionStmt);
1945                                         n->command = ABORT_TRANS;
1946                                         $$ = (Node *)n;
1947                                 }
1948                 ;
1949
1950
1951 /*****************************************************************************
1952  *
1953  *              QUERY:
1954  *                              define view <viewname> '('target-list ')' [where <quals> ]
1955  *
1956  *****************************************************************************/
1957
1958 ViewStmt:  CREATE VIEW name AS SelectStmt
1959                                 {
1960                                         ViewStmt *n = makeNode(ViewStmt);
1961                                         n->viewname = $3;
1962                                         n->query = (Query *)$5;
1963                                         if (((SelectStmt *)n->query)->sortClause != NULL)
1964                                                 elog(ERROR,"Order by and Distinct on views is not implemented.");
1965                                         if (((SelectStmt *)n->query)->unionClause != NULL)
1966                                                 elog(ERROR,"Views on unions not implemented.");
1967                                         $$ = (Node *)n;
1968                                 }
1969                 ;
1970
1971
1972 /*****************************************************************************
1973  *
1974  *              QUERY:
1975  *                              load "filename"
1976  *
1977  *****************************************************************************/
1978
1979 LoadStmt:  LOAD file_name
1980                                 {
1981                                         LoadStmt *n = makeNode(LoadStmt);
1982                                         n->filename = $2;
1983                                         $$ = (Node *)n;
1984                                 }
1985                 ;
1986
1987
1988 /*****************************************************************************
1989  *
1990  *              QUERY:
1991  *                              createdb dbname
1992  *
1993  *****************************************************************************/
1994
1995 CreatedbStmt:  CREATE DATABASE database_name opt_database
1996                                 {
1997                                         CreatedbStmt *n = makeNode(CreatedbStmt);
1998                                         n->dbname = $3;
1999                                         n->dbpath = $4;
2000                                         $$ = (Node *)n;
2001                                 }
2002                 ;
2003
2004 opt_database:  WITH LOCATION '=' location               { $$ = $4; }
2005                 | /*EMPTY*/                                                             { $$ = NULL; }
2006                 ;
2007
2008 location:  Sconst                                                               { $$ = $1; }
2009                 | DEFAULT                                                               { $$ = NULL; }
2010                 | /*EMPTY*/                                                             { $$ = NULL; }
2011                 ;
2012
2013 /*****************************************************************************
2014  *
2015  *              QUERY:
2016  *                              destroydb dbname
2017  *
2018  *****************************************************************************/
2019
2020 DestroydbStmt:  DROP DATABASE database_name
2021                                 {
2022                                         DestroydbStmt *n = makeNode(DestroydbStmt);
2023                                         n->dbname = $3;
2024                                         $$ = (Node *)n;
2025                                 }
2026                 ;
2027
2028
2029 /*****************************************************************************
2030  *
2031  *              QUERY:
2032  *                              cluster <index_name> on <relation_name>
2033  *
2034  *****************************************************************************/
2035
2036 ClusterStmt:  CLUSTER index_name ON relation_name
2037                                 {
2038                                    ClusterStmt *n = makeNode(ClusterStmt);
2039                                    n->relname = $4;
2040                                    n->indexname = $2;
2041                                    $$ = (Node*)n;
2042                                 }
2043                 ;
2044
2045
2046 /*****************************************************************************
2047  *
2048  *              QUERY:
2049  *                              vacuum
2050  *
2051  *****************************************************************************/
2052
2053 VacuumStmt:  VACUUM opt_verbose opt_analyze
2054                                 {
2055                                         VacuumStmt *n = makeNode(VacuumStmt);
2056                                         n->verbose = $2;
2057                                         n->analyze = $3;
2058                                         n->vacrel = NULL;
2059                                         n->va_spec = NIL;
2060                                         $$ = (Node *)n;
2061                                 }
2062                 | VACUUM opt_verbose opt_analyze relation_name opt_va_list
2063                                 {
2064                                         VacuumStmt *n = makeNode(VacuumStmt);
2065                                         n->verbose = $2;
2066                                         n->analyze = $3;
2067                                         n->vacrel = $4;
2068                                         n->va_spec = $5;
2069                                         if ( $5 != NIL && !$4 )
2070                                                 elog(ERROR,"parser: syntax error at or near \"(\"");
2071                                         $$ = (Node *)n;
2072                                 }
2073                 ;
2074
2075 opt_verbose:  VERBOSE                                                   { $$ = TRUE; }
2076                 | /*EMPTY*/                                                             { $$ = FALSE; }
2077                 ;
2078
2079 opt_analyze:  ANALYZE                                                   { $$ = TRUE; }
2080                 | /*EMPTY*/                                                             { $$ = FALSE; }
2081                 ;
2082
2083 opt_va_list:  '(' va_list ')'
2084                                 { $$ = $2; }
2085                 | /* EMPTY */
2086                                 { $$ = NIL; }
2087                 ;
2088
2089 va_list:  name
2090                                 { $$=lcons($1,NIL); }
2091                 | va_list ',' name
2092                                 { $$=lappend($1,$3); }
2093                 ;
2094
2095
2096 /*****************************************************************************
2097  *
2098  *              QUERY:
2099  *                              EXPLAIN query
2100  *
2101  *****************************************************************************/
2102
2103 ExplainStmt:  EXPLAIN opt_verbose OptimizableStmt
2104                                 {
2105                                         ExplainStmt *n = makeNode(ExplainStmt);
2106                                         n->verbose = $2;
2107                                         n->query = (Query*)$3;
2108                                         $$ = (Node *)n;
2109                                 }
2110                 ;
2111
2112
2113 /*****************************************************************************
2114  *                                                                                                                                                       *
2115  *              Optimizable Stmts:                                                                                                       *
2116  *                                                                                                                                                       *
2117  *              one of the five queries processed by the planner                                         *
2118  *                                                                                                                                                       *
2119  *              [ultimately] produces query-trees as specified                                           *
2120  *              in the query-spec document in ~postgres/ref                                                      *
2121  *                                                                                                                                                       *
2122  *****************************************************************************/
2123
2124 OptimizableStmt:  SelectStmt
2125                 | CursorStmt
2126                 | UpdateStmt
2127                 | InsertStmt
2128                 | NotifyStmt
2129                 | DeleteStmt                                    /* by default all are $$=$1 */
2130                 ;
2131
2132
2133 /*****************************************************************************
2134  *
2135  *              QUERY:
2136  *                              INSERT STATEMENTS
2137  *
2138  *****************************************************************************/
2139
2140 InsertStmt:  INSERT INTO relation_name opt_column_list insert_rest
2141                                 {
2142                                         $5->relname = $3;
2143                                         $5->cols = $4;
2144                                         $$ = (Node *)$5;
2145                                 }
2146                 ;
2147
2148 insert_rest:  VALUES '(' res_target_list2 ')'
2149                                 {
2150                                         $$ = makeNode(InsertStmt);
2151                                         $$->unique = NULL;
2152                                         $$->targetList = $3;
2153                                         $$->fromClause = NIL;
2154                                         $$->whereClause = NIL;
2155                                         $$->groupClause = NIL;
2156                                         $$->havingClause = NIL;
2157                                         $$->unionClause = NIL;
2158                                 }
2159                 | SELECT opt_unique res_target_list2
2160                          from_clause where_clause
2161                          group_clause having_clause
2162                          union_clause
2163                                 {
2164                                         $$ = makeNode(InsertStmt);
2165                                         $$->unique = $2;
2166                                         $$->targetList = $3;
2167                                         $$->fromClause = $4;
2168                                         $$->whereClause = $5;
2169                                         $$->groupClause = $6;
2170                                         $$->havingClause = $7;
2171                                         $$->unionClause = $8;
2172                                 }
2173                 ;
2174
2175 opt_column_list:  '(' columnList ')'                    { $$ = $2; }
2176                 | /*EMPTY*/                                                             { $$ = NIL; }
2177                 ;
2178
2179 columnList:
2180                   columnList ',' columnElem
2181                                 { $$ = lappend($1, $3); }
2182                 | columnElem
2183                                 { $$ = lcons($1, NIL); }
2184                 ;
2185
2186 columnElem:  ColId opt_indirection
2187                                 {
2188                                         Ident *id = makeNode(Ident);
2189                                         id->name = $1;
2190                                         id->indirection = $2;
2191                                         $$ = (Node *)id;
2192                                 }
2193                 ;
2194
2195
2196 /*****************************************************************************
2197  *
2198  *              QUERY:
2199  *                              DELETE STATEMENTS
2200  *
2201  *****************************************************************************/
2202
2203 DeleteStmt:  DELETE FROM relation_name
2204                          where_clause
2205                                 {
2206                                         DeleteStmt *n = makeNode(DeleteStmt);
2207                                         n->relname = $3;
2208                                         n->whereClause = $4;
2209                                         $$ = (Node *)n;
2210                                 }
2211                 ;
2212
2213
2214 /*****************************************************************************
2215  *
2216  *              QUERY:
2217  *                              UpdateStmt (UPDATE)
2218  *
2219  *****************************************************************************/
2220
2221 UpdateStmt:  UPDATE relation_name
2222                           SET res_target_list
2223                           from_clause
2224                           where_clause
2225                                 {
2226                                         UpdateStmt *n = makeNode(UpdateStmt);
2227                                         n->relname = $2;
2228                                         n->targetList = $4;
2229                                         n->fromClause = $5;
2230                                         n->whereClause = $6;
2231                                         $$ = (Node *)n;
2232                                 }
2233                 ;
2234
2235
2236 /*****************************************************************************
2237  *
2238  *              QUERY:
2239  *                              CURSOR STATEMENTS
2240  *
2241  *****************************************************************************/
2242 CursorStmt:  DECLARE name opt_binary CURSOR FOR
2243                          SELECT opt_unique res_target_list2
2244                          from_clause where_clause
2245                          group_clause having_clause
2246                          union_clause sort_clause
2247                                 {
2248                                         SelectStmt *n = makeNode(SelectStmt);
2249
2250                                         /* from PORTAL name */
2251                                         /*
2252                                          *      15 august 1991 -- since 3.0 postgres does locking
2253                                          *      right, we discovered that portals were violating
2254                                          *      locking protocol.  portal locks cannot span xacts.
2255                                          *      as a short-term fix, we installed the check here.
2256                                          *                                                      -- mao
2257                                          */
2258                                         if (!IsTransactionBlock())
2259                                                 elog(ERROR,"Named portals may only be used in begin/end transaction blocks");
2260
2261                                         n->portalname = $2;
2262                                         n->binary = $3;
2263                                         n->unique = $7;
2264                                         n->targetList = $8;
2265                                         n->fromClause = $9;
2266                                         n->whereClause = $10;
2267                                         n->groupClause = $11;
2268                                         n->havingClause = $12;
2269                                         n->unionClause = $13;
2270                                         n->sortClause = $14;
2271                                         $$ = (Node *)n;
2272                                 }
2273                 ;
2274
2275
2276 /*****************************************************************************
2277  *
2278  *              QUERY:
2279  *                              SELECT STATEMENTS
2280  *
2281  *****************************************************************************/
2282
2283 SelectStmt:  SELECT opt_unique res_target_list2
2284                          result from_clause where_clause
2285                          group_clause having_clause
2286                          union_clause sort_clause
2287                                 {
2288                                         SelectStmt *n = makeNode(SelectStmt);
2289                                         n->unique = $2;
2290                                         n->targetList = $3;
2291                                         n->into = $4;
2292                                         n->fromClause = $5;
2293                                         n->whereClause = $6;
2294                                         n->groupClause = $7;
2295                                         n->havingClause = $8;
2296                                         n->unionClause = $9;
2297                                         n->sortClause = $10;
2298                                         $$ = (Node *)n;
2299                                 }
2300                 ;
2301
2302 union_clause:  UNION opt_union select_list
2303                                 {
2304                                         SelectStmt *n = (SelectStmt *)lfirst($3);
2305                                         n->unionall = $2;
2306                                         $$ = $3;
2307                                 }
2308                 | /*EMPTY*/
2309                                 { $$ = NIL; }
2310                 ;
2311
2312 select_list:  select_list UNION opt_union SubSelect
2313                                 {
2314                                         SelectStmt *n = (SelectStmt *)$4;
2315                                         n->unionall = $3;
2316                                         $$ = lappend($1, $4);
2317                                 }
2318                 | SubSelect
2319                                 { $$ = lcons($1, NIL); }
2320                 ;
2321
2322 SubSelect:      SELECT opt_unique res_target_list2
2323                          from_clause where_clause
2324                          group_clause having_clause
2325                                 {
2326                                         SelectStmt *n = makeNode(SelectStmt);
2327                                         n->unique = $2;
2328                                         n->unionall = FALSE;
2329                                         n->targetList = $3;
2330                                         n->fromClause = $4;
2331                                         n->whereClause = $5;
2332                                         n->groupClause = $6;
2333                                         n->havingClause = $7;
2334                                         $$ = (Node *)n;
2335                                 }
2336                 ;
2337
2338 result:  INTO TABLE relation_name
2339                                 {       $$= $3; }
2340                 | /*EMPTY*/
2341                                 {       $$ = NULL; }
2342                 ;
2343
2344 opt_union:  ALL                                                                 { $$ = TRUE; }
2345                 | /*EMPTY*/                                                             { $$ = FALSE; }
2346                 ;
2347
2348 opt_unique:  DISTINCT                                                   { $$ = "*"; }
2349                 | DISTINCT ON ColId                                             { $$ = $3; }
2350                 | ALL                                                                   { $$ = NULL; }
2351                 | /*EMPTY*/                                                             { $$ = NULL; }
2352                 ;
2353
2354 sort_clause:  ORDER BY sortby_list                              { $$ = $3; }
2355                 | /*EMPTY*/                                                             { $$ = NIL; }
2356                 ;
2357
2358 sortby_list:  sortby                                                    { $$ = lcons($1, NIL); }
2359                 | sortby_list ',' sortby                                { $$ = lappend($1, $3); }
2360                 ;
2361
2362 sortby:  ColId OptUseOp
2363                                 {
2364                                         $$ = makeNode(SortGroupBy);
2365                                         $$->resno = 0;
2366                                         $$->range = NULL;
2367                                         $$->name = $1;
2368                                         $$->useOp = $2;
2369                                 }
2370                 | ColId '.' ColId OptUseOp
2371                                 {
2372                                         $$ = makeNode(SortGroupBy);
2373                                         $$->resno = 0;
2374                                         $$->range = $1;
2375                                         $$->name = $3;
2376                                         $$->useOp = $4;
2377                                 }
2378                 | Iconst OptUseOp
2379                                 {
2380                                         $$ = makeNode(SortGroupBy);
2381                                         $$->resno = $1;
2382                                         $$->range = NULL;
2383                                         $$->name = NULL;
2384                                         $$->useOp = $2;
2385                                 }
2386                 ;
2387
2388 OptUseOp:  USING Op                                                             { $$ = $2; }
2389                 | USING '<'                                                             { $$ = "<"; }
2390                 | USING '>'                                                             { $$ = ">"; }
2391                 | ASC                                                                   { $$ = "<"; }
2392                 | DESC                                                                  { $$ = ">"; }
2393                 | /*EMPTY*/                                                             { $$ = "<"; /*default*/ }
2394                 ;
2395
2396 /*
2397  *      jimmy bell-style recursive queries aren't supported in the
2398  *      current system.
2399  *
2400  *      ...however, recursive addattr and rename supported.  make special
2401  *      cases for these.
2402  */
2403 opt_inh_star:  '*'                                                              { $$ = TRUE; }
2404                 | /*EMPTY*/                                                             { $$ = FALSE; }
2405                 ;
2406
2407 relation_name_list:  name_list;
2408
2409 name_list:  name
2410                                 {       $$ = lcons(makeString($1),NIL); }
2411                 | name_list ',' name
2412                                 {       $$ = lappend($1,makeString($3)); }
2413                 ;
2414
2415 group_clause:  GROUP BY groupby_list                    { $$ = $3; }
2416                 | /*EMPTY*/                                                             { $$ = NIL; }
2417                 ;
2418
2419 groupby_list:  groupby                                                  { $$ = lcons($1, NIL); }
2420                 | groupby_list ',' groupby                              { $$ = lappend($1, $3); }
2421                 ;
2422
2423 groupby:  ColId
2424                                 {
2425                                         $$ = makeNode(SortGroupBy);
2426                                         $$->resno = 0;
2427                                         $$->range = NULL;
2428                                         $$->name = $1;
2429                                         $$->useOp = NULL;
2430                                 }
2431                 | ColId '.' ColId
2432                                 {
2433                                         $$ = makeNode(SortGroupBy);
2434                                         $$->resno = 0;
2435                                         $$->range = $1;
2436                                         $$->name = $3;
2437                                         $$->useOp = NULL;
2438                                 }
2439                 | Iconst
2440                                 {
2441                                         $$ = makeNode(SortGroupBy);
2442                                         $$->resno = $1;
2443                                         $$->range = NULL;
2444                                         $$->name = NULL;
2445                                         $$->useOp = NULL;
2446                                 }
2447                 ;
2448
2449 having_clause:  HAVING a_expr                                   { $$ = $2; }
2450                 | /*EMPTY*/                                                             { $$ = NULL; }
2451                 ;
2452
2453
2454 /*****************************************************************************
2455  *
2456  *      clauses common to all Optimizable Stmts:
2457  *              from_clause             -
2458  *              where_clause    -
2459  *
2460  *****************************************************************************/
2461
2462 from_clause:  FROM '(' relation_expr join_expr JOIN relation_expr join_spec ')'
2463                                 {
2464                                         $$ = NIL;
2465                                         elog(ERROR,"JOIN not yet implemented");
2466                                 }
2467                 | FROM from_list                                                { $$ = $2; }
2468                 | /*EMPTY*/                                                             { $$ = NIL; }
2469                 ;
2470
2471 from_list:      from_list ',' from_val
2472                                 { $$ = lappend($1, $3); }
2473                 | from_val CROSS JOIN from_val
2474                                 { elog(ERROR,"CROSS JOIN not yet implemented"); }
2475                 | from_val
2476                                 { $$ = lcons($1, NIL); }
2477                 ;
2478
2479 from_val:  relation_expr AS ColLabel
2480                                 {
2481                                         $$ = makeNode(RangeVar);
2482                                         $$->relExpr = $1;
2483                                         $$->name = $3;
2484                                 }
2485                 | relation_expr ColId
2486                                 {
2487                                         $$ = makeNode(RangeVar);
2488                                         $$->relExpr = $1;
2489                                         $$->name = $2;
2490                                 }
2491                 | relation_expr
2492                                 {
2493                                         $$ = makeNode(RangeVar);
2494                                         $$->relExpr = $1;
2495                                         $$->name = NULL;
2496                                 }
2497                 ;
2498
2499 join_expr:  NATURAL join_expr                                   { $$ = NULL; }
2500                 | FULL join_outer
2501                                 { elog(ERROR,"FULL OUTER JOIN not yet implemented"); }
2502                 | LEFT join_outer
2503                                 { elog(ERROR,"LEFT OUTER JOIN not yet implemented"); }
2504                 | RIGHT join_outer
2505                                 { elog(ERROR,"RIGHT OUTER JOIN not yet implemented"); }
2506                 | OUTER_P
2507                                 { elog(ERROR,"OUTER JOIN not yet implemented"); }
2508                 | INNER_P
2509                                 { elog(ERROR,"INNER JOIN not yet implemented"); }
2510                 | UNION
2511                                 { elog(ERROR,"UNION JOIN not yet implemented"); }
2512                 | /*EMPTY*/
2513                                 { elog(ERROR,"INNER JOIN not yet implemented"); }
2514                 ;
2515
2516 join_outer:  OUTER_P                                                    { $$ = NULL; }
2517                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2518                 ;
2519
2520 join_spec:      ON '(' a_expr ')'                                       { $$ = NULL; }
2521                 | USING '(' join_list ')'                               { $$ = NULL; }
2522                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2523                 ;
2524
2525 join_list:  join_using                                                  { $$ = lcons($1, NIL); }
2526                 | join_list ',' join_using                              { $$ = lappend($1, $3); }
2527                 ;
2528
2529 join_using:  ColId
2530                                 {
2531                                         $$ = makeNode(SortGroupBy);
2532                                         $$->resno = 0;
2533                                         $$->range = NULL;
2534                                         $$->name = $1;
2535                                         $$->useOp = NULL;
2536                                 }
2537                 | ColId '.' ColId
2538                                 {
2539                                         $$ = makeNode(SortGroupBy);
2540                                         $$->resno = 0;
2541                                         $$->range = $1;
2542                                         $$->name = $3;
2543                                         $$->useOp = NULL;
2544                                 }
2545                 | Iconst
2546                                 {
2547                                         $$ = makeNode(SortGroupBy);
2548                                         $$->resno = $1;
2549                                         $$->range = NULL;
2550                                         $$->name = NULL;
2551                                         $$->useOp = NULL;
2552                                 }
2553                 ;
2554
2555 where_clause:  WHERE a_expr                                             { $$ = $2; }
2556                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2557                 ;
2558
2559 relation_expr:  relation_name
2560                                 {
2561                                         /* normal relations */
2562                                         $$ = makeNode(RelExpr);
2563                                         $$->relname = $1;
2564                                         $$->inh = FALSE;
2565                                 }
2566                 | relation_name '*'                               %prec '='
2567                                 {
2568                                         /* inheritance query */
2569                                         $$ = makeNode(RelExpr);
2570                                         $$->relname = $1;
2571                                         $$->inh = TRUE;
2572                                 }
2573
2574 opt_array_bounds:  '[' ']' nest_array_bounds
2575                                 {  $$ = lcons(makeInteger(-1), $3); }
2576                 | '[' Iconst ']' nest_array_bounds
2577                                 {  $$ = lcons(makeInteger($2), $4); }
2578                 | /* EMPTY */
2579                                 {  $$ = NIL; }
2580                 ;
2581
2582 nest_array_bounds:      '[' ']' nest_array_bounds
2583                                 {  $$ = lcons(makeInteger(-1), $3); }
2584                 | '[' Iconst ']' nest_array_bounds
2585                                 {  $$ = lcons(makeInteger($2), $4); }
2586                 | /*EMPTY*/
2587                                 {  $$ = NIL; }
2588                 ;
2589
2590
2591 /*****************************************************************************
2592  *
2593  *      Type syntax
2594  *              SQL92 introduces a large amount of type-specific syntax.
2595  *              Define individual clauses to handle these cases, and use
2596  *               the generic case to handle regular type-extensible Postgres syntax.
2597  *              - thomas 1997-10-10
2598  *
2599  *****************************************************************************/
2600
2601 Typename:  Array opt_array_bounds
2602                                 {
2603                                         $$ = $1;
2604                                         $$->arrayBounds = $2;
2605
2606                                         /* Is this the name of a complex type? If so, implement
2607                                          * it as a set.
2608                                          */
2609                                         if (!strcmp(saved_relname, $$->name))
2610                                                 /* This attr is the same type as the relation
2611                                                  * being defined. The classic example: create
2612                                                  * emp(name=text,mgr=emp)
2613                                                  */
2614                                                 $$->setof = TRUE;
2615                                         else if (typeTypeRelid(typenameType($$->name)) != InvalidOid)
2616                                                  /* (Eventually add in here that the set can only
2617                                                   * contain one element.)
2618                                                   */
2619                                                 $$->setof = TRUE;
2620                                         else
2621                                                 $$->setof = FALSE;
2622                                 }
2623                 | Character
2624                 | SETOF Array
2625                                 {
2626                                         $$ = $2;
2627                                         $$->setof = TRUE;
2628                                 }
2629                 ;
2630
2631 Array:  Generic
2632                 | Datetime
2633                 | Numeric
2634                 ;
2635
2636 Generic:  generic
2637                                 {
2638                                         $$ = makeNode(TypeName);
2639                                         $$->name = xlateSqlType($1);
2640                                 }
2641                 ;
2642
2643 generic:  Id                                                                    { $$ = $1; }
2644                 | TYPE_P                                                                { $$ = xlateSqlType("type"); }
2645                 | DOUBLE PRECISION                                              { $$ = xlateSqlType("float8"); }
2646                 ;
2647
2648 /* SQL92 numeric data types
2649  * Check FLOAT() precision limits assuming IEEE floating types.
2650  * Provide rudimentary DECIMAL() and NUMERIC() implementations
2651  *  by checking parameters and making sure they match what is possible with INTEGER.
2652  * - thomas 1997-09-18
2653  */
2654 Numeric:  FLOAT opt_float
2655                                 {
2656                                         $$ = makeNode(TypeName);
2657                                         $$->name = xlateSqlType($2);
2658                                 }
2659                 | DECIMAL opt_decimal
2660                                 {
2661                                         $$ = makeNode(TypeName);
2662                                         $$->name = xlateSqlType("integer");
2663                                 }
2664                 | NUMERIC opt_numeric
2665                                 {
2666                                         $$ = makeNode(TypeName);
2667                                         $$->name = xlateSqlType("integer");
2668                                 }
2669                 ;
2670
2671 opt_float:  '(' Iconst ')'
2672                                 {
2673                                         if ($2 < 1)
2674                                                 elog(ERROR,"precision for FLOAT must be at least 1");
2675                                         else if ($2 < 7)
2676                                                 $$ = xlateSqlType("float4");
2677                                         else if ($2 < 16)
2678                                                 $$ = xlateSqlType("float8");
2679                                         else
2680                                                 elog(ERROR,"precision for FLOAT must be less than 16");
2681                                 }
2682                 | /*EMPTY*/
2683                                 {
2684                                         $$ = xlateSqlType("float8");
2685                                 }
2686                 ;
2687
2688 opt_numeric:  '(' Iconst ',' Iconst ')'
2689                                 {
2690                                         if ($2 != 9)
2691                                                 elog(ERROR,"NUMERIC precision %d must be 9",$2);
2692                                         if ($4 != 0)
2693                                                 elog(ERROR,"NUMERIC scale %d must be zero",$4);
2694                                 }
2695                 | '(' Iconst ')'
2696                                 {
2697                                         if ($2 != 9)
2698                                                 elog(ERROR,"NUMERIC precision %d must be 9",$2);
2699                                 }
2700                 | /*EMPTY*/
2701                                 {
2702                                         $$ = NULL;
2703                                 }
2704                 ;
2705
2706 opt_decimal:  '(' Iconst ',' Iconst ')'
2707                                 {
2708                                         if ($2 > 9)
2709                                                 elog(ERROR,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2710                                         if ($4 != 0)
2711                                                 elog(ERROR,"DECIMAL scale %d must be zero",$4);
2712                                         $$ = NULL;
2713                                 }
2714                 | '(' Iconst ')'
2715                                 {
2716                                         if ($2 > 9)
2717                                                 elog(ERROR,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2718                                         $$ = NULL;
2719                                 }
2720                 | /*EMPTY*/
2721                                 {
2722                                         $$ = NULL;
2723                                 }
2724                 ;
2725
2726 /* SQL92 character data types
2727  * The following implements CHAR() and VARCHAR().
2728  * We do it here instead of the 'Generic' production
2729  * because we don't want to allow arrays of VARCHAR().
2730  * I haven't thought about whether that will work or not.
2731  *                                                              - ay 6/95
2732  */
2733 Character:  character '(' Iconst ')'
2734                                 {
2735                                         $$ = makeNode(TypeName);
2736                                         if (!strcasecmp($1, "char"))
2737                                                 $$->name = xlateSqlType("bpchar");
2738                                         else if (!strcasecmp($1, "varchar"))
2739                                                 $$->name = xlateSqlType("varchar");
2740                                         else
2741                                                 yyerror("parse error");
2742                                         if ($3 < 1)
2743                                                 elog(ERROR,"length for '%s' type must be at least 1",$1);
2744                                         else if ($3 > 4096)
2745                                                 /* we can store a char() of length up to the size
2746                                                  * of a page (8KB) - page headers and friends but
2747                                                  * just to be safe here...      - ay 6/95
2748                                                  * XXX note this hardcoded limit - thomas 1997-07-13
2749                                                  */
2750                                                 elog(ERROR,"length for type '%s' cannot exceed 4096",$1);
2751
2752                                         /* we actually implement this sort of like a varlen, so
2753                                          * the first 4 bytes is the length. (the difference
2754                                          * between this and "text" is that we blank-pad and
2755                                          * truncate where necessary
2756                                          */
2757                                         $$->typlen = VARHDRSZ + $3;
2758                                 }
2759                 | character
2760                                 {
2761                                         $$ = makeNode(TypeName);
2762                                         $$->name = xlateSqlType($1);
2763                                 }
2764                 ;
2765
2766 character:  CHARACTER opt_varying opt_charset opt_collate
2767                                 {
2768                                         char *type, *c;
2769                                         if (($3 == NULL) || (strcasecmp($3, "sql_text") == 0)) {
2770                                                 if ($2) type = xlateSqlType("varchar");
2771                                                 else type = xlateSqlType("char");
2772                                         } else {
2773                                                 if ($2) {
2774                                                         c = palloc(strlen("var") + strlen($3) + 1);
2775                                                         strcpy(c, "var");
2776                                                         strcat(c, $3);
2777                                                         type = xlateSqlType(c);
2778                                                 } else {
2779                                                         type = xlateSqlType($3);
2780                                                 }
2781                                         };
2782                                         if ($4 != NULL)
2783                                         elog(ERROR,"COLLATE %s not yet implemented",$4);
2784                                         $$ = type;
2785                                 }
2786                 | CHAR opt_varying                                              { $$ = xlateSqlType($2? "varchar": "char"); }
2787                 | VARCHAR                                                               { $$ = xlateSqlType("varchar"); }
2788                 | NATIONAL CHARACTER opt_varying                { $$ = xlateSqlType($3? "varchar": "char"); }
2789                 | NCHAR opt_varying                                             { $$ = xlateSqlType($2? "varchar": "char"); }
2790                 ;
2791
2792 opt_varying:  VARYING                                                   { $$ = TRUE; }
2793                 | /*EMPTY*/                                                             { $$ = FALSE; }
2794                 ;
2795
2796 opt_charset:  CHARACTER SET ColId                               { $$ = $3; }
2797                 | /*EMPTY*/                                                             { $$ = NULL; }
2798                 ;
2799
2800 opt_collate:  COLLATE ColId                                             { $$ = $2; }
2801                 | /*EMPTY*/                                                             { $$ = NULL; }
2802                 ;
2803
2804 Datetime:  datetime
2805                                 {
2806                                         $$ = makeNode(TypeName);
2807                                         $$->name = xlateSqlType($1);
2808                                 }
2809                 | TIMESTAMP opt_timezone
2810                                 {
2811                                         $$ = makeNode(TypeName);
2812                                         $$->name = xlateSqlType("timestamp");
2813                                         $$->timezone = $2;
2814                                 }
2815                 | TIME
2816                                 {
2817                                         $$ = makeNode(TypeName);
2818                                         $$->name = xlateSqlType("time");
2819                                 }
2820                 | INTERVAL opt_interval
2821                                 {
2822                                         $$ = makeNode(TypeName);
2823                                         $$->name = xlateSqlType("interval");
2824                                 }
2825                 ;
2826
2827 datetime:  YEAR_P                                                               { $$ = "year"; }
2828                 | MONTH_P                                                               { $$ = "month"; }
2829                 | DAY_P                                                                 { $$ = "day"; }
2830                 | HOUR_P                                                                { $$ = "hour"; }
2831                 | MINUTE_P                                                              { $$ = "minute"; }
2832                 | SECOND_P                                                              { $$ = "second"; }
2833                 ;
2834
2835 opt_timezone:  WITH TIME ZONE                                   { $$ = TRUE; }
2836                 | /*EMPTY*/                                                             { $$ = FALSE; }
2837                 ;
2838
2839 opt_interval:  datetime                                                 { $$ = lcons($1, NIL); }
2840                 | YEAR_P TO MONTH_P                                             { $$ = NIL; }
2841                 | DAY_P TO HOUR_P                                               { $$ = NIL; }
2842                 | DAY_P TO MINUTE_P                                             { $$ = NIL; }
2843                 | DAY_P TO SECOND_P                                             { $$ = NIL; }
2844                 | HOUR_P TO MINUTE_P                                    { $$ = NIL; }
2845                 | HOUR_P TO SECOND_P                                    { $$ = NIL; }
2846                 | /*EMPTY*/                                                             { $$ = NIL; }
2847                 ;
2848
2849
2850 /*****************************************************************************
2851  *
2852  *      expression grammar, still needs some cleanup
2853  *
2854  *****************************************************************************/
2855
2856 a_expr_or_null:  a_expr
2857                                 { $$ = $1; }
2858                 | NULL_P
2859                                 {
2860                                         A_Const *n = makeNode(A_Const);
2861                                         n->val.type = T_Null;
2862                                         $$ = (Node *)n;
2863                                 }
2864                 ;
2865
2866 /* Expressions using row descriptors
2867  * Define row_descriptor to allow yacc to break the reduce/reduce conflict
2868  *  with singleton expressions.
2869  */
2870 row_expr: '(' row_descriptor ')' IN '(' SubSelect ')'
2871                                 {
2872                                         $$ = NULL;
2873                                 }
2874                 | '(' row_descriptor ')' NOT IN '(' SubSelect ')'
2875                                 {
2876                                         $$ = NULL;
2877                                 }
2878                 | '(' row_descriptor ')' '=' '(' row_descriptor ')'
2879                                 {
2880                                         $$ = makeRowExpr("=", $2, $6);
2881                                 }
2882                 | '(' row_descriptor ')' '<' '(' row_descriptor ')'
2883                                 {
2884                                         $$ = makeRowExpr("<", $2, $6);
2885                                 }
2886                 | '(' row_descriptor ')' '>' '(' row_descriptor ')'
2887                                 {
2888                                         $$ = makeRowExpr("<", $2, $6);
2889                                 }
2890                 | '(' row_descriptor ')' Op '(' row_descriptor ')'
2891                                 {
2892                                         $$ = makeRowExpr($4, $2, $6);
2893                                 }
2894                 ;
2895
2896 row_descriptor:  row_list ',' a_expr
2897                                 {
2898                                         $$ = lappend($1, $3);
2899                                 }
2900                 ;
2901
2902 row_list:  row_list ',' a_expr
2903                                 {
2904                                         $$ = lappend($1, $3);
2905                                 }
2906                 | a_expr
2907                                 {
2908                                         $$ = lcons($1, NIL);
2909                                 }
2910                 ;
2911
2912 a_expr:  attr opt_indirection
2913                                 {
2914                                         $1->indirection = $2;
2915                                         $$ = (Node *)$1;
2916                                 }
2917                 | row_expr
2918                                 {       $$ = $1;  }
2919                 | AexprConst
2920                                 {       $$ = $1;  }
2921                 | '-' a_expr %prec UMINUS
2922                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
2923                 | a_expr '+' a_expr
2924                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
2925                 | a_expr '-' a_expr
2926                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
2927                 | a_expr '/' a_expr
2928                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
2929                 | a_expr '*' a_expr
2930                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
2931                 | a_expr '<' a_expr
2932                                 {       $$ = makeA_Expr(OP, "<", $1, $3); }
2933                 | a_expr '>' a_expr
2934                                 {       $$ = makeA_Expr(OP, ">", $1, $3); }
2935                 | a_expr '=' a_expr
2936                                 {       $$ = makeA_Expr(OP, "=", $1, $3); }
2937                 | ':' a_expr
2938                                 {       $$ = makeA_Expr(OP, ":", NULL, $2); }
2939                 | ';' a_expr
2940                                 {       $$ = makeA_Expr(OP, ";", NULL, $2); }
2941                 | '|' a_expr
2942                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
2943                 | a_expr TYPECAST Typename
2944                                 {
2945                                         $$ = (Node *)$1;
2946                                         /* AexprConst can be either A_Const or ParamNo */
2947                                         if (nodeTag($1) == T_A_Const) {
2948                                                 ((A_Const *)$1)->typename = $3;
2949                                         } else if (nodeTag($1) == T_Param) {
2950                                                 ((ParamNo *)$1)->typename = $3;
2951                                         /* otherwise, try to transform to a function call */
2952                                         } else {
2953                                                 FuncCall *n = makeNode(FuncCall);
2954                                                 n->funcname = $3->name;
2955                                                 n->args = lcons($1,NIL);
2956                                                 $$ = (Node *)n;
2957                                         }
2958                                 }
2959                 | CAST a_expr AS Typename
2960                                 {
2961                                         $$ = (Node *)$2;
2962                                         /* AexprConst can be either A_Const or ParamNo */
2963                                         if (nodeTag($2) == T_A_Const) {
2964                                                 ((A_Const *)$2)->typename = $4;
2965                                         } else if (nodeTag($2) == T_Param) {
2966                                                 ((ParamNo *)$2)->typename = $4;
2967                                         /* otherwise, try to transform to a function call */
2968                                         } else {
2969                                                 FuncCall *n = makeNode(FuncCall);
2970                                                 n->funcname = $4->name;
2971                                                 n->args = lcons($2,NIL);
2972                                                 $$ = (Node *)n;
2973                                         }
2974                                 }
2975                 | '(' a_expr_or_null ')'
2976                                 {       $$ = $2; }
2977                 | a_expr Op a_expr
2978                                 {       $$ = makeIndexable($2,$1,$3);   }
2979                 | a_expr LIKE a_expr
2980                                 {       $$ = makeIndexable("~~", $1, $3); }
2981                 | a_expr NOT LIKE a_expr
2982                                 {       $$ = makeA_Expr(OP, "!~~", $1, $4); }
2983                 | Op a_expr
2984                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
2985                 | a_expr Op
2986                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
2987                 | ColId
2988                                 {
2989                                         /* could be a column name or a relation_name */
2990                                         Ident *n = makeNode(Ident);
2991                                         n->name = $1;
2992                                         n->indirection = NULL;
2993                                         $$ = (Node *)n;
2994                                 }
2995                 | name '(' '*' ')'
2996                                 {
2997                                         /* cheap hack for aggregate (eg. count) */
2998                                         FuncCall *n = makeNode(FuncCall);
2999                                         A_Const *star = makeNode(A_Const);
3000
3001                                         star->val.type = T_String;
3002                                         star->val.val.str = "";
3003                                         n->funcname = $1;
3004                                         n->args = lcons(star, NIL);
3005                                         $$ = (Node *)n;
3006                                 }
3007                 | name '(' ')'
3008                                 {
3009                                         FuncCall *n = makeNode(FuncCall);
3010                                         n->funcname = $1;
3011                                         n->args = NIL;
3012                                         $$ = (Node *)n;
3013                                 }
3014                 | name '(' expr_list ')'
3015                                 {
3016                                         FuncCall *n = makeNode(FuncCall);
3017                                         n->funcname = $1;
3018                                         n->args = $3;
3019                                         $$ = (Node *)n;
3020                                 }
3021                 | CURRENT_DATE
3022                                 {
3023                                         A_Const *n = makeNode(A_Const);
3024                                         TypeName *t = makeNode(TypeName);
3025
3026                                         n->val.type = T_String;
3027                                         n->val.val.str = "now";
3028                                         n->typename = t;
3029
3030                                         t->name = xlateSqlType("date");
3031                                         t->setof = FALSE;
3032
3033                                         $$ = (Node *)n;
3034                                 }
3035                 | CURRENT_TIME
3036                                 {
3037                                         A_Const *n = makeNode(A_Const);
3038                                         TypeName *t = makeNode(TypeName);
3039
3040                                         n->val.type = T_String;
3041                                         n->val.val.str = "now";
3042                                         n->typename = t;
3043
3044                                         t->name = xlateSqlType("time");
3045                                         t->setof = FALSE;
3046
3047                                         $$ = (Node *)n;
3048                                 }
3049                 | CURRENT_TIME '(' Iconst ')'
3050                                 {
3051                                         FuncCall *n = makeNode(FuncCall);
3052                                         A_Const *s = makeNode(A_Const);
3053                                         TypeName *t = makeNode(TypeName);
3054
3055                                         n->funcname = xlateSqlType("time");
3056                                         n->args = lcons(s, NIL);
3057
3058                                         s->val.type = T_String;
3059                                         s->val.val.str = "now";
3060                                         s->typename = t;
3061
3062                                         t->name = xlateSqlType("time");
3063                                         t->setof = FALSE;
3064
3065                                         if ($3 != 0)
3066                                                 elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
3067
3068                                         $$ = (Node *)n;
3069                                 }
3070                 | CURRENT_TIMESTAMP
3071                                 {
3072                                         A_Const *n = makeNode(A_Const);
3073                                         TypeName *t = makeNode(TypeName);
3074
3075                                         n->val.type = T_String;
3076                                         n->val.val.str = "now";
3077                                         n->typename = t;
3078
3079                                         t->name = xlateSqlType("timestamp");
3080                                         t->setof = FALSE;
3081
3082                                         $$ = (Node *)n;
3083                                 }
3084                 | CURRENT_TIMESTAMP '(' Iconst ')'
3085                                 {
3086                                         FuncCall *n = makeNode(FuncCall);
3087                                         A_Const *s = makeNode(A_Const);
3088                                         TypeName *t = makeNode(TypeName);
3089
3090                                         n->funcname = xlateSqlType("timestamp");
3091                                         n->args = lcons(s, NIL);
3092
3093                                         s->val.type = T_String;
3094                                         s->val.val.str = "now";
3095                                         s->typename = t;
3096
3097                                         t->name = xlateSqlType("timestamp");
3098                                         t->setof = FALSE;
3099
3100                                         if ($3 != 0)
3101                                                 elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
3102
3103                                         $$ = (Node *)n;
3104                                 }
3105                 | CURRENT_USER
3106                                 {
3107                                         FuncCall *n = makeNode(FuncCall);
3108                                         n->funcname = "getpgusername";
3109                                         n->args = NIL;
3110                                         $$ = (Node *)n;
3111                                 }
3112                 /* We probably need to define an "exists" node,
3113                  *      since the optimizer could choose to find only one match.
3114                  * Perhaps the first implementation could just check for
3115                  *      count(*) > 0? - thomas 1997-07-19
3116                  */
3117                 | EXISTS '(' SubSelect ')'
3118                                 {
3119                                         elog(ERROR,"EXISTS not yet implemented");
3120                                         $$ = $3;
3121                                 }
3122                 | EXTRACT '(' extract_list ')'
3123                                 {
3124                                         FuncCall *n = makeNode(FuncCall);
3125                                         n->funcname = "date_part";
3126                                         n->args = $3;
3127                                         $$ = (Node *)n;
3128                                 }
3129                 | POSITION '(' position_list ')'
3130                                 {
3131                                         FuncCall *n = makeNode(FuncCall);
3132                                         n->funcname = "strpos";
3133                                         n->args = $3;
3134                                         $$ = (Node *)n;
3135                                 }
3136                 | SUBSTRING '(' substr_list ')'
3137                                 {
3138                                         FuncCall *n = makeNode(FuncCall);
3139                                         n->funcname = "substr";
3140                                         n->args = $3;
3141                                         $$ = (Node *)n;
3142                                 }
3143                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3144                 | TRIM '(' BOTH trim_list ')'
3145                                 {
3146                                         FuncCall *n = makeNode(FuncCall);
3147                                         n->funcname = "btrim";
3148                                         n->args = $4;
3149                                         $$ = (Node *)n;
3150                                 }
3151                 | TRIM '(' LEADING trim_list ')'
3152                                 {
3153                                         FuncCall *n = makeNode(FuncCall);
3154                                         n->funcname = "ltrim";
3155                                         n->args = $4;
3156                                         $$ = (Node *)n;
3157                                 }
3158                 | TRIM '(' TRAILING trim_list ')'
3159                                 {
3160                                         FuncCall *n = makeNode(FuncCall);
3161                                         n->funcname = "rtrim";
3162                                         n->args = $4;
3163                                         $$ = (Node *)n;
3164                                 }
3165                 | TRIM '(' trim_list ')'
3166                                 {
3167                                         FuncCall *n = makeNode(FuncCall);
3168                                         n->funcname = "btrim";
3169                                         n->args = $3;
3170                                         $$ = (Node *)n;
3171                                 }
3172                 | a_expr ISNULL
3173                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3174                 | a_expr IS NULL_P
3175                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3176                 | a_expr NOTNULL
3177                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3178                 | a_expr IS NOT NULL_P
3179                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3180                 /* IS TRUE, IS FALSE, etc used to be function calls
3181                  *  but let's make them expressions to allow the optimizer
3182                  *  a chance to eliminate them if a_expr is a constant string.
3183                  * - thomas 1997-12-22
3184                  */
3185                 | a_expr IS TRUE_P
3186                                 {
3187                                         A_Const *n = makeNode(A_Const);
3188                                         n->val.type = T_String;
3189                                         n->val.val.str = "t";
3190                                         n->typename = makeNode(TypeName);
3191                                         n->typename->name = xlateSqlType("bool");
3192                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3193                                 }
3194                 | a_expr IS NOT FALSE_P
3195                                 {
3196                                         A_Const *n = makeNode(A_Const);
3197                                         n->val.type = T_String;
3198                                         n->val.val.str = "t";
3199                                         n->typename = makeNode(TypeName);
3200                                         n->typename->name = xlateSqlType("bool");
3201                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3202                                 }
3203                 | a_expr IS FALSE_P
3204                                 {
3205                                         A_Const *n = makeNode(A_Const);
3206                                         n->val.type = T_String;
3207                                         n->val.val.str = "f";
3208                                         n->typename = makeNode(TypeName);
3209                                         n->typename->name = xlateSqlType("bool");
3210                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3211                                 }
3212                 | a_expr IS NOT TRUE_P
3213                                 {
3214                                         A_Const *n = makeNode(A_Const);
3215                                         n->val.type = T_String;
3216                                         n->val.val.str = "f";
3217                                         n->typename = makeNode(TypeName);
3218                                         n->typename->name = xlateSqlType("bool");
3219                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3220                                 }
3221                 | a_expr BETWEEN AexprConst AND AexprConst
3222                                 {
3223                                         $$ = makeA_Expr(AND, NULL,
3224                                                 makeA_Expr(OP, ">=", $1, $3),
3225                                                 makeA_Expr(OP, "<=", $1, $5));
3226                                 }
3227                 | a_expr NOT BETWEEN AexprConst AND AexprConst
3228                                 {
3229                                         $$ = makeA_Expr(OR, NULL,
3230                                                 makeA_Expr(OP, "<", $1, $4),
3231                                                 makeA_Expr(OP, ">", $1, $6));
3232                                 }
3233                 | a_expr IN { saved_In_Expr = $1; } '(' in_expr ')'
3234                                 {       $$ = $5; }
3235                 | a_expr NOT IN { saved_In_Expr = $1; } '(' not_in_expr ')'
3236                                 {       $$ = $6; }
3237                 | a_expr AND a_expr
3238                                 {       $$ = makeA_Expr(AND, NULL, $1, $3); }
3239                 | a_expr OR a_expr
3240                                 {       $$ = makeA_Expr(OR, NULL, $1, $3); }
3241                 | NOT a_expr
3242                                 {       $$ = makeA_Expr(NOT, NULL, NULL, $2); }
3243                 ;
3244
3245 opt_indirection:  '[' a_expr ']' opt_indirection
3246                                 {
3247                                         A_Indices *ai = makeNode(A_Indices);
3248                                         ai->lidx = NULL;
3249                                         ai->uidx = $2;
3250                                         $$ = lcons(ai, $4);
3251                                 }
3252                 | '[' a_expr ':' a_expr ']' opt_indirection
3253                                 {
3254                                         A_Indices *ai = makeNode(A_Indices);
3255                                         ai->lidx = $2;
3256                                         ai->uidx = $4;
3257                                         $$ = lcons(ai, $6);
3258                                 }
3259                 | /* EMPTY */
3260                                 {       $$ = NIL; }
3261                 ;
3262
3263 expr_list:  a_expr_or_null
3264                                 { $$ = lcons($1, NIL); }
3265                 | expr_list ',' a_expr_or_null
3266                                 { $$ = lappend($1, $3); }
3267                 | expr_list USING a_expr
3268                                 { $$ = lappend($1, $3); }
3269                 ;
3270
3271 extract_list:  datetime FROM a_expr
3272                                 {
3273                                         A_Const *n = makeNode(A_Const);
3274                                         n->val.type = T_String;
3275                                         n->val.val.str = $1;
3276                                         $$ = lappend(lcons((Node *)n,NIL), $3);
3277                                 }
3278                 | /* EMPTY */
3279                                 {       $$ = NIL; }
3280                 ;
3281
3282 position_list:  position_expr IN position_expr
3283                                 {       $$ = makeList($3, $1, -1); }
3284                 | /* EMPTY */
3285                                 {       $$ = NIL; }
3286                 ;
3287
3288 position_expr:  attr opt_indirection
3289                                 {
3290                                         $1->indirection = $2;
3291                                         $$ = (Node *)$1;
3292                                 }
3293                 | AexprConst
3294                                 {       $$ = $1;  }
3295                 | '-' position_expr %prec UMINUS
3296                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
3297                 | position_expr '+' position_expr
3298                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
3299                 | position_expr '-' position_expr
3300                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
3301                 | position_expr '/' position_expr
3302                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
3303                 | position_expr '*' position_expr
3304                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
3305                 | '|' position_expr
3306                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
3307                 | position_expr TYPECAST Typename
3308                                 {
3309                                         $$ = (Node *)$1;
3310                                         /* AexprConst can be either A_Const or ParamNo */
3311                                         if (nodeTag($1) == T_A_Const) {
3312                                                 ((A_Const *)$1)->typename = $3;
3313                                         } else if (nodeTag($1) == T_Param) {
3314                                                 ((ParamNo *)$1)->typename = $3;
3315                                         /* otherwise, try to transform to a function call */
3316                                         } else {
3317                                                 FuncCall *n = makeNode(FuncCall);
3318                                                 n->funcname = $3->name;
3319                                                 n->args = lcons($1,NIL);
3320                                                 $$ = (Node *)n;
3321                                         }
3322                                 }
3323                 | CAST position_expr AS Typename
3324                                 {
3325                                         $$ = (Node *)$2;
3326                                         /* AexprConst can be either A_Const or ParamNo */
3327                                         if (nodeTag($2) == T_A_Const) {
3328                                                 ((A_Const *)$2)->typename = $4;
3329                                         } else if (nodeTag($2) == T_Param) {
3330                                                 ((ParamNo *)$2)->typename = $4;
3331                                         /* otherwise, try to transform to a function call */
3332                                         } else {
3333                                                 FuncCall *n = makeNode(FuncCall);
3334                                                 n->funcname = $4->name;
3335                                                 n->args = lcons($2,NIL);
3336                                                 $$ = (Node *)n;
3337                                         }
3338                                 }
3339                 | '(' position_expr ')'
3340                                 {       $$ = $2; }
3341                 | position_expr Op position_expr
3342                                 {       $$ = makeA_Expr(OP, $2, $1, $3); }
3343                 | Op position_expr
3344                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
3345                 | position_expr Op
3346                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
3347                 | ColId
3348                                 {
3349                                         /* could be a column name or a relation_name */
3350                                         Ident *n = makeNode(Ident);
3351                                         n->name = $1;
3352                                         n->indirection = NULL;
3353                                         $$ = (Node *)n;
3354                                 }
3355                 | name '(' ')'
3356                                 {
3357                                         FuncCall *n = makeNode(FuncCall);
3358                                         n->funcname = $1;
3359                                         n->args = NIL;
3360                                         $$ = (Node *)n;
3361                                 }
3362                 | name '(' expr_list ')'
3363                                 {
3364                                         FuncCall *n = makeNode(FuncCall);
3365                                         n->funcname = $1;
3366                                         n->args = $3;
3367                                         $$ = (Node *)n;
3368                                 }
3369                 | POSITION '(' position_list ')'
3370                                 {
3371                                         FuncCall *n = makeNode(FuncCall);
3372                                         n->funcname = "strpos";
3373                                         n->args = $3;
3374                                         $$ = (Node *)n;
3375                                 }
3376                 | SUBSTRING '(' substr_list ')'
3377                                 {
3378                                         FuncCall *n = makeNode(FuncCall);
3379                                         n->funcname = "substr";
3380                                         n->args = $3;
3381                                         $$ = (Node *)n;
3382                                 }
3383                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3384                 | TRIM '(' BOTH trim_list ')'
3385                                 {
3386                                         FuncCall *n = makeNode(FuncCall);
3387                                         n->funcname = "btrim";
3388                                         n->args = $4;
3389                                         $$ = (Node *)n;
3390                                 }
3391                 | TRIM '(' LEADING trim_list ')'
3392                                 {
3393                                         FuncCall *n = makeNode(FuncCall);
3394                                         n->funcname = "ltrim";
3395                                         n->args = $4;
3396                                         $$ = (Node *)n;
3397                                 }
3398                 | TRIM '(' TRAILING trim_list ')'
3399                                 {
3400                                         FuncCall *n = makeNode(FuncCall);
3401                                         n->funcname = "rtrim";
3402                                         n->args = $4;
3403                                         $$ = (Node *)n;
3404                                 }
3405                 | TRIM '(' trim_list ')'
3406                                 {
3407                                         FuncCall *n = makeNode(FuncCall);
3408                                         n->funcname = "btrim";
3409                                         n->args = $3;
3410                                         $$ = (Node *)n;
3411                                 }
3412                 ;
3413
3414 substr_list:  expr_list substr_from substr_for
3415                                 {
3416                                         $$ = nconc(nconc($1,$2),$3);
3417                                 }
3418                 | /* EMPTY */
3419                                 {       $$ = NIL; }
3420                 ;
3421
3422 substr_from:  FROM expr_list
3423                                 {       $$ = $2; }
3424                 | /* EMPTY */
3425                                 {
3426                                         A_Const *n = makeNode(A_Const);
3427                                         n->val.type = T_Integer;
3428                                         n->val.val.ival = 1;
3429                                         $$ = lcons((Node *)n,NIL);
3430                                 }
3431                 ;
3432
3433 substr_for:  FOR expr_list
3434                                 {       $$ = $2; }
3435                 | /* EMPTY */
3436                                 {       $$ = NIL; }
3437                 ;
3438
3439 trim_list:  a_expr FROM expr_list
3440                                 { $$ = lappend($3, $1); }
3441                 | FROM expr_list
3442                                 { $$ = $2; }
3443                 | expr_list
3444                                 { $$ = $1; }
3445                 ;
3446
3447 in_expr:  SubSelect
3448                                 {
3449                                         elog(ERROR,"IN (SUBSELECT) not yet implemented");
3450                                         $$ = $1;
3451                                 }
3452                 | in_expr_nodes
3453                                 {       $$ = $1; }
3454                 ;
3455
3456 in_expr_nodes:  AexprConst
3457                                 {       $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
3458                 | in_expr_nodes ',' AexprConst
3459                                 {       $$ = makeA_Expr(OR, NULL, $1,
3460                                                 makeA_Expr(OP, "=", saved_In_Expr, $3));
3461                                 }
3462                 ;
3463
3464 not_in_expr:  SubSelect
3465                                 {
3466                                         elog(ERROR,"NOT IN (SUBSELECT) not yet implemented");
3467                                         $$ = $1;
3468                                 }
3469                 | not_in_expr_nodes
3470                                 {       $$ = $1; }
3471                 ;
3472
3473 not_in_expr_nodes:  AexprConst
3474                                 {       $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
3475                 | not_in_expr_nodes ',' AexprConst
3476                                 {       $$ = makeA_Expr(AND, NULL, $1,
3477                                                 makeA_Expr(OP, "<>", saved_In_Expr, $3));
3478                                 }
3479                 ;
3480
3481 attr:  relation_name '.' attrs
3482                                 {
3483                                         $$ = makeNode(Attr);
3484                                         $$->relname = $1;
3485                                         $$->paramNo = NULL;
3486                                         $$->attrs = $3;
3487                                         $$->indirection = NULL;
3488                                 }
3489                 | ParamNo '.' attrs
3490                                 {
3491                                         $$ = makeNode(Attr);
3492                                         $$->relname = NULL;
3493                                         $$->paramNo = $1;
3494                                         $$->attrs = $3;
3495                                         $$->indirection = NULL;
3496                                 }
3497                 ;
3498
3499 attrs:    attr_name
3500                                 { $$ = lcons(makeString($1), NIL); }
3501                 | attrs '.' attr_name
3502                                 { $$ = lappend($1, makeString($3)); }
3503                 | attrs '.' '*'
3504                                 { $$ = lappend($1, makeString("*")); }
3505                 ;
3506
3507
3508 /*****************************************************************************
3509  *
3510  *      target lists
3511  *
3512  *****************************************************************************/
3513
3514 res_target_list:  res_target_list ',' res_target_el
3515                                 {       $$ = lappend($1,$3);  }
3516                 | res_target_el
3517                                 {       $$ = lcons($1, NIL);  }
3518                 | '*'
3519                                 {
3520                                         ResTarget *rt = makeNode(ResTarget);
3521                                         Attr *att = makeNode(Attr);
3522                                         att->relname = "*";
3523                                         att->paramNo = NULL;
3524                                         att->attrs = NULL;
3525                                         att->indirection = NIL;
3526                                         rt->name = NULL;
3527                                         rt->indirection = NULL;
3528                                         rt->val = (Node *)att;
3529                                         $$ = lcons(rt, NIL);
3530                                 }
3531                 ;
3532
3533 res_target_el:  ColId opt_indirection '=' a_expr_or_null
3534                                 {
3535                                         $$ = makeNode(ResTarget);
3536                                         $$->name = $1;
3537                                         $$->indirection = $2;
3538                                         $$->val = (Node *)$4;
3539                                 }
3540                 | attr opt_indirection
3541                                 {
3542                                         $$ = makeNode(ResTarget);
3543                                         $$->name = NULL;
3544                                         $$->indirection = $2;
3545                                         $$->val = (Node *)$1;
3546                                 }
3547                 | relation_name '.' '*'
3548                                 {
3549                                         Attr *att = makeNode(Attr);
3550                                         att->relname = $1;
3551                                         att->paramNo = NULL;
3552                                         att->attrs = lcons(makeString("*"), NIL);
3553                                         att->indirection = NIL;
3554                                         $$ = makeNode(ResTarget);
3555                                         $$->name = NULL;
3556                                         $$->indirection = NULL;
3557                                         $$->val = (Node *)att;
3558                                 }
3559                 ;
3560
3561 /*
3562 ** target list for select.
3563 ** should get rid of the other but is still needed by the defunct retrieve into
3564 ** and update (uses a subset)
3565 */
3566 res_target_list2:  res_target_list2 ',' res_target_el2
3567                                 {       $$ = lappend($1, $3);  }
3568                 | res_target_el2
3569                                 {       $$ = lcons($1, NIL);  }
3570                 ;
3571
3572 /* AS is not optional because shift/red conflict with unary ops */
3573 res_target_el2:  a_expr_or_null AS ColLabel
3574                                 {
3575                                         $$ = makeNode(ResTarget);
3576                                         $$->name = $3;
3577                                         $$->indirection = NULL;
3578                                         $$->val = (Node *)$1;
3579                                 }
3580                 | a_expr_or_null
3581                                 {
3582                                         $$ = makeNode(ResTarget);
3583                                         $$->name = NULL;
3584                                         $$->indirection = NULL;
3585                                         $$->val = (Node *)$1;
3586                                 }
3587                 | relation_name '.' '*'
3588                                 {
3589                                         Attr *att = makeNode(Attr);
3590                                         att->relname = $1;
3591                                         att->paramNo = NULL;
3592                                         att->attrs = lcons(makeString("*"), NIL);
3593                                         att->indirection = NIL;
3594                                         $$ = makeNode(ResTarget);
3595                                         $$->name = NULL;
3596                                         $$->indirection = NULL;
3597                                         $$->val = (Node *)att;
3598                                 }
3599                 | '*'
3600                                 {
3601                                         Attr *att = makeNode(Attr);
3602                                         att->relname = "*";
3603                                         att->paramNo = NULL;
3604                                         att->attrs = NULL;
3605                                         att->indirection = NIL;
3606                                         $$ = makeNode(ResTarget);
3607                                         $$->name = NULL;
3608                                         $$->indirection = NULL;
3609                                         $$->val = (Node *)att;
3610                                 }
3611                 ;
3612
3613 opt_id:  ColId                                                                  { $$ = $1; }
3614                 | /* EMPTY */                                                   { $$ = NULL; }
3615                 ;
3616
3617 relation_name:  SpecialRuleRelation
3618                                 {
3619                                         $$ = $1;
3620                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3621                                 }
3622                 | ColId
3623                                 {
3624                                         /* disallow refs to variable system tables */
3625                                         if (strcmp(LogRelationName, $1) == 0
3626                                            || strcmp(VariableRelationName, $1) == 0)
3627                                                 elog(ERROR,"%s cannot be accessed by users",$1);
3628                                         else
3629                                                 $$ = $1;
3630                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3631                                 }
3632                 ;
3633
3634 database_name:                  ColId                   { $$ = $1; };
3635 access_method:                  Id                              { $$ = $1; };
3636 attr_name:                              ColId                   { $$ = $1; };
3637 class:                                  Id                              { $$ = $1; };
3638 index_name:                             ColId                   { $$ = $1; };
3639
3640 /* Functions
3641  * Include date/time keywords as SQL92 extension.
3642  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3643  */
3644 name:                                   ColId                   { $$ = $1; };
3645
3646 file_name:                              Sconst                  { $$ = $1; };
3647 recipe_name:                    Id                              { $$ = $1; };
3648
3649 /* Constants
3650  * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
3651  */
3652 AexprConst:  Iconst
3653                                 {
3654                                         A_Const *n = makeNode(A_Const);
3655                                         n->val.type = T_Integer;
3656                                         n->val.val.ival = $1;
3657                                         $$ = (Node *)n;
3658                                 }
3659                 | FCONST
3660                                 {
3661                                         A_Const *n = makeNode(A_Const);
3662                                         n->val.type = T_Float;
3663                                         n->val.val.dval = $1;
3664                                         $$ = (Node *)n;
3665                                 }
3666                 | Sconst
3667                                 {
3668                                         A_Const *n = makeNode(A_Const);
3669                                         n->val.type = T_String;
3670                                         n->val.val.str = $1;
3671                                         $$ = (Node *)n;
3672                                 }
3673                 | Typename Sconst
3674                                 {
3675                                         A_Const *n = makeNode(A_Const);
3676                                         n->typename = $1;
3677                                         n->val.type = T_String;
3678                                         n->val.val.str = $2;
3679                                         $$ = (Node *)n;
3680                                 }
3681                 | ParamNo
3682                                 {       $$ = (Node *)$1;  }
3683                 | TRUE_P
3684                                 {
3685                                         A_Const *n = makeNode(A_Const);
3686                                         n->val.type = T_String;
3687                                         n->val.val.str = "t";
3688                                         n->typename = makeNode(TypeName);
3689                                         n->typename->name = xlateSqlType("bool");
3690                                         $$ = (Node *)n;
3691                                 }
3692                 | FALSE_P
3693                                 {
3694                                         A_Const *n = makeNode(A_Const);
3695                                         n->val.type = T_String;
3696                                         n->val.val.str = "f";
3697                                         n->typename = makeNode(TypeName);
3698                                         n->typename->name = xlateSqlType("bool");
3699                                         $$ = (Node *)n;
3700                                 }
3701                 ;
3702
3703 ParamNo:  PARAM
3704                                 {
3705                                         $$ = makeNode(ParamNo);
3706                                         $$->number = $1;
3707                                 }
3708                 ;
3709
3710 NumConst:  Iconst                                               { $$ = makeInteger($1); }
3711                 | FCONST                                                { $$ = makeFloat($1); }
3712                 ;
3713
3714 Iconst:  ICONST                                                 { $$ = $1; };
3715 Sconst:  SCONST                                                 { $$ = $1; };
3716
3717 /* Column and type identifier
3718  * Does not include explicit datetime types
3719  *  since these must be decoupled in Typename syntax.
3720  * Use ColId for most identifiers. - thomas 1997-10-21
3721  */
3722 Id:  IDENT                                                              { $$ = $1; };
3723
3724 /* Column identifier
3725  * Include date/time keywords as SQL92 extension.
3726  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3727  * Add other keywords. Note that as the syntax expands,
3728  *  some of these keywords will have to be removed from this
3729  *  list due to shift/reduce conflicts in yacc. If so, move
3730  *  down to the ColLabel entity. - thomas 1997-11-06
3731  */
3732 ColId:  Id                                                              { $$ = $1; }
3733                 | datetime                                              { $$ = $1; }
3734                 | ACTION                                                { $$ = "action"; }
3735                 | DATABASE                                              { $$ = "database"; }
3736                 | DELIMITERS                                    { $$ = "delimiters"; }
3737                 | FUNCTION                                              { $$ = "function"; }
3738                 | INDEX                                                 { $$ = "index"; }
3739                 | KEY                                                   { $$ = "key"; }
3740                 | LANGUAGE                                              { $$ = "language"; }
3741                 | LOCATION                                              { $$ = "location"; }
3742                 | MATCH                                                 { $$ = "match"; }
3743                 | OPERATOR                                              { $$ = "operator"; }
3744                 | OPTION                                                { $$ = "option"; }
3745                 | PRIVILEGES                                    { $$ = "privileges"; }
3746                 | RECIPE                                                { $$ = "recipe"; }
3747                 | TIME                                                  { $$ = "time"; }
3748                 | TRIGGER                                               { $$ = "trigger"; }
3749                 | TYPE_P                                                { $$ = "type"; }
3750                 | VERSION                                               { $$ = "version"; }
3751                 | ZONE                                                  { $$ = "zone"; }
3752                 ;
3753
3754 /* Column label
3755  * Allowed labels in "AS" clauses.
3756  * Include TRUE/FALSE SQL3 reserved words for Postgres backward
3757  *  compatibility. Cannot allow this for column names since the
3758  *  syntax would not distinguish between the constant value and
3759  *  a column name. - thomas 1997-10-24
3760  * Add other keywords to this list. Note that they appear here
3761  *  rather than in ColId if there was a shift/reduce conflict
3762  *  when used as a full identifier. - thomas 1997-11-06
3763  */
3764 ColLabel:  ColId                                                { $$ = $1; }
3765                 | ARCHIVE                                               { $$ = "archive"; }
3766                 | CLUSTER                                               { $$ = "cluster"; }
3767                 | CONSTRAINT                                    { $$ = "constraint"; }
3768                 | CROSS                                                 { $$ = "cross"; }
3769                 | FOREIGN                                               { $$ = "foreign"; }
3770                 | GROUP                                                 { $$ = "group"; }
3771                 | LOAD                                                  { $$ = "load"; }
3772                 | ORDER                                                 { $$ = "order"; }
3773                 | POSITION                                              { $$ = "position"; }
3774                 | PRECISION                                             { $$ = "precision"; }
3775                 | TABLE                                                 { $$ = "table"; }
3776                 | TRANSACTION                                   { $$ = "transaction"; }
3777                 | TRUE_P                                                { $$ = "true"; }
3778                 | FALSE_P                                               { $$ = "false"; }
3779                 ;
3780
3781 SpecialRuleRelation:  CURRENT
3782                                 {
3783                                         if (QueryIsRule)
3784                                                 $$ = "*CURRENT*";
3785                                         else
3786                                                 elog(ERROR,"CURRENT used in non-rule query");
3787                                 }
3788                 | NEW
3789                                 {
3790                                         if (QueryIsRule)
3791                                                 $$ = "*NEW*";
3792                                         else
3793                                                 elog(ERROR,"NEW used in non-rule query");
3794                                 }
3795                 ;
3796
3797 %%
3798
3799 static Node *
3800 makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
3801 {
3802         A_Expr *a = makeNode(A_Expr);
3803         a->oper = oper;
3804         a->opname = opname;
3805         a->lexpr = lexpr;
3806         a->rexpr = rexpr;
3807         return (Node *)a;
3808 }
3809
3810 /* makeRowExpr()
3811  * Generate separate operator nodes for a single row descriptor expression.
3812  * Perhaps this should go deeper in the parser someday... - thomas 1997-12-22
3813  */
3814 static Node *
3815 makeRowExpr(char *opr, List *largs, List *rargs)
3816 {
3817         Node *expr = NULL;
3818         Node *larg, *rarg;
3819
3820         if (length(largs) != length(rargs))
3821                 elog(ERROR,"Unequal number of entries in row expression");
3822
3823         if (lnext(largs) != NIL)
3824                 expr = makeRowExpr(opr,lnext(largs),lnext(rargs));
3825
3826         larg = lfirst(largs);
3827         rarg = lfirst(rargs);
3828
3829         if ((strcmp(opr, "=") == 0)
3830          || (strcmp(opr, "<") == 0)
3831          || (strcmp(opr, "<=") == 0)
3832          || (strcmp(opr, ">") == 0)
3833          || (strcmp(opr, ">=") == 0))
3834         {
3835                 if (expr == NULL)
3836                         expr = makeA_Expr(OP, opr, larg, rarg);
3837                 else
3838                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3839         }
3840         else if (strcmp(opr, "<>") == 0)
3841         {
3842                 if (expr == NULL)
3843                         expr = makeA_Expr(OP, opr, larg, rarg);
3844                 else
3845                         expr = makeA_Expr(OR, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3846         }
3847         else
3848         {
3849                 elog(ERROR,"Operator '%s' not implemented for row expressions",opr);
3850         }
3851
3852 #if FALSE
3853         while ((largs != NIL) && (rargs != NIL))
3854         {
3855                 larg = lfirst(largs);
3856                 rarg = lfirst(rargs);
3857
3858                 if (expr == NULL)
3859                         expr = makeA_Expr(OP, opr, larg, rarg);
3860                 else
3861                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3862
3863                 largs = lnext(largs);
3864                 rargs = lnext(rargs);
3865         }
3866         pprint(expr);
3867 #endif
3868
3869         return expr;
3870 } /* makeRowExpr() */
3871
3872 void
3873 mapTargetColumns(List *src, List *dst)
3874 {
3875         ColumnDef *s;
3876         ResTarget *d;
3877
3878         if (length(src) != length(dst))
3879                 elog(ERROR,"CREATE TABLE/AS SELECT has mismatched column count");
3880
3881         while ((src != NIL) && (dst != NIL))
3882         {
3883                 s = (ColumnDef *)lfirst(src);
3884                 d = (ResTarget *)lfirst(dst);
3885
3886                 d->name = s->colname;
3887
3888                 src = lnext(src);
3889                 dst = lnext(dst);
3890         }
3891
3892         return;
3893 } /* mapTargetColumns() */
3894
3895 static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr)
3896 {
3897         Node *result = NULL;
3898
3899         /* we do this so indexes can be used */
3900         if (strcmp(opname,"~") == 0 ||
3901                 strcmp(opname,"~*") == 0)
3902         {
3903                 if (nodeTag(rexpr) == T_A_Const &&
3904                    ((A_Const *)rexpr)->val.type == T_String &&
3905                    ((A_Const *)rexpr)->val.val.str[0] == '^')
3906                 {
3907                         A_Const *n = (A_Const *)rexpr;
3908                         char *match_least = palloc(strlen(n->val.val.str)+2);
3909                         char *match_most = palloc(strlen(n->val.val.str)+2);
3910                         int pos, match_pos=0;
3911
3912                         /* skip leading ^ */
3913                         for (pos = 1; n->val.val.str[pos]; pos++)
3914                         {
3915                                 if (n->val.val.str[pos] == '.' ||
3916                                         n->val.val.str[pos] == '?' ||
3917                                         n->val.val.str[pos] == '*' ||
3918                                         n->val.val.str[pos] == '[' ||
3919                                         n->val.val.str[pos] == '$' ||
3920                                         (strcmp(opname,"~*") == 0 && isalpha(n->val.val.str[pos])))
3921                                 break;
3922                         if (n->val.val.str[pos] == '\\')
3923                                         pos++;
3924                                 match_least[match_pos] = n->val.val.str[pos];
3925                                 match_most[match_pos++] = n->val.val.str[pos];
3926                         }
3927
3928                         if (match_pos != 0)
3929                         {
3930                                 A_Const *least = makeNode(A_Const);
3931                                 A_Const *most = makeNode(A_Const);
3932
3933                                 /* make strings to be used in index use */
3934                                 match_least[match_pos] = '\0';
3935                                 match_most[match_pos] = '\377';
3936                                 match_most[match_pos+1] = '\0';
3937                                 least->val.type = T_String;
3938                                 least->val.val.str = match_least;
3939                                 most->val.type = T_String;
3940                                 most->val.val.str = match_most;
3941                                 result = makeA_Expr(AND, NULL,
3942                                                 makeA_Expr(OP, "~", lexpr, rexpr),
3943                                                 makeA_Expr(AND, NULL,
3944                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3945                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3946                         }
3947                 }
3948         }
3949         else if (strcmp(opname,"~~") == 0)
3950         {
3951                 if (nodeTag(rexpr) == T_A_Const &&
3952                    ((A_Const *)rexpr)->val.type == T_String)
3953                 {
3954                         A_Const *n = (A_Const *)rexpr;
3955                         char *match_least = palloc(strlen(n->val.val.str)+2);
3956                         char *match_most = palloc(strlen(n->val.val.str)+2);
3957                         int pos, match_pos=0;
3958
3959                         for (pos = 0; n->val.val.str[pos]; pos++)
3960                         {
3961                                 if ((n->val.val.str[pos] == '%' &&
3962                                          n->val.val.str[pos+1] != '%') ||
3963                                     (n->val.val.str[pos] == '_' &&
3964                                  n->val.val.str[pos+1] != '_'))
3965                                 break;
3966                         if (n->val.val.str[pos] == '%' ||
3967                                     n->val.val.str[pos] == '_' ||
3968                                     n->val.val.str[pos] == '\\')
3969                                         pos++;
3970                                 match_least[match_pos] = n->val.val.str[pos];
3971                                 match_most[match_pos++] = n->val.val.str[pos];
3972                         }
3973
3974                         if (match_pos != 0)
3975                         {
3976                                 A_Const *least = makeNode(A_Const);
3977                                 A_Const *most = makeNode(A_Const);
3978
3979                                 /* make strings to be used in index use */
3980                                 match_least[match_pos] = '\0';
3981                                 match_most[match_pos] = '\377';
3982                                 match_most[match_pos+1] = '\0';
3983                                 least->val.type = T_String;
3984                                 least->val.val.str = match_least;
3985                                 most->val.type = T_String;
3986                                 most->val.val.str = match_most;
3987                                 result = makeA_Expr(AND, NULL,
3988                                                 makeA_Expr(OP, "~~", lexpr, rexpr),
3989                                                 makeA_Expr(AND, NULL,
3990                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3991                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3992                         }
3993                 }
3994         }
3995
3996         if (result == NULL)
3997                 result = makeA_Expr(OP, opname, lexpr, rexpr);
3998         return result;
3999 } /* makeIndexable() */
4000
4001
4002 /* xlateSqlType()
4003  * Convert alternate type names to internal Postgres types.
4004  * Do not convert "float", since that is handled elsewhere
4005  *  for FLOAT(p) syntax.
4006  */
4007 static char *
4008 xlateSqlType(char *name)
4009 {
4010         if (!strcasecmp(name,"int")
4011          || !strcasecmp(name,"integer"))
4012                 return "int4";
4013         else if (!strcasecmp(name, "smallint"))
4014                 return "int2";
4015         else if (!strcasecmp(name, "real"))
4016                 return "float8";
4017         else if (!strcasecmp(name, "interval"))
4018                 return "timespan";
4019         else if (!strcasecmp(name, "boolean"))
4020                 return "bool";
4021         else
4022                 return name;
4023 } /* xlateSqlName() */
4024
4025
4026 void parser_init(Oid *typev, int nargs)
4027 {
4028         QueryIsRule = FALSE;
4029         saved_relname[0]= '\0';
4030         saved_In_Expr = NULL;
4031
4032         param_type_init(typev, nargs);
4033 }
4034
4035
4036 /* FlattenStringList()
4037  * Traverse list of string nodes and convert to a single string.
4038  * Used for reconstructing string form of complex expressions.
4039  *
4040  * Allocate at least one byte for terminator.
4041  */
4042 static char *
4043 FlattenStringList(List *list)
4044 {
4045         List *l;
4046         Value *v;
4047         char *s;
4048         char *sp;
4049         int nlist, len = 0;
4050
4051         nlist = length(list);
4052         l = list;
4053         while(l != NIL) {
4054                 v = (Value *)lfirst(l);
4055                 sp = v->val.str;
4056                 l = lnext(l);
4057                 len += strlen(sp);
4058         };
4059         len += nlist;
4060
4061         s = (char*) palloc(len+1);
4062         *s = '\0';
4063
4064         l = list;
4065         while(l != NIL) {
4066                 v = (Value *)lfirst(l);
4067                 sp = v->val.str;
4068                 l = lnext(l);
4069                 strcat(s,sp);
4070                 if (l != NIL) strcat(s," ");
4071         };
4072         *(s+len) = '\0';
4073
4074 #ifdef PARSEDEBUG
4075 printf( "flattened string is \"%s\"\n", s);
4076 #endif
4077
4078         return(s);
4079 } /* FlattenStringList() */
4080
4081
4082 /* makeConstantList()
4083  * Convert constant value node into string node.
4084  */
4085 static List *
4086 makeConstantList( A_Const *n)
4087 {
4088         char *defval = NULL;
4089         if (nodeTag(n) != T_A_Const) {
4090                 elog(ERROR,"Cannot handle non-constant parameter");
4091
4092         } else if (n->val.type == T_Float) {
4093                 defval = (char*) palloc(20+1);
4094                 sprintf( defval, "%g", n->val.val.dval);
4095
4096         } else if (n->val.type == T_Integer) {
4097                 defval = (char*) palloc(20+1);
4098                 sprintf( defval, "%ld", n->val.val.ival);
4099
4100         } else if (n->val.type == T_String) {
4101                 defval = (char*) palloc(strlen( ((A_Const *) n)->val.val.str) + 3);
4102                 strcpy( defval, "'");
4103                 strcat( defval, ((A_Const *) n)->val.val.str);
4104                 strcat( defval, "'");
4105
4106         } else {
4107                 elog(ERROR,"Internal error in makeConstantList(): cannot encode node");
4108         };
4109
4110 #ifdef PARSEDEBUG
4111 printf( "AexprConst argument is \"%s\"\n", defval);
4112 #endif
4113
4114         return( lcons( makeString(defval), NIL));
4115 } /* makeConstantList() */
4116
4117
4118 /* fmtId()
4119  * Check input string for non-lowercase/non-numeric characters.
4120  * Returns either input string or input surrounded by double quotes.
4121  */
4122 static char *
4123 fmtId(char *rawid)
4124 {
4125         static char *cp;
4126
4127         for (cp = rawid; *cp != '\0'; cp++)
4128                 if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;
4129
4130         if (*cp != '\0') {
4131                 cp = palloc(strlen(rawid)+1);
4132                 strcpy(cp,"\"");
4133                 strcat(cp,rawid);
4134                 strcat(cp,"\"");
4135         } else {
4136                 cp = rawid;
4137         };
4138
4139 #ifdef PARSEDEBUG
4140 printf("fmtId- %sconvert %s to %s\n", ((cp == rawid)? "do not ": ""), rawid, cp);
4141 #endif
4142
4143         return(cp);
4144 }
4145
4146 /*
4147  * param_type_init()
4148  *
4149  * keep enough information around fill out the type of param nodes
4150  * used in postquel functions
4151  */
4152 static void
4153 param_type_init(Oid *typev, int nargs)
4154 {
4155         pfunc_num_args = nargs;
4156         param_type_info = typev;
4157 }
4158
4159 Oid param_type(int t)
4160 {
4161         if ((t > pfunc_num_args) || (t == 0))
4162                 return InvalidOid;
4163         return param_type_info[t - 1];
4164 }