?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make to_timestamp and friends skip leading spaces before an integer field,
[PostgreSQL.git] / src / backend / parser / gram.y
blobac17b93bf6863115a54496fcdf9bb2a6e7c15a20
1 %{
2
3 /*#define YYDEBUG 1*/
4 /*-------------------------------------------------------------------------
5 *
6 * gram.y
7 * POSTGRES SQL YACC rules/actions
8 *
9 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
10 * Portions Copyright (c) 1994, Regents of the University of California
11 *
12 *
13 * IDENTIFICATION
14 * $PostgreSQL$
15 *
16 * HISTORY
17 * AUTHOR DATE MAJOR EVENT
18 * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion
19 * Andrew Yu Oct, 1994 lispy code conversion
20 *
21 * NOTES
22 * CAPITALS are used to represent terminal symbols.
23 * non-capitals are used to represent non-terminals.
24 * SQL92-specific syntax is separated from plain SQL/Postgres syntax
25 * to help isolate the non-extensible portions of the parser.
26 *
27 * In general, nothing in this file should initiate database accesses
28 * nor depend on changeable state (such as SET variables). If you do
29 * database accesses, your code will fail when we have aborted the
30 * current transaction and are just parsing commands to find the next
31 * ROLLBACK or COMMIT. If you make use of SET variables, then you
32 * will do the wrong thing in multi-query strings like this:
33 * SET SQL_inheritance TO off; SELECT * FROM foo;
34 * because the entire string is parsed by gram.y before the SET gets
35 * executed. Anything that depends on the database or changeable state
36 * should be handled during parse analysis so that it happens at the
37 * right time not the wrong time. The handling of SQL_inheritance is
38 * a good example.
39 *
40 * WARNINGS
41 * If you use a list, make sure the datum is a node so that the printing
42 * routines work.
43 *
44 * Sometimes we assign constants to makeStrings. Make sure we don't free
45 * those.
46 *
47 *-------------------------------------------------------------------------
48 */
49 #include "postgres.h"
50
51 #include <ctype.h>
52 #include <limits.h>
53
54 #include "catalog/index.h"
55 #include "catalog/namespace.h"
56 #include "catalog/pg_trigger.h"
57 #include "commands/defrem.h"
58 #include "nodes/makefuncs.h"
59 #include "nodes/nodeFuncs.h"
60 #include "parser/gramparse.h"
61 #include "storage/lmgr.h"
62 #include "utils/date.h"
63 #include "utils/datetime.h"
64 #include "utils/numeric.h"
65 #include "utils/xml.h"
66
67
68 /* Location tracking support --- simpler than bison's default */
69 #define YYLLOC_DEFAULT(Current, Rhs, N) \
70 do { \
71 if (N) \
72 (Current) = (Rhs)[1]; \
73 else \
74 (Current) = (Rhs)[0]; \
75 } while (0)
76
77 /*
78 * The %name-prefix option below will make bison call base_yylex, but we
79 * really want it to call filtered_base_yylex (see parser.c).
80 */
81 #define base_yylex filtered_base_yylex
82
83 /*
84 * Bison doesn't allocate anything that needs to live across parser calls,
85 * so we can easily have it use palloc instead of malloc. This prevents
86 * memory leaks if we error out during parsing. Note this only works with
87 * bison >= 2.0. However, in bison 1.875 the default is to use alloca()
88 * if possible, so there's not really much problem anyhow, at least if
89 * you're building with gcc.
90 */
91 #define YYMALLOC palloc
92 #define YYFREE pfree
93
94 extern List *parsetree; /* final parse result is delivered here */
95
96 static bool QueryIsRule = FALSE;
97
98 /* Private struct for the result of privilege_target production */
99 typedef struct PrivTarget
100 {
101 GrantObjectType objtype;
102 List *objs;
103 } PrivTarget;
104
105 /*
106 * If you need access to certain yacc-generated variables and find that
107 * they're static by default, uncomment the next line. (this is not a
108 * problem, yet.)
109 */
110 /*#define __YYSCLASS*/
111
112 static Node *makeColumnRef(char *colname, List *indirection, int location);
113 static Node *makeTypeCast(Node *arg, TypeName *typename, int location);
114 static Node *makeStringConst(char *str, int location);
115 static Node *makeStringConstCast(char *str, int location, TypeName *typename);
116 static Node *makeIntConst(int val, int location);
117 static Node *makeFloatConst(char *str, int location);
118 static Node *makeBitStringConst(char *str, int location);
119 static Node *makeNullAConst(int location);
120 static Node *makeAConst(Value *v, int location);
121 static Node *makeBoolAConst(bool state, int location);
122 static FuncCall *makeOverlaps(List *largs, List *rargs, int location);
123 static void check_qualified_name(List *names);
124 static List *check_func_name(List *names);
125 static List *check_indirection(List *indirection);
126 static List *extractArgTypes(List *parameters);
127 static SelectStmt *findLeftmostSelect(SelectStmt *node);
128 static void insertSelectOptions(SelectStmt *stmt,
129 List *sortClause, List *lockingClause,
130 Node *limitOffset, Node *limitCount,
131 WithClause *withClause);
132 static Node *makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg);
133 static Node *doNegate(Node *n, int location);
134 static void doNegateFloat(Value *v);
135 static Node *makeAArrayExpr(List *elements, int location);
136 static Node *makeXmlExpr(XmlExprOp op, char *name, List *named_args,
137 List *args, int location);
138 static List *mergeTableFuncParameters(List *func_args, List *columns);
139 static TypeName *TableFuncTypeName(List *columns);
140
141 %}
142
143 %expect 0
144 %name-prefix="base_yy"
145 %locations
146
147 %union
148 {
149 int ival;
150 char chr;
151 char *str;
152 const char *keyword;
153 bool boolean;
154 JoinType jtype;
155 DropBehavior dbehavior;
156 OnCommitAction oncommit;
157 List *list;
158 Node *node;
159 Value *value;
160 ObjectType objtype;
161
162 TypeName *typnam;
163 FunctionParameter *fun_param;
164 FunctionParameterMode fun_param_mode;
165 FuncWithArgs *funwithargs;
166 DefElem *defelt;
167 SortBy *sortby;
168 WindowDef *windef;
169 JoinExpr *jexpr;
170 IndexElem *ielem;
171 Alias *alias;
172 RangeVar *range;
173 IntoClause *into;
174 WithClause *with;
175 A_Indices *aind;
176 ResTarget *target;
177 struct PrivTarget *privtarget;
178 AccessPriv *accesspriv;
179
180 InsertStmt *istmt;
181 VariableSetStmt *vsetstmt;
182 }
183
184 %type <node> stmt schema_stmt
185 AlterDatabaseStmt AlterDatabaseSetStmt AlterDomainStmt AlterFdwStmt
186 AlterForeignServerStmt AlterGroupStmt
187 AlterObjectSchemaStmt AlterOwnerStmt AlterSeqStmt AlterTableStmt
188 AlterUserStmt AlterUserMappingStmt AlterUserSetStmt AlterRoleStmt AlterRoleSetStmt
189 AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
190 ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
191 CreateDomainStmt CreateGroupStmt CreateOpClassStmt
192 CreateOpFamilyStmt AlterOpFamilyStmt CreatePLangStmt
193 CreateSchemaStmt CreateSeqStmt CreateStmt CreateTableSpaceStmt
194 CreateFdwStmt CreateForeignServerStmt CreateAssertStmt CreateTrigStmt
195 CreateUserStmt CreateUserMappingStmt CreateRoleStmt
196 CreatedbStmt DeclareCursorStmt DefineStmt DeleteStmt DiscardStmt
197 DropGroupStmt DropOpClassStmt DropOpFamilyStmt DropPLangStmt DropStmt
198 DropAssertStmt DropTrigStmt DropRuleStmt DropCastStmt DropRoleStmt
199 DropUserStmt DropdbStmt DropTableSpaceStmt DropFdwStmt
200 DropForeignServerStmt DropUserMappingStmt ExplainStmt FetchStmt
201 GrantStmt GrantRoleStmt IndexStmt InsertStmt ListenStmt LoadStmt
202 LockStmt NotifyStmt ExplainableStmt PreparableStmt
203 CreateFunctionStmt AlterFunctionStmt ReindexStmt RemoveAggrStmt
204 RemoveFuncStmt RemoveOperStmt RenameStmt RevokeStmt RevokeRoleStmt
205 RuleActionStmt RuleActionStmtOrEmpty RuleStmt
206 SelectStmt TransactionStmt TruncateStmt
207 UnlistenStmt UpdateStmt VacuumStmt
208 VariableResetStmt VariableSetStmt VariableShowStmt
209 ViewStmt CheckPointStmt CreateConversionStmt
210 DeallocateStmt PrepareStmt ExecuteStmt
211 DropOwnedStmt ReassignOwnedStmt
212 AlterTSConfigurationStmt AlterTSDictionaryStmt
213
214 %type <node> select_no_parens select_with_parens select_clause
215 simple_select values_clause
216
217 %type <node> alter_column_default opclass_item opclass_drop alter_using
218 %type <ival> add_drop opt_asc_desc opt_nulls_order
219
220 %type <node> alter_table_cmd
221 %type <list> alter_table_cmds
222
223 %type <dbehavior> opt_drop_behavior
224
225 %type <list> createdb_opt_list alterdb_opt_list copy_opt_list
226 transaction_mode_list
227 %type <defelt> createdb_opt_item alterdb_opt_item copy_opt_item
228 transaction_mode_item
229
230 %type <ival> opt_lock lock_type cast_context
231 %type <boolean> opt_force opt_or_replace
232 opt_grant_grant_option opt_grant_admin_option
233 opt_nowait opt_if_exists opt_with_data
234
235 %type <list> OptRoleList
236 %type <defelt> OptRoleElem
237
238 %type <str> opt_type
239 %type <str> foreign_server_version opt_foreign_server_version
240 %type <str> auth_ident
241
242 %type <str> OptSchemaName
243 %type <list> OptSchemaEltList
244
245 %type <boolean> TriggerActionTime TriggerForSpec opt_trusted opt_restart_seqs
246 %type <str> opt_lancompiler
247
248 %type <ival> TriggerEvents TriggerOneEvent
249 %type <value> TriggerFuncArg
250
251 %type <str> relation_name copy_file_name
252 database_name access_method_clause access_method attr_name
253 index_name name file_name cluster_index_specification
254
255 %type <list> func_name handler_name qual_Op qual_all_Op subquery_Op
256 opt_class opt_validator validator_clause
257
258 %type <range> qualified_name OptConstrFromTable
259
260 %type <str> all_Op MathOp SpecialRuleRelation
261
262 %type <str> iso_level opt_encoding
263 %type <node> grantee
264 %type <list> grantee_list
265 %type <accesspriv> privilege
266 %type <list> privileges privilege_list
267 %type <privtarget> privilege_target
268 %type <funwithargs> function_with_argtypes
269 %type <list> function_with_argtypes_list
270
271 %type <list> stmtblock stmtmulti
272 OptTableElementList TableElementList OptInherit definition
273 reloptions opt_reloptions
274 OptWith opt_distinct opt_definition func_args func_args_list
275 func_args_with_defaults func_args_with_defaults_list
276 func_as createfunc_opt_list alterfunc_opt_list
277 aggr_args old_aggr_definition old_aggr_list
278 oper_argtypes RuleActionList RuleActionMulti
279 opt_column_list columnList opt_name_list
280 sort_clause opt_sort_clause sortby_list index_params
281 name_list from_clause from_list opt_array_bounds
282 qualified_name_list any_name any_name_list
283 any_operator expr_list attrs
284 target_list insert_column_list set_target_list
285 set_clause_list set_clause multiple_set_clause
286 ctext_expr_list ctext_row def_list indirection opt_indirection
287 reloption_list group_clause TriggerFuncArgs select_limit
288 opt_select_limit opclass_item_list opclass_drop_list
289 opt_opfamily transaction_mode_list_or_empty
290 TableFuncElementList opt_type_modifiers
291 prep_type_clause
292 execute_param_clause using_clause returning_clause
293 enum_val_list table_func_column_list
294 create_generic_options alter_generic_options
295 relation_expr_list
296
297 %type <range> OptTempTableName
298 %type <into> into_clause create_as_target
299
300 %type <defelt> createfunc_opt_item common_func_opt_item
301 %type <fun_param> func_arg func_arg_with_default table_func_column
302 %type <fun_param_mode> arg_class
303 %type <typnam> func_return func_type
304
305 %type <boolean> TriggerForType OptTemp
306 %type <oncommit> OnCommitOption
307
308 %type <node> for_locking_item
309 %type <list> for_locking_clause opt_for_locking_clause for_locking_items
310 %type <list> locked_rels_list
311 %type <boolean> opt_all
312
313 %type <node> join_outer join_qual
314 %type <jtype> join_type
315
316 %type <list> extract_list overlay_list position_list
317 %type <list> substr_list trim_list
318 %type <list> opt_interval interval_second
319 %type <node> overlay_placing substr_from substr_for
320
321 %type <boolean> opt_instead opt_analyze
322 %type <boolean> index_opt_unique opt_verbose opt_full
323 %type <boolean> opt_freeze opt_default opt_recheck
324 %type <defelt> opt_binary opt_oids copy_delimiter
325
326 %type <boolean> copy_from
327
328 %type <ival> opt_column event cursor_options opt_hold opt_set_data
329 %type <objtype> reindex_type drop_type comment_type
330
331 %type <node> fetch_direction select_limit_value select_offset_value
332 select_offset_value2 opt_select_fetch_first_value
333 %type <ival> row_or_rows first_or_next
334
335 %type <list> OptSeqOptList SeqOptList
336 %type <defelt> SeqOptElem
337
338 %type <istmt> insert_rest
339
340 %type <vsetstmt> set_rest SetResetClause
341
342 %type <node> TableElement ConstraintElem TableFuncElement
343 %type <node> columnDef
344 %type <defelt> def_elem reloption_elem old_aggr_elem
345 %type <node> def_arg columnElem where_clause where_or_current_clause
346 a_expr b_expr c_expr func_expr AexprConst indirection_el
347 columnref in_expr having_clause func_table array_expr
348 %type <list> row type_list array_expr_list
349 %type <node> case_expr case_arg when_clause case_default
350 %type <list> when_clause_list
351 %type <ival> sub_type
352 %type <list> OptCreateAs CreateAsList
353 %type <node> CreateAsElement ctext_expr
354 %type <value> NumericOnly
355 %type <alias> alias_clause
356 %type <sortby> sortby
357 %type <ielem> index_elem
358 %type <node> table_ref
359 %type <jexpr> joined_table
360 %type <range> relation_expr
361 %type <range> relation_expr_opt_alias
362 %type <target> target_el single_set_clause set_target insert_column_item
363
364 %type <str> generic_option_name
365 %type <node> generic_option_arg
366 %type <defelt> generic_option_elem alter_generic_option_elem
367 %type <list> generic_option_list alter_generic_option_list
368
369 %type <typnam> Typename SimpleTypename ConstTypename
370 GenericType Numeric opt_float
371 Character ConstCharacter
372 CharacterWithLength CharacterWithoutLength
373 ConstDatetime ConstInterval
374 Bit ConstBit BitWithLength BitWithoutLength
375 %type <str> character
376 %type <str> extract_arg
377 %type <str> opt_charset
378 %type <boolean> opt_varying opt_timezone
379
380 %type <ival> Iconst SignedIconst
381 %type <str> Sconst comment_text
382 %type <str> RoleId opt_granted_by opt_boolean ColId_or_Sconst
383 %type <list> var_list
384 %type <str> ColId ColLabel var_name type_function_name param_name
385 %type <node> var_value zone_value
386
387 %type <keyword> unreserved_keyword type_func_name_keyword
388 %type <keyword> col_name_keyword reserved_keyword
389
390 %type <node> TableConstraint TableLikeClause
391 %type <list> TableLikeOptionList
392 %type <ival> TableLikeOption
393 %type <list> ColQualList
394 %type <node> ColConstraint ColConstraintElem ConstraintAttr
395 %type <ival> key_actions key_delete key_match key_update key_action
396 %type <ival> ConstraintAttributeSpec ConstraintDeferrabilitySpec
397 ConstraintTimeSpec
398
399 %type <list> constraints_set_list
400 %type <boolean> constraints_set_mode
401 %type <str> OptTableSpace OptConsTableSpace OptTableSpaceOwner
402 %type <list> opt_check_option
403
404 %type <target> xml_attribute_el
405 %type <list> xml_attribute_list xml_attributes
406 %type <node> xml_root_version opt_xml_root_standalone
407 %type <ival> document_or_content
408 %type <boolean> xml_whitespace_option
409
410 %type <node> common_table_expr
411 %type <with> with_clause
412 %type <list> cte_list
413
414 %type <list> window_clause window_definition_list opt_partition_clause
415 %type <windef> window_definition over_clause window_specification
416 %type <str> opt_existing_window_name
417 %type <ival> opt_frame_clause frame_extent frame_bound
418
419
420 /*
421 * If you make any token changes, update the keyword table in
422 * src/include/parser/kwlist.h and add new keywords to the appropriate one of
423 * the reserved-or-not-so-reserved keyword lists, below; search
424 * this file for "Name classification hierarchy".
425 */
426
427 /* ordinary key words in alphabetical order */
428 %token <keyword> ABORT_P ABSOLUTE_P ACCESS ACTION ADD_P ADMIN AFTER
429 AGGREGATE ALL ALSO ALTER ALWAYS ANALYSE ANALYZE AND ANY ARRAY AS ASC
430 ASSERTION ASSIGNMENT ASYMMETRIC AT AUTHORIZATION
431
432 BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
433 BOOLEAN_P BOTH BY
434
435 CACHE CALLED CASCADE CASCADED CASE CAST CATALOG_P CHAIN CHAR_P
436 CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
437 CLUSTER COALESCE COLLATE COLUMN COMMENT COMMIT
438 COMMITTED CONCURRENTLY CONFIGURATION CONNECTION CONSTRAINT CONSTRAINTS
439 CONTENT_P CONTINUE_P CONVERSION_P COPY COST CREATE CREATEDB
440 CREATEROLE CREATEUSER CROSS CSV CURRENT_P
441 CURRENT_CATALOG CURRENT_DATE CURRENT_ROLE CURRENT_SCHEMA
442 CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
443
444 DATA_P DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
445 DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS DESC
446 DICTIONARY DISABLE_P DISCARD DISTINCT DO DOCUMENT_P DOMAIN_P DOUBLE_P DROP
447
448 EACH ELSE ENABLE_P ENCODING ENCRYPTED END_P ENUM_P ESCAPE EXCEPT
449 EXCLUDING EXCLUSIVE EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
450
451 FALSE_P FAMILY FETCH FIRST_P FLOAT_P FOLLOWING FOR FORCE FOREIGN FORWARD
452 FREEZE FROM FULL FUNCTION
453
454 GLOBAL GRANT GRANTED GREATEST GROUP_P
455
456 HANDLER HAVING HEADER_P HOLD HOUR_P
457
458 IDENTITY_P IF_P ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P
459 INCLUDING INCREMENT INDEX INDEXES INHERIT INHERITS INITIALLY
460 INNER_P INOUT INPUT_P INSENSITIVE INSERT INSTEAD INT_P INTEGER
461 INTERSECT INTERVAL INTO INVOKER IS ISNULL ISOLATION
462
463 JOIN
464
465 KEY
466
467 LANCOMPILER LANGUAGE LARGE_P LAST_P LC_COLLATE_P LC_CTYPE_P LEADING
468 LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL LOCALTIME LOCALTIMESTAMP
469 LOCATION LOCK_P LOGIN_P
470
471 MAPPING MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
472
473 NAME_P NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NOCREATEDB
474 NOCREATEROLE NOCREATEUSER NOINHERIT NOLOGIN_P NONE NOSUPERUSER
475 NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NULLS_P NUMERIC
476
477 OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OPTIONS OR
478 ORDER OUT_P OUTER_P OVER OVERLAPS OVERLAY OWNED OWNER
479
480 PARSER PARTIAL PARTITION PASSWORD PLACING PLANS POSITION
481 PRECEDING PRECISION PRESERVE PREPARE PREPARED PRIMARY
482 PRIOR PRIVILEGES PROCEDURAL PROCEDURE
483
484 QUOTE
485
486 RANGE READ REAL REASSIGN RECHECK RECURSIVE REFERENCES REINDEX
487 RELATIVE_P RELEASE RENAME REPEATABLE REPLACE REPLICA RESET RESTART
488 RESTRICT RETURNING RETURNS REVOKE RIGHT ROLE ROLLBACK ROW ROWS RULE
489
490 SAVEPOINT SCHEMA SCROLL SEARCH SECOND_P SECURITY SELECT SEQUENCE
491 SERIALIZABLE SERVER SESSION SESSION_USER SET SETOF SHARE
492 SHOW SIMILAR SIMPLE SMALLINT SOME STABLE STANDALONE_P START STATEMENT
493 STATISTICS STDIN STDOUT STORAGE STRICT_P STRIP_P SUBSTRING SUPERUSER_P
494 SYMMETRIC SYSID SYSTEM_P
495
496 TABLE TABLESPACE TEMP TEMPLATE TEMPORARY TEXT_P THEN TIME TIMESTAMP
497 TO TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P
498 TRUNCATE TRUSTED TYPE_P
499
500 UNBOUNDED UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
501 UPDATE USER USING
502
503 VACUUM VALID VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
504 VERBOSE VERSION_P VIEW VOLATILE
505
506 WHEN WHERE WHITESPACE_P WINDOW WITH WITHOUT WORK WRAPPER WRITE
507
508 XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLFOREST XMLPARSE
509 XMLPI XMLROOT XMLSERIALIZE
510
511 YEAR_P YES_P
512
513 ZONE
514
515 /* The grammar thinks these are keywords, but they are not in the kwlist.h
516 * list and so can never be entered directly. The filter in parser.c
517 * creates these tokens when required.
518 */
519 %token NULLS_FIRST NULLS_LAST WITH_TIME
520
521 /* Special token types, not actually keywords - see the "lex" file */
522 %token <str> IDENT FCONST SCONST BCONST XCONST Op
523 %token <ival> ICONST PARAM
524
525 /* precedence: lowest to highest */
526 %nonassoc SET /* see relation_expr_opt_alias */
527 %left UNION EXCEPT
528 %left INTERSECT
529 %left OR
530 %left AND
531 %right NOT
532 %right '='
533 %nonassoc '<' '>'
534 %nonassoc LIKE ILIKE SIMILAR
535 %nonassoc ESCAPE
536 %nonassoc OVERLAPS
537 %nonassoc BETWEEN
538 %nonassoc IN_P
539 %left POSTFIXOP /* dummy for postfix Op rules */
540 /*
541 * To support target_el without AS, we must give IDENT an explicit priority
542 * between POSTFIXOP and Op. We can safely assign the same priority to
543 * various unreserved keywords as needed to resolve ambiguities (this can't
544 * have any bad effects since obviously the keywords will still behave the
545 * same as if they weren't keywords). We need to do this for PARTITION,
546 * RANGE, ROWS to support opt_existing_window_name; and for RANGE, ROWS
547 * so that they can follow a_expr without creating
548 * postfix-operator problems.
549 */
550 %nonassoc IDENT PARTITION RANGE ROWS
551 %left Op OPERATOR /* multi-character ops and user-defined operators */
552 %nonassoc NOTNULL
553 %nonassoc ISNULL
554 %nonassoc IS NULL_P TRUE_P FALSE_P UNKNOWN /* sets precedence for IS NULL, etc */
555 %left '+' '-'
556 %left '*' '/' '%'
557 %left '^'
558 /* Unary Operators */
559 %left AT ZONE /* sets precedence for AT TIME ZONE */
560 %right UMINUS
561 %left '[' ']'
562 %left '(' ')'
563 %left TYPECAST
564 %left '.'
565 /*
566 * These might seem to be low-precedence, but actually they are not part
567 * of the arithmetic hierarchy at all in their use as JOIN operators.
568 * We make them high-precedence to support their use as function names.
569 * They wouldn't be given a precedence at all, were it not that we need
570 * left-associativity among the JOIN rules themselves.
571 */
572 %left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
573 /* kluge to keep xml_whitespace_option from causing shift/reduce conflicts */
574 %right PRESERVE STRIP_P
575 %%
576
577 /*
578 * Handle comment-only lines, and ;; SELECT * FROM pg_class ;;;
579 * psql already handles such cases, but other interfaces don't.
580 * bjm 1999/10/05
581 */
582 stmtblock: stmtmulti { parsetree = $1; }
583 ;
584
585 /* the thrashing around here is to discard "empty" statements... */
586 stmtmulti: stmtmulti ';' stmt
587 { if ($3 != NULL)
588 $$ = lappend($1, $3);
589 else
590 $$ = $1;
591 }
592 | stmt
593 { if ($1 != NULL)
594 $$ = list_make1($1);
595 else
596 $$ = NIL;
597 }
598 ;
599
600 stmt :
601 AlterDatabaseStmt
602 | AlterDatabaseSetStmt
603 | AlterDomainStmt
604 | AlterFdwStmt
605 | AlterForeignServerStmt
606 | AlterFunctionStmt
607 | AlterGroupStmt
608 | AlterObjectSchemaStmt
609 | AlterOwnerStmt
610 | AlterSeqStmt
611 | AlterTableStmt
612 | AlterRoleSetStmt
613 | AlterRoleStmt
614 | AlterTSConfigurationStmt
615 | AlterTSDictionaryStmt
616 | AlterUserMappingStmt
617 | AlterUserSetStmt
618 | AlterUserStmt
619 | AnalyzeStmt
620 | CheckPointStmt
621 | ClosePortalStmt
622 | ClusterStmt
623 | CommentStmt
624 | ConstraintsSetStmt
625 | CopyStmt
626 | CreateAsStmt
627 | CreateAssertStmt
628 | CreateCastStmt
629 | CreateConversionStmt
630 | CreateDomainStmt
631 | CreateFdwStmt
632 | CreateForeignServerStmt
633 | CreateFunctionStmt
634 | CreateGroupStmt
635 | CreateOpClassStmt
636 | CreateOpFamilyStmt
637 | AlterOpFamilyStmt
638 | CreatePLangStmt
639 | CreateSchemaStmt
640 | CreateSeqStmt
641 | CreateStmt
642 | CreateTableSpaceStmt
643 | CreateTrigStmt
644 | CreateRoleStmt
645 | CreateUserStmt
646 | CreateUserMappingStmt
647 | CreatedbStmt
648 | DeallocateStmt
649 | DeclareCursorStmt
650 | DefineStmt
651 | DeleteStmt
652 | DiscardStmt
653 | DropAssertStmt
654 | DropCastStmt
655 | DropFdwStmt
656 | DropForeignServerStmt
657 | DropGroupStmt
658 | DropOpClassStmt
659 | DropOpFamilyStmt
660 | DropOwnedStmt
661 | DropPLangStmt
662 | DropRuleStmt
663 | DropStmt
664 | DropTableSpaceStmt
665 | DropTrigStmt
666 | DropRoleStmt
667 | DropUserStmt
668 | DropUserMappingStmt
669 | DropdbStmt
670 | ExecuteStmt
671 | ExplainStmt
672 | FetchStmt
673 | GrantStmt
674 | GrantRoleStmt
675 | IndexStmt
676 | InsertStmt
677 | ListenStmt
678 | LoadStmt
679 | LockStmt
680 | NotifyStmt
681 | PrepareStmt
682 | ReassignOwnedStmt
683 | ReindexStmt
684 | RemoveAggrStmt
685 | RemoveFuncStmt
686 | RemoveOperStmt
687 | RenameStmt
688 | RevokeStmt
689 | RevokeRoleStmt
690 | RuleStmt
691 | SelectStmt
692 | TransactionStmt
693 | TruncateStmt
694 | UnlistenStmt
695 | UpdateStmt
696 | VacuumStmt
697 | VariableResetStmt
698 | VariableSetStmt
699 | VariableShowStmt
700 | ViewStmt
701 | /*EMPTY*/
702 { $$ = NULL; }
703 ;
704
705 /*****************************************************************************
706 *
707 * Create a new Postgres DBMS role
708 *
709 *****************************************************************************/
710
711 CreateRoleStmt:
712 CREATE ROLE RoleId opt_with OptRoleList
713 {
714 CreateRoleStmt *n = makeNode(CreateRoleStmt);
715 n->stmt_type = ROLESTMT_ROLE;
716 n->role = $3;
717 n->options = $5;
718 $$ = (Node *)n;
719 }
720 ;
721
722
723 opt_with: WITH {}
724 | /*EMPTY*/ {}
725 ;
726
727 /*
728 * Options for CREATE ROLE and ALTER ROLE (also used by CREATE/ALTER USER
729 * for backwards compatibility). Note: the only option required by SQL99
730 * is "WITH ADMIN name".
731 */
732 OptRoleList:
733 OptRoleList OptRoleElem { $$ = lappend($1, $2); }
734 | /* EMPTY */ { $$ = NIL; }
735 ;
736
737 OptRoleElem:
738 PASSWORD Sconst
739 {
740 $$ = makeDefElem("password",
741 (Node *)makeString($2));
742 }
743 | PASSWORD NULL_P
744 {
745 $$ = makeDefElem("password", NULL);
746 }
747 | ENCRYPTED PASSWORD Sconst
748 {
749 $$ = makeDefElem("encryptedPassword",
750 (Node *)makeString($3));
751 }
752 | UNENCRYPTED PASSWORD Sconst
753 {
754 $$ = makeDefElem("unencryptedPassword",
755 (Node *)makeString($3));
756 }
757 | SUPERUSER_P
758 {
759 $$ = makeDefElem("superuser", (Node *)makeInteger(TRUE));
760 }
761 | NOSUPERUSER
762 {
763 $$ = makeDefElem("superuser", (Node *)makeInteger(FALSE));
764 }
765 | INHERIT
766 {
767 $$ = makeDefElem("inherit", (Node *)makeInteger(TRUE));
768 }
769 | NOINHERIT
770 {
771 $$ = makeDefElem("inherit", (Node *)makeInteger(FALSE));
772 }
773 | CREATEDB
774 {
775 $$ = makeDefElem("createdb", (Node *)makeInteger(TRUE));
776 }
777 | NOCREATEDB
778 {
779 $$ = makeDefElem("createdb", (Node *)makeInteger(FALSE));
780 }
781 | CREATEROLE
782 {
783 $$ = makeDefElem("createrole", (Node *)makeInteger(TRUE));
784 }
785 | NOCREATEROLE
786 {
787 $$ = makeDefElem("createrole", (Node *)makeInteger(FALSE));
788 }
789 | CREATEUSER
790 {
791 /* For backwards compatibility, synonym for SUPERUSER */
792 $$ = makeDefElem("superuser", (Node *)makeInteger(TRUE));
793 }
794 | NOCREATEUSER
795 {
796 $$ = makeDefElem("superuser", (Node *)makeInteger(FALSE));
797 }
798 | LOGIN_P
799 {
800 $$ = makeDefElem("canlogin", (Node *)makeInteger(TRUE));
801 }
802 | NOLOGIN_P
803 {
804 $$ = makeDefElem("canlogin", (Node *)makeInteger(FALSE));
805 }
806 | CONNECTION LIMIT SignedIconst
807 {
808 $$ = makeDefElem("connectionlimit", (Node *)makeInteger($3));
809 }
810 | VALID UNTIL Sconst
811 {
812 $$ = makeDefElem("validUntil", (Node *)makeString($3));
813 }
814 /* Supported but not documented for roles, for use by ALTER GROUP. */
815 | USER name_list
816 {
817 $$ = makeDefElem("rolemembers", (Node *)$2);
818 }
819 /* The following are not supported by ALTER ROLE/USER/GROUP */
820 | SYSID Iconst
821 {
822 $$ = makeDefElem("sysid", (Node *)makeInteger($2));
823 }
824 | ADMIN name_list
825 {
826 $$ = makeDefElem("adminmembers", (Node *)$2);
827 }
828 | ROLE name_list
829 {
830 $$ = makeDefElem("rolemembers", (Node *)$2);
831 }
832 | IN_P ROLE name_list
833 {
834 $$ = makeDefElem("addroleto", (Node *)$3);
835 }
836 | IN_P GROUP_P name_list
837 {
838 $$ = makeDefElem("addroleto", (Node *)$3);
839 }
840 ;
841
842
843 /*****************************************************************************
844 *
845 * Create a new Postgres DBMS user (role with implied login ability)
846 *
847 *****************************************************************************/
848
849 CreateUserStmt:
850 CREATE USER RoleId opt_with OptRoleList
851 {
852 CreateRoleStmt *n = makeNode(CreateRoleStmt);
853 n->stmt_type = ROLESTMT_USER;
854 n->role = $3;
855 n->options = $5;
856 $$ = (Node *)n;
857 }
858 ;
859
860
861 /*****************************************************************************
862 *
863 * Alter a postgresql DBMS role
864 *
865 *****************************************************************************/
866
867 AlterRoleStmt:
868 ALTER ROLE RoleId opt_with OptRoleList
869 {
870 AlterRoleStmt *n = makeNode(AlterRoleStmt);
871 n->role = $3;
872 n->action = +1; /* add, if there are members */
873 n->options = $5;
874 $$ = (Node *)n;
875 }
876 ;
877
878 AlterRoleSetStmt:
879 ALTER ROLE RoleId SetResetClause
880 {
881 AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
882 n->role = $3;
883 n->setstmt = $4;
884 $$ = (Node *)n;
885 }
886 ;
887
888
889 /*****************************************************************************
890 *
891 * Alter a postgresql DBMS user
892 *
893 *****************************************************************************/
894
895 AlterUserStmt:
896 ALTER USER RoleId opt_with OptRoleList
897 {
898 AlterRoleStmt *n = makeNode(AlterRoleStmt);
899 n->role = $3;
900 n->action = +1; /* add, if there are members */
901 n->options = $5;
902 $$ = (Node *)n;
903 }
904 ;
905
906
907 AlterUserSetStmt:
908 ALTER USER RoleId SetResetClause
909 {
910 AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt);
911 n->role = $3;
912 n->setstmt = $4;
913 $$ = (Node *)n;
914 }
915 ;
916
917
918 /*****************************************************************************
919 *
920 * Drop a postgresql DBMS role
921 *
922 * XXX Ideally this would have CASCADE/RESTRICT options, but since a role
923 * might own objects in multiple databases, there is presently no way to
924 * implement either cascading or restricting. Caveat DBA.
925 *****************************************************************************/
926
927 DropRoleStmt:
928 DROP ROLE name_list
929 {
930 DropRoleStmt *n = makeNode(DropRoleStmt);
931 n->missing_ok = FALSE;
932 n->roles = $3;
933 $$ = (Node *)n;
934 }
935 | DROP ROLE IF_P EXISTS name_list
936 {
937 DropRoleStmt *n = makeNode(DropRoleStmt);
938 n->missing_ok = TRUE;
939 n->roles = $5;
940 $$ = (Node *)n;
941 }
942 ;
943
944 /*****************************************************************************
945 *
946 * Drop a postgresql DBMS user
947 *
948 * XXX Ideally this would have CASCADE/RESTRICT options, but since a user
949 * might own objects in multiple databases, there is presently no way to
950 * implement either cascading or restricting. Caveat DBA.
951 *****************************************************************************/
952
953 DropUserStmt:
954 DROP USER name_list
955 {
956 DropRoleStmt *n = makeNode(DropRoleStmt);
957 n->missing_ok = FALSE;
958 n->roles = $3;
959 $$ = (Node *)n;
960 }
961 | DROP USER IF_P EXISTS name_list
962 {
963 DropRoleStmt *n = makeNode(DropRoleStmt);
964 n->roles = $5;
965 n->missing_ok = TRUE;
966 $$ = (Node *)n;
967 }
968 ;
969
970
971 /*****************************************************************************
972 *
973 * Create a postgresql group (role without login ability)
974 *
975 *****************************************************************************/
976
977 CreateGroupStmt:
978 CREATE GROUP_P RoleId opt_with OptRoleList
979 {
980 CreateRoleStmt *n = makeNode(CreateRoleStmt);
981 n->stmt_type = ROLESTMT_GROUP;
982 n->role = $3;
983 n->options = $5;
984 $$ = (Node *)n;
985 }
986 ;
987
988
989 /*****************************************************************************
990 *
991 * Alter a postgresql group
992 *
993 *****************************************************************************/
994
995 AlterGroupStmt:
996 ALTER GROUP_P RoleId add_drop USER name_list
997 {
998 AlterRoleStmt *n = makeNode(AlterRoleStmt);
999 n->role = $3;
1000 n->action = $4;
1001 n->options = list_make1(makeDefElem("rolemembers",
1002 (Node *)$6));
1003 $$ = (Node *)n;
1004 }
1005 ;
1006
1007 add_drop: ADD_P { $$ = +1; }
1008 | DROP { $$ = -1; }
1009 ;
1010
1011
1012 /*****************************************************************************
1013 *
1014 * Drop a postgresql group
1015 *
1016 * XXX see above notes about cascading DROP USER; groups have same problem.
1017 *****************************************************************************/
1018
1019 DropGroupStmt:
1020 DROP GROUP_P name_list
1021 {
1022 DropRoleStmt *n = makeNode(DropRoleStmt);
1023 n->missing_ok = FALSE;
1024 n->roles = $3;
1025 $$ = (Node *)n;
1026 }
1027 | DROP GROUP_P IF_P EXISTS name_list
1028 {
1029 DropRoleStmt *n = makeNode(DropRoleStmt);
1030 n->missing_ok = TRUE;
1031 n->roles = $5;
1032 $$ = (Node *)n;
1033 }
1034 ;
1035
1036
1037 /*****************************************************************************
1038 *
1039 * Manipulate a schema
1040 *
1041 *****************************************************************************/
1042
1043 CreateSchemaStmt:
1044 CREATE SCHEMA OptSchemaName AUTHORIZATION RoleId OptSchemaEltList
1045 {
1046 CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
1047 /* One can omit the schema name or the authorization id. */
1048 if ($3 != NULL)
1049 n->schemaname = $3;
1050 else
1051 n->schemaname = $5;
1052 n->authid = $5;
1053 n->schemaElts = $6;
1054 $$ = (Node *)n;
1055 }
1056 | CREATE SCHEMA ColId OptSchemaEltList
1057 {
1058 CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
1059 /* ...but not both */
1060 n->schemaname = $3;
1061 n->authid = NULL;
1062 n->schemaElts = $4;
1063 $$ = (Node *)n;
1064 }
1065 ;
1066
1067 OptSchemaName:
1068 ColId { $$ = $1; }
1069 | /* EMPTY */ { $$ = NULL; }
1070 ;
1071
1072 OptSchemaEltList:
1073 OptSchemaEltList schema_stmt { $$ = lappend($1, $2); }
1074 | /* EMPTY */ { $$ = NIL; }
1075 ;
1076
1077 /*
1078 * schema_stmt are the ones that can show up inside a CREATE SCHEMA
1079 * statement (in addition to by themselves).
1080 */
1081 schema_stmt:
1082 CreateStmt
1083 | IndexStmt
1084 | CreateSeqStmt
1085 | CreateTrigStmt
1086 | GrantStmt
1087 | ViewStmt
1088 ;
1089
1090
1091 /*****************************************************************************
1092 *
1093 * Set PG internal variable
1094 * SET name TO 'var_value'
1095 * Include SQL92 syntax (thomas 1997-10-22):
1096 * SET TIME ZONE 'var_value'
1097 *
1098 *****************************************************************************/
1099
1100 VariableSetStmt:
1101 SET set_rest
1102 {
1103 VariableSetStmt *n = $2;
1104 n->is_local = false;
1105 $$ = (Node *) n;
1106 }
1107 | SET LOCAL set_rest
1108 {
1109 VariableSetStmt *n = $3;
1110 n->is_local = true;
1111 $$ = (Node *) n;
1112 }
1113 | SET SESSION set_rest
1114 {
1115 VariableSetStmt *n = $3;
1116 n->is_local = false;
1117 $$ = (Node *) n;
1118 }
1119 ;
1120
1121 set_rest: /* Generic SET syntaxes: */
1122 var_name TO var_list
1123 {
1124 VariableSetStmt *n = makeNode(VariableSetStmt);
1125 n->kind = VAR_SET_VALUE;
1126 n->name = $1;
1127 n->args = $3;
1128 $$ = n;
1129 }
1130 | var_name '=' var_list
1131 {
1132 VariableSetStmt *n = makeNode(VariableSetStmt);
1133 n->kind = VAR_SET_VALUE;
1134 n->name = $1;
1135 n->args = $3;
1136 $$ = n;
1137 }
1138 | var_name TO DEFAULT
1139 {
1140 VariableSetStmt *n = makeNode(VariableSetStmt);
1141 n->kind = VAR_SET_DEFAULT;
1142 n->name = $1;
1143 $$ = n;
1144 }
1145 | var_name '=' DEFAULT
1146 {
1147 VariableSetStmt *n = makeNode(VariableSetStmt);
1148 n->kind = VAR_SET_DEFAULT;
1149 n->name = $1;
1150 $$ = n;
1151 }
1152 | var_name FROM CURRENT_P
1153 {
1154 VariableSetStmt *n = makeNode(VariableSetStmt);
1155 n->kind = VAR_SET_CURRENT;
1156 n->name = $1;
1157 $$ = n;
1158 }
1159 /* Special syntaxes mandated by SQL standard: */
1160 | TIME ZONE zone_value
1161 {
1162 VariableSetStmt *n = makeNode(VariableSetStmt);
1163 n->kind = VAR_SET_VALUE;
1164 n->name = "timezone";
1165 if ($3 != NULL)
1166 n->args = list_make1($3);
1167 else
1168 n->kind = VAR_SET_DEFAULT;
1169 $$ = n;
1170 }
1171 | TRANSACTION transaction_mode_list
1172 {
1173 VariableSetStmt *n = makeNode(VariableSetStmt);
1174 n->kind = VAR_SET_MULTI;
1175 n->name = "TRANSACTION";
1176 n->args = $2;
1177 $$ = n;
1178 }
1179 | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
1180 {
1181 VariableSetStmt *n = makeNode(VariableSetStmt);
1182 n->kind = VAR_SET_MULTI;
1183 n->name = "SESSION CHARACTERISTICS";
1184 n->args = $5;
1185 $$ = n;
1186 }
1187 | CATALOG_P Sconst
1188 {
1189 ereport(ERROR,
1190 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1191 errmsg("current database cannot be changed"),
1192 scanner_errposition(@2)));
1193 $$ = NULL; /*not reached*/
1194 }
1195 | SCHEMA Sconst
1196 {
1197 VariableSetStmt *n = makeNode(VariableSetStmt);
1198 n->kind = VAR_SET_VALUE;
1199 n->name = "search_path";
1200 n->args = list_make1(makeStringConst($2, @2));
1201 $$ = n;
1202 }
1203 | NAMES opt_encoding
1204 {
1205 VariableSetStmt *n = makeNode(VariableSetStmt);
1206 n->kind = VAR_SET_VALUE;
1207 n->name = "client_encoding";
1208 if ($2 != NULL)
1209 n->args = list_make1(makeStringConst($2, @2));
1210 else
1211 n->kind = VAR_SET_DEFAULT;
1212 $$ = n;
1213 }
1214 | ROLE ColId_or_Sconst
1215 {
1216 VariableSetStmt *n = makeNode(VariableSetStmt);
1217 n->kind = VAR_SET_VALUE;
1218 n->name = "role";
1219 n->args = list_make1(makeStringConst($2, @2));
1220 $$ = n;
1221 }
1222 | SESSION AUTHORIZATION ColId_or_Sconst
1223 {
1224 VariableSetStmt *n = makeNode(VariableSetStmt);
1225 n->kind = VAR_SET_VALUE;
1226 n->name = "session_authorization";
1227 n->args = list_make1(makeStringConst($3, @3));
1228 $$ = n;
1229 }
1230 | SESSION AUTHORIZATION DEFAULT
1231 {
1232 VariableSetStmt *n = makeNode(VariableSetStmt);
1233 n->kind = VAR_SET_DEFAULT;
1234 n->name = "session_authorization";
1235 $$ = n;
1236 }
1237 | XML_P OPTION document_or_content
1238 {
1239 VariableSetStmt *n = makeNode(VariableSetStmt);
1240 n->kind = VAR_SET_VALUE;
1241 n->name = "xmloption";
1242 n->args = list_make1(makeStringConst($3 == XMLOPTION_DOCUMENT ? "DOCUMENT" : "CONTENT", @3));
1243 $$ = n;
1244 }
1245 ;
1246
1247 var_name: ColId { $$ = $1; }
1248 | var_name '.' ColId
1249 {
1250 $$ = palloc(strlen($1) + strlen($3) + 2);
1251 sprintf($$, "%s.%s", $1, $3);
1252 }
1253 ;
1254
1255 var_list: var_value { $$ = list_make1($1); }
1256 | var_list ',' var_value { $$ = lappend($1, $3); }
1257 ;
1258
1259 var_value: opt_boolean
1260 { $$ = makeStringConst($1, @1); }
1261 | ColId_or_Sconst
1262 { $$ = makeStringConst($1, @1); }
1263 | NumericOnly
1264 { $$ = makeAConst($1, @1); }
1265 ;
1266
1267 iso_level: READ UNCOMMITTED { $$ = "read uncommitted"; }
1268 | READ COMMITTED { $$ = "read committed"; }
1269 | REPEATABLE READ { $$ = "repeatable read"; }
1270 | SERIALIZABLE { $$ = "serializable"; }
1271 ;
1272
1273 opt_boolean:
1274 TRUE_P { $$ = "true"; }
1275 | FALSE_P { $$ = "false"; }
1276 | ON { $$ = "on"; }
1277 | OFF { $$ = "off"; }
1278 ;
1279
1280 /* Timezone values can be:
1281 * - a string such as 'pst8pdt'
1282 * - an identifier such as "pst8pdt"
1283 * - an integer or floating point number
1284 * - a time interval per SQL99
1285 * ColId gives reduce/reduce errors against ConstInterval and LOCAL,
1286 * so use IDENT (meaning we reject anything that is a key word).
1287 */
1288 zone_value:
1289 Sconst
1290 {
1291 $$ = makeStringConst($1, @1);
1292 }
1293 | IDENT
1294 {
1295 $$ = makeStringConst($1, @1);
1296 }
1297 | ConstInterval Sconst opt_interval
1298 {
1299 TypeName *t = $1;
1300 if ($3 != NIL)
1301 {
1302 A_Const *n = (A_Const *) linitial($3);
1303 if ((n->val.val.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
1304 ereport(ERROR,
1305 (errcode(ERRCODE_SYNTAX_ERROR),
1306 errmsg("time zone interval must be HOUR or HOUR TO MINUTE"),
1307 scanner_errposition(@3)));
1308 }
1309 t->typmods = $3;
1310 $$ = makeStringConstCast($2, @2, t);
1311 }
1312 | ConstInterval '(' Iconst ')' Sconst opt_interval
1313 {
1314 TypeName *t = $1;
1315 if ($6 != NIL)
1316 {
1317 A_Const *n = (A_Const *) linitial($6);
1318 if ((n->val.val.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
1319 ereport(ERROR,
1320 (errcode(ERRCODE_SYNTAX_ERROR),
1321 errmsg("time zone interval must be HOUR or HOUR TO MINUTE"),
1322 scanner_errposition(@6)));
1323 if (list_length($6) != 1)
1324 ereport(ERROR,
1325 (errcode(ERRCODE_SYNTAX_ERROR),
1326 errmsg("interval precision specified twice"),
1327 scanner_errposition(@1)));
1328 t->typmods = lappend($6, makeIntConst($3, @3));
1329 }
1330 else
1331 t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
1332 makeIntConst($3, @3));
1333 $$ = makeStringConstCast($5, @5, t);
1334 }
1335 | NumericOnly { $$ = makeAConst($1, @1); }
1336 | DEFAULT { $$ = NULL; }
1337 | LOCAL { $$ = NULL; }
1338 ;
1339
1340 opt_encoding:
1341 Sconst { $$ = $1; }
1342 | DEFAULT { $$ = NULL; }
1343 | /*EMPTY*/ { $$ = NULL; }
1344 ;
1345
1346 ColId_or_Sconst:
1347 ColId { $$ = $1; }
1348 | Sconst { $$ = $1; }
1349 ;
1350
1351 VariableResetStmt:
1352 RESET var_name
1353 {
1354 VariableSetStmt *n = makeNode(VariableSetStmt);
1355 n->kind = VAR_RESET;
1356 n->name = $2;
1357 $$ = (Node *) n;
1358 }
1359 | RESET TIME ZONE
1360 {
1361 VariableSetStmt *n = makeNode(VariableSetStmt);
1362 n->kind = VAR_RESET;
1363 n->name = "timezone";
1364 $$ = (Node *) n;
1365 }
1366 | RESET TRANSACTION ISOLATION LEVEL
1367 {
1368 VariableSetStmt *n = makeNode(VariableSetStmt);
1369 n->kind = VAR_RESET;
1370 n->name = "transaction_isolation";
1371 $$ = (Node *) n;
1372 }
1373 | RESET SESSION AUTHORIZATION
1374 {
1375 VariableSetStmt *n = makeNode(VariableSetStmt);
1376 n->kind = VAR_RESET;
1377 n->name = "session_authorization";
1378 $$ = (Node *) n;
1379 }
1380 | RESET ALL
1381 {
1382 VariableSetStmt *n = makeNode(VariableSetStmt);
1383 n->kind = VAR_RESET_ALL;
1384 $$ = (Node *) n;
1385 }
1386 ;
1387
1388 /* SetResetClause allows SET or RESET without LOCAL */
1389 SetResetClause:
1390 SET set_rest { $$ = $2; }
1391 | VariableResetStmt { $$ = (VariableSetStmt *) $1; }
1392 ;
1393
1394
1395 VariableShowStmt:
1396 SHOW var_name
1397 {
1398 VariableShowStmt *n = makeNode(VariableShowStmt);
1399 n->name = $2;
1400 $$ = (Node *) n;
1401 }
1402 | SHOW TIME ZONE
1403 {
1404 VariableShowStmt *n = makeNode(VariableShowStmt);
1405 n->name = "timezone";
1406 $$ = (Node *) n;
1407 }
1408 | SHOW TRANSACTION ISOLATION LEVEL
1409 {
1410 VariableShowStmt *n = makeNode(VariableShowStmt);
1411 n->name = "transaction_isolation";
1412 $$ = (Node *) n;
1413 }
1414 | SHOW SESSION AUTHORIZATION
1415 {
1416 VariableShowStmt *n = makeNode(VariableShowStmt);
1417 n->name = "session_authorization";
1418 $$ = (Node *) n;
1419 }
1420 | SHOW ALL
1421 {
1422 VariableShowStmt *n = makeNode(VariableShowStmt);
1423 n->name = "all";
1424 $$ = (Node *) n;
1425 }
1426 ;
1427
1428
1429 ConstraintsSetStmt:
1430 SET CONSTRAINTS constraints_set_list constraints_set_mode
1431 {
1432 ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt);
1433 n->constraints = $3;
1434 n->deferred = $4;
1435 $$ = (Node *) n;
1436 }
1437 ;
1438
1439 constraints_set_list:
1440 ALL { $$ = NIL; }
1441 | qualified_name_list { $$ = $1; }
1442 ;
1443
1444 constraints_set_mode:
1445 DEFERRED { $$ = TRUE; }
1446 | IMMEDIATE { $$ = FALSE; }
1447 ;
1448
1449
1450 /*
1451 * Checkpoint statement
1452 */
1453 CheckPointStmt:
1454 CHECKPOINT
1455 {
1456 CheckPointStmt *n = makeNode(CheckPointStmt);
1457 $$ = (Node *)n;
1458 }
1459 ;
1460
1461
1462 /*****************************************************************************
1463 *
1464 * DISCARD { ALL | TEMP | PLANS }
1465 *
1466 *****************************************************************************/
1467
1468 DiscardStmt:
1469 DISCARD ALL
1470 {
1471 DiscardStmt *n = makeNode(DiscardStmt);
1472 n->target = DISCARD_ALL;
1473 $$ = (Node *) n;
1474 }
1475 | DISCARD TEMP
1476 {
1477 DiscardStmt *n = makeNode(DiscardStmt);
1478 n->target = DISCARD_TEMP;
1479 $$ = (Node *) n;
1480 }
1481 | DISCARD TEMPORARY
1482 {
1483 DiscardStmt *n = makeNode(DiscardStmt);
1484 n->target = DISCARD_TEMP;
1485 $$ = (Node *) n;
1486 }
1487 | DISCARD PLANS
1488 {
1489 DiscardStmt *n = makeNode(DiscardStmt);
1490 n->target = DISCARD_PLANS;
1491 $$ = (Node *) n;
1492 }
1493 ;
1494
1495
1496 /*****************************************************************************
1497 *
1498 * ALTER [ TABLE | INDEX | SEQUENCE | VIEW ] variations
1499 *
1500 * Note: we accept all subcommands for each of the four variants, and sort
1501 * out what's really legal at execution time.
1502 *****************************************************************************/
1503
1504 AlterTableStmt:
1505 ALTER TABLE relation_expr alter_table_cmds
1506 {
1507 AlterTableStmt *n = makeNode(AlterTableStmt);
1508 n->relation = $3;
1509 n->cmds = $4;
1510 n->relkind = OBJECT_TABLE;
1511 $$ = (Node *)n;
1512 }
1513 | ALTER INDEX qualified_name alter_table_cmds
1514 {
1515 AlterTableStmt *n = makeNode(AlterTableStmt);
1516 n->relation = $3;
1517 n->cmds = $4;
1518 n->relkind = OBJECT_INDEX;
1519 $$ = (Node *)n;
1520 }
1521 | ALTER SEQUENCE qualified_name alter_table_cmds
1522 {
1523 AlterTableStmt *n = makeNode(AlterTableStmt);
1524 n->relation = $3;
1525 n->cmds = $4;
1526 n->relkind = OBJECT_SEQUENCE;
1527 $$ = (Node *)n;
1528 }
1529 | ALTER VIEW qualified_name alter_table_cmds
1530 {
1531 AlterTableStmt *n = makeNode(AlterTableStmt);
1532 n->relation = $3;
1533 n->cmds = $4;
1534 n->relkind = OBJECT_VIEW;
1535 $$ = (Node *)n;
1536 }
1537 ;
1538
1539 alter_table_cmds:
1540 alter_table_cmd { $$ = list_make1($1); }
1541 | alter_table_cmds ',' alter_table_cmd { $$ = lappend($1, $3); }
1542 ;
1543
1544 alter_table_cmd:
1545 /* ALTER TABLE <name> ADD [COLUMN] <coldef> */
1546 ADD_P opt_column columnDef
1547 {
1548 AlterTableCmd *n = makeNode(AlterTableCmd);
1549 n->subtype = AT_AddColumn;
1550 n->def = $3;
1551 $$ = (Node *)n;
1552 }
1553 /* ALTER TABLE <name> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
1554 | ALTER opt_column ColId alter_column_default
1555 {
1556 AlterTableCmd *n = makeNode(AlterTableCmd);
1557 n->subtype = AT_ColumnDefault;
1558 n->name = $3;
1559 n->def = $4;
1560 $$ = (Node *)n;
1561 }
1562 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP NOT NULL */
1563 | ALTER opt_column ColId DROP NOT NULL_P
1564 {
1565 AlterTableCmd *n = makeNode(AlterTableCmd);
1566 n->subtype = AT_DropNotNull;
1567 n->name = $3;
1568 $$ = (Node *)n;
1569 }
1570 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET NOT NULL */
1571 | ALTER opt_column ColId SET NOT NULL_P
1572 {
1573 AlterTableCmd *n = makeNode(AlterTableCmd);
1574 n->subtype = AT_SetNotNull;
1575 n->name = $3;
1576 $$ = (Node *)n;
1577 }
1578 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET STATISTICS <SignedIconst> */
1579 | ALTER opt_column ColId SET STATISTICS SignedIconst
1580 {
1581 AlterTableCmd *n = makeNode(AlterTableCmd);
1582 n->subtype = AT_SetStatistics;
1583 n->name = $3;
1584 n->def = (Node *) makeInteger($6);
1585 $$ = (Node *)n;
1586 }
1587 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
1588 | ALTER opt_column ColId SET STORAGE ColId
1589 {
1590 AlterTableCmd *n = makeNode(AlterTableCmd);
1591 n->subtype = AT_SetStorage;
1592 n->name = $3;
1593 n->def = (Node *) makeString($6);
1594 $$ = (Node *)n;
1595 }
1596 /* ALTER TABLE <name> DROP [COLUMN] <colname> [RESTRICT|CASCADE] */
1597 | DROP opt_column ColId opt_drop_behavior
1598 {
1599 AlterTableCmd *n = makeNode(AlterTableCmd);
1600 n->subtype = AT_DropColumn;
1601 n->name = $3;
1602 n->behavior = $4;
1603 $$ = (Node *)n;
1604 }
1605 /*
1606 * ALTER TABLE <name> ALTER [COLUMN] <colname> [SET DATA] TYPE <typename>
1607 * [ USING <expression> ]
1608 */
1609 | ALTER opt_column ColId opt_set_data TYPE_P Typename alter_using
1610 {
1611 AlterTableCmd *n = makeNode(AlterTableCmd);
1612 n->subtype = AT_AlterColumnType;
1613 n->name = $3;
1614 n->def = (Node *) $6;
1615 n->transform = $7;
1616 $$ = (Node *)n;
1617 }
1618 /* ALTER TABLE <name> ADD CONSTRAINT ... */
1619 | ADD_P TableConstraint
1620 {
1621 AlterTableCmd *n = makeNode(AlterTableCmd);
1622 n->subtype = AT_AddConstraint;
1623 n->def = $2;
1624 $$ = (Node *)n;
1625 }
1626 /* ALTER TABLE <name> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
1627 | DROP CONSTRAINT name opt_drop_behavior
1628 {
1629 AlterTableCmd *n = makeNode(AlterTableCmd);
1630 n->subtype = AT_DropConstraint;
1631 n->name = $3;
1632 n->behavior = $4;
1633 $$ = (Node *)n;
1634 }
1635 /* ALTER TABLE <name> SET WITH OIDS */
1636 | SET WITH OIDS
1637 {
1638 AlterTableCmd *n = makeNode(AlterTableCmd);
1639 n->subtype = AT_AddOids;
1640 $$ = (Node *)n;
1641 }
1642 /* ALTER TABLE <name> SET WITHOUT OIDS */
1643 | SET WITHOUT OIDS
1644 {
1645 AlterTableCmd *n = makeNode(AlterTableCmd);
1646 n->subtype = AT_DropOids;
1647 $$ = (Node *)n;
1648 }
1649 /* ALTER TABLE <name> CLUSTER ON <indexname> */
1650 | CLUSTER ON name
1651 {
1652 AlterTableCmd *n = makeNode(AlterTableCmd);
1653 n->subtype = AT_ClusterOn;
1654 n->name = $3;
1655 $$ = (Node *)n;
1656 }
1657 /* ALTER TABLE <name> SET WITHOUT CLUSTER */
1658 | SET WITHOUT CLUSTER
1659 {
1660 AlterTableCmd *n = makeNode(AlterTableCmd);
1661 n->subtype = AT_DropCluster;
1662 n->name = NULL;
1663 $$ = (Node *)n;
1664 }
1665 /* ALTER TABLE <name> ENABLE TRIGGER <trig> */
1666 | ENABLE_P TRIGGER name
1667 {
1668 AlterTableCmd *n = makeNode(AlterTableCmd);
1669 n->subtype = AT_EnableTrig;
1670 n->name = $3;
1671 $$ = (Node *)n;
1672 }
1673 /* ALTER TABLE <name> ENABLE ALWAYS TRIGGER <trig> */
1674 | ENABLE_P ALWAYS TRIGGER name
1675 {
1676 AlterTableCmd *n = makeNode(AlterTableCmd);
1677 n->subtype = AT_EnableAlwaysTrig;
1678 n->name = $4;
1679 $$ = (Node *)n;
1680 }
1681 /* ALTER TABLE <name> ENABLE REPLICA TRIGGER <trig> */
1682 | ENABLE_P REPLICA TRIGGER name
1683 {
1684 AlterTableCmd *n = makeNode(AlterTableCmd);
1685 n->subtype = AT_EnableReplicaTrig;
1686 n->name = $4;
1687 $$ = (Node *)n;
1688 }
1689 /* ALTER TABLE <name> ENABLE TRIGGER ALL */
1690 | ENABLE_P TRIGGER ALL
1691 {
1692 AlterTableCmd *n = makeNode(AlterTableCmd);
1693 n->subtype = AT_EnableTrigAll;
1694 $$ = (Node *)n;
1695 }
1696 /* ALTER TABLE <name> ENABLE TRIGGER USER */
1697 | ENABLE_P TRIGGER USER
1698 {
1699 AlterTableCmd *n = makeNode(AlterTableCmd);
1700 n->subtype = AT_EnableTrigUser;
1701 $$ = (Node *)n;
1702 }
1703 /* ALTER TABLE <name> DISABLE TRIGGER <trig> */
1704 | DISABLE_P TRIGGER name
1705 {
1706 AlterTableCmd *n = makeNode(AlterTableCmd);
1707 n->subtype = AT_DisableTrig;
1708 n->name = $3;
1709 $$ = (Node *)n;
1710 }
1711 /* ALTER TABLE <name> DISABLE TRIGGER ALL */
1712 | DISABLE_P TRIGGER ALL
1713 {
1714 AlterTableCmd *n = makeNode(AlterTableCmd);
1715 n->subtype = AT_DisableTrigAll;
1716 $$ = (Node *)n;
1717 }
1718 /* ALTER TABLE <name> DISABLE TRIGGER USER */
1719 | DISABLE_P TRIGGER USER
1720 {
1721 AlterTableCmd *n = makeNode(AlterTableCmd);
1722 n->subtype = AT_DisableTrigUser;
1723 $$ = (Node *)n;
1724 }
1725 /* ALTER TABLE <name> ENABLE RULE <rule> */
1726 | ENABLE_P RULE name
1727 {
1728 AlterTableCmd *n = makeNode(AlterTableCmd);
1729 n->subtype = AT_EnableRule;
1730 n->name = $3;
1731 $$ = (Node *)n;
1732 }
1733 /* ALTER TABLE <name> ENABLE ALWAYS RULE <rule> */
1734 | ENABLE_P ALWAYS RULE name
1735 {
1736 AlterTableCmd *n = makeNode(AlterTableCmd);
1737 n->subtype = AT_EnableAlwaysRule;
1738 n->name = $4;
1739 $$ = (Node *)n;
1740 }
1741 /* ALTER TABLE <name> ENABLE REPLICA RULE <rule> */
1742 | ENABLE_P REPLICA RULE name
1743 {
1744 AlterTableCmd *n = makeNode(AlterTableCmd);
1745 n->subtype = AT_EnableReplicaRule;
1746 n->name = $4;
1747 $$ = (Node *)n;
1748 }
1749 /* ALTER TABLE <name> DISABLE RULE <rule> */
1750 | DISABLE_P RULE name
1751 {
1752 AlterTableCmd *n = makeNode(AlterTableCmd);
1753 n->subtype = AT_DisableRule;
1754 n->name = $3;
1755 $$ = (Node *)n;
1756 }
1757 /* ALTER TABLE <name> INHERIT <parent> */
1758 | INHERIT qualified_name
1759 {
1760 AlterTableCmd *n = makeNode(AlterTableCmd);
1761 n->subtype = AT_AddInherit;
1762 n->def = (Node *) $2;
1763 $$ = (Node *)n;
1764 }
1765 /* ALTER TABLE <name> NO INHERIT <parent> */
1766 | NO INHERIT qualified_name
1767 {
1768 AlterTableCmd *n = makeNode(AlterTableCmd);
1769 n->subtype = AT_DropInherit;
1770 n->def = (Node *) $3;
1771 $$ = (Node *)n;
1772 }
1773 /* ALTER TABLE <name> OWNER TO RoleId */
1774 | OWNER TO RoleId
1775 {
1776 AlterTableCmd *n = makeNode(AlterTableCmd);
1777 n->subtype = AT_ChangeOwner;
1778 n->name = $3;
1779 $$ = (Node *)n;
1780 }
1781 /* ALTER TABLE <name> SET TABLESPACE <tablespacename> */
1782 | SET TABLESPACE name
1783 {
1784 AlterTableCmd *n = makeNode(AlterTableCmd);
1785 n->subtype = AT_SetTableSpace;
1786 n->name = $3;
1787 $$ = (Node *)n;
1788 }
1789 /* ALTER TABLE <name> SET (...) */
1790 | SET reloptions
1791 {
1792 AlterTableCmd *n = makeNode(AlterTableCmd);
1793 n->subtype = AT_SetRelOptions;
1794 n->def = (Node *)$2;
1795 $$ = (Node *)n;
1796 }
1797 /* ALTER TABLE <name> RESET (...) */
1798 | RESET reloptions
1799 {
1800 AlterTableCmd *n = makeNode(AlterTableCmd);
1801 n->subtype = AT_ResetRelOptions;
1802 n->def = (Node *)$2;
1803 $$ = (Node *)n;
1804 }
1805 ;
1806
1807 alter_column_default:
1808 SET DEFAULT a_expr { $$ = $3; }
1809 | DROP DEFAULT { $$ = NULL; }
1810 ;
1811
1812 opt_drop_behavior:
1813 CASCADE { $$ = DROP_CASCADE; }
1814 | RESTRICT { $$ = DROP_RESTRICT; }
1815 | /* EMPTY */ { $$ = DROP_RESTRICT; /* default */ }
1816 ;
1817
1818 alter_using:
1819 USING a_expr { $$ = $2; }
1820 | /* EMPTY */ { $$ = NULL; }
1821 ;
1822
1823 reloptions:
1824 '(' reloption_list ')' { $$ = $2; }
1825 ;
1826
1827 opt_reloptions: WITH reloptions { $$ = $2; }
1828 | /* EMPTY */ { $$ = NIL; }
1829 ;
1830
1831 reloption_list:
1832 reloption_elem { $$ = list_make1($1); }
1833 | reloption_list ',' reloption_elem { $$ = lappend($1, $3); }
1834 ;
1835
1836 /* This should match def_elem and also allow qualified names */
1837 reloption_elem:
1838 ColLabel '=' def_arg
1839 {
1840 $$ = makeDefElem($1, (Node *) $3);
1841 }
1842 | ColLabel
1843 {
1844 $$ = makeDefElem($1, NULL);
1845 }
1846 | ColLabel '.' ColLabel '=' def_arg
1847 {
1848 $$ = makeDefElemExtended($1, $3, (Node *) $5,
1849 DEFELEM_UNSPEC);
1850 }
1851 | ColLabel '.' ColLabel
1852 {
1853 $$ = makeDefElemExtended($1, $3, NULL, DEFELEM_UNSPEC);
1854 }
1855 ;
1856
1857
1858 /*****************************************************************************
1859 *
1860 * QUERY :
1861 * close <portalname>
1862 *
1863 *****************************************************************************/
1864
1865 ClosePortalStmt:
1866 CLOSE name
1867 {
1868 ClosePortalStmt *n = makeNode(ClosePortalStmt);
1869 n->portalname = $2;
1870 $$ = (Node *)n;
1871 }
1872 | CLOSE ALL
1873 {
1874 ClosePortalStmt *n = makeNode(ClosePortalStmt);
1875 n->portalname = NULL;
1876 $$ = (Node *)n;
1877 }
1878 ;
1879
1880
1881 /*****************************************************************************
1882 *
1883 * QUERY :
1884 * COPY relname ['(' columnList ')'] FROM/TO file [WITH options]
1885 *
1886 * BINARY, OIDS, and DELIMITERS kept in old locations
1887 * for backward compatibility. 2002-06-18
1888 *
1889 * COPY ( SELECT ... ) TO file [WITH options]
1890 * This form doesn't have the backwards-compatible option
1891 * syntax.
1892 *
1893 *****************************************************************************/
1894
1895 CopyStmt: COPY opt_binary qualified_name opt_column_list opt_oids
1896 copy_from copy_file_name copy_delimiter opt_with copy_opt_list
1897 {
1898 CopyStmt *n = makeNode(CopyStmt);
1899 n->relation = $3;
1900 n->query = NULL;
1901 n->attlist = $4;
1902 n->is_from = $6;
1903 n->filename = $7;
1904
1905 n->options = NIL;
1906 /* Concatenate user-supplied flags */
1907 if ($2)
1908 n->options = lappend(n->options, $2);
1909 if ($5)
1910 n->options = lappend(n->options, $5);
1911 if ($8)
1912 n->options = lappend(n->options, $8);
1913 if ($10)
1914 n->options = list_concat(n->options, $10);
1915 $$ = (Node *)n;
1916 }
1917 | COPY select_with_parens TO copy_file_name opt_with
1918 copy_opt_list
1919 {
1920 CopyStmt *n = makeNode(CopyStmt);
1921 n->relation = NULL;
1922 n->query = $2;
1923 n->attlist = NIL;
1924 n->is_from = false;
1925 n->filename = $4;
1926 n->options = $6;
1927 $$ = (Node *)n;
1928 }
1929 ;
1930
1931 copy_from:
1932 FROM { $$ = TRUE; }
1933 | TO { $$ = FALSE; }
1934 ;
1935
1936 /*
1937 * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
1938 * used depends on the direction. (It really doesn't make sense to copy from
1939 * stdout. We silently correct the "typo".) - AY 9/94
1940 */
1941 copy_file_name:
1942 Sconst { $$ = $1; }
1943 | STDIN { $$ = NULL; }
1944 | STDOUT { $$ = NULL; }
1945 ;
1946
1947
1948
1949 copy_opt_list:
1950 copy_opt_list copy_opt_item { $$ = lappend($1, $2); }
1951 | /* EMPTY */ { $$ = NIL; }
1952 ;
1953
1954
1955 copy_opt_item:
1956 BINARY
1957 {
1958 $$ = makeDefElem("binary", (Node *)makeInteger(TRUE));
1959 }
1960 | OIDS
1961 {
1962 $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
1963 }
1964 | DELIMITER opt_as Sconst
1965 {
1966 $$ = makeDefElem("delimiter", (Node *)makeString($3));
1967 }
1968 | NULL_P opt_as Sconst
1969 {
1970 $$ = makeDefElem("null", (Node *)makeString($3));
1971 }
1972 | CSV
1973 {
1974 $$ = makeDefElem("csv", (Node *)makeInteger(TRUE));
1975 }
1976 | HEADER_P
1977 {
1978 $$ = makeDefElem("header", (Node *)makeInteger(TRUE));
1979 }
1980 | QUOTE opt_as Sconst
1981 {
1982 $$ = makeDefElem("quote", (Node *)makeString($3));
1983 }
1984 | ESCAPE opt_as Sconst
1985 {
1986 $$ = makeDefElem("escape", (Node *)makeString($3));
1987 }
1988 | FORCE QUOTE columnList
1989 {
1990 $$ = makeDefElem("force_quote", (Node *)$3);
1991 }
1992 | FORCE NOT NULL_P columnList
1993 {
1994 $$ = makeDefElem("force_notnull", (Node *)$4);
1995 }
1996 ;
1997
1998 /* The following exist for backward compatibility */
1999
2000 opt_binary:
2001 BINARY
2002 {
2003 $$ = makeDefElem("binary", (Node *)makeInteger(TRUE));
2004 }
2005 | /*EMPTY*/ { $$ = NULL; }
2006 ;
2007
2008 opt_oids:
2009 WITH OIDS
2010 {
2011 $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
2012 }
2013 | /*EMPTY*/ { $$ = NULL; }
2014 ;
2015
2016 copy_delimiter:
2017 /* USING DELIMITERS kept for backward compatibility. 2002-06-15 */
2018 opt_using DELIMITERS Sconst
2019 {
2020 $$ = makeDefElem("delimiter", (Node *)makeString($3));
2021 }
2022 | /*EMPTY*/ { $$ = NULL; }
2023 ;
2024
2025 opt_using:
2026 USING {}
2027 | /*EMPTY*/ {}
2028 ;
2029
2030
2031 /*****************************************************************************
2032 *
2033 * QUERY :
2034 * CREATE TABLE relname
2035 *
2036 *****************************************************************************/
2037
2038 CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')'
2039 OptInherit OptWith OnCommitOption OptTableSpace
2040 {
2041 CreateStmt *n = makeNode(CreateStmt);
2042 $4->istemp = $2;
2043 n->relation = $4;
2044 n->tableElts = $6;
2045 n->inhRelations = $8;
2046 n->constraints = NIL;
2047 n->options = $9;
2048 n->oncommit = $10;
2049 n->tablespacename = $11;
2050 $$ = (Node *)n;
2051 }
2052 | CREATE OptTemp TABLE qualified_name OF qualified_name
2053 '(' OptTableElementList ')' OptWith OnCommitOption OptTableSpace
2054 {
2055 /* SQL99 CREATE TABLE OF <UDT> (cols) seems to be satisfied
2056 * by our inheritance capabilities. Let's try it...
2057 */
2058 CreateStmt *n = makeNode(CreateStmt);
2059 $4->istemp = $2;
2060 n->relation = $4;
2061 n->tableElts = $8;
2062 n->inhRelations = list_make1($6);
2063 n->constraints = NIL;
2064 n->options = $10;
2065 n->oncommit = $11;
2066 n->tablespacename = $12;
2067 $$ = (Node *)n;
2068 }
2069 ;
2070
2071 /*
2072 * Redundancy here is needed to avoid shift/reduce conflicts,
2073 * since TEMP is not a reserved word. See also OptTempTableName.
2074 *
2075 * NOTE: we accept both GLOBAL and LOCAL options; since we have no modules
2076 * the LOCAL keyword is really meaningless.
2077 */
2078 OptTemp: TEMPORARY { $$ = TRUE; }
2079 | TEMP { $$ = TRUE; }
2080 | LOCAL TEMPORARY { $$ = TRUE; }
2081 | LOCAL TEMP { $$ = TRUE; }
2082 | GLOBAL TEMPORARY { $$ = TRUE; }
2083 | GLOBAL TEMP { $$ = TRUE; }
2084 | /*EMPTY*/ { $$ = FALSE; }
2085 ;
2086
2087 OptTableElementList:
2088 TableElementList { $$ = $1; }
2089 | /*EMPTY*/ { $$ = NIL; }
2090 ;
2091
2092 TableElementList:
2093 TableElement
2094 {
2095 $$ = list_make1($1);
2096 }
2097 | TableElementList ',' TableElement
2098 {
2099 $$ = lappend($1, $3);
2100 }
2101 ;
2102
2103 TableElement:
2104 columnDef { $$ = $1; }
2105 | TableLikeClause { $$ = $1; }
2106 | TableConstraint { $$ = $1; }
2107 ;
2108
2109 columnDef: ColId Typename ColQualList
2110 {
2111 ColumnDef *n = makeNode(ColumnDef);
2112 n->colname = $1;
2113 n->typename = $2;
2114 n->constraints = $3;
2115 n->is_local = true;
2116 $$ = (Node *)n;
2117 }
2118 ;
2119
2120 ColQualList:
2121 ColQualList ColConstraint { $$ = lappend($1, $2); }
2122 | /*EMPTY*/ { $$ = NIL; }
2123 ;
2124
2125 ColConstraint:
2126 CONSTRAINT name ColConstraintElem
2127 {
2128 switch (nodeTag($3))
2129 {
2130 case T_Constraint:
2131 {
2132 Constraint *n = (Constraint *)$3;
2133 n->name = $2;
2134 }
2135 break;
2136 case T_FkConstraint:
2137 {
2138 FkConstraint *n = (FkConstraint *)$3;
2139 n->constr_name = $2;
2140 }
2141 break;
2142 default:
2143 break;
2144 }
2145 $$ = $3;
2146 }
2147 | ColConstraintElem { $$ = $1; }
2148 | ConstraintAttr { $$ = $1; }
2149 ;
2150
2151 /* DEFAULT NULL is already the default for Postgres.
2152 * But define it here and carry it forward into the system
2153 * to make it explicit.
2154 * - thomas 1998-09-13
2155 *
2156 * WITH NULL and NULL are not SQL92-standard syntax elements,
2157 * so leave them out. Use DEFAULT NULL to explicitly indicate
2158 * that a column may have that value. WITH NULL leads to
2159 * shift/reduce conflicts with WITH TIME ZONE anyway.
2160 * - thomas 1999-01-08
2161 *
2162 * DEFAULT expression must be b_expr not a_expr to prevent shift/reduce
2163 * conflict on NOT (since NOT might start a subsequent NOT NULL constraint,
2164 * or be part of a_expr NOT LIKE or similar constructs).
2165 */
2166 ColConstraintElem:
2167 NOT NULL_P
2168 {
2169 Constraint *n = makeNode(Constraint);
2170 n->contype = CONSTR_NOTNULL;
2171 n->name = NULL;
2172 n->raw_expr = NULL;
2173 n->cooked_expr = NULL;
2174 n->keys = NULL;
2175 n->indexspace = NULL;
2176 $$ = (Node *)n;
2177 }
2178 | NULL_P
2179 {
2180 Constraint *n = makeNode(Constraint);
2181 n->contype = CONSTR_NULL;
2182 n->name = NULL;
2183 n->raw_expr = NULL;
2184 n->cooked_expr = NULL;
2185 n->keys = NULL;
2186 n->indexspace = NULL;
2187 $$ = (Node *)n;
2188 }
2189 | UNIQUE opt_definition OptConsTableSpace
2190 {
2191 Constraint *n = makeNode(Constraint);
2192 n->contype = CONSTR_UNIQUE;
2193 n->name = NULL;
2194 n->raw_expr = NULL;
2195 n->cooked_expr = NULL;
2196 n->keys = NULL;
2197 n->options = $2;
2198 n->indexspace = $3;
2199 $$ = (Node *)n;
2200 }
2201 | PRIMARY KEY opt_definition OptConsTableSpace
2202 {
2203 Constraint *n = makeNode(Constraint);
2204 n->contype = CONSTR_PRIMARY;
2205 n->name = NULL;
2206 n->raw_expr = NULL;
2207 n->cooked_expr = NULL;
2208 n->keys = NULL;
2209 n->options = $3;
2210 n->indexspace = $4;
2211 $$ = (Node *)n;
2212 }
2213 | CHECK '(' a_expr ')'
2214 {
2215 Constraint *n = makeNode(Constraint);
2216 n->contype = CONSTR_CHECK;
2217 n->name = NULL;
2218 n->raw_expr = $3;
2219 n->cooked_expr = NULL;
2220 n->keys = NULL;
2221 n->indexspace = NULL;
2222 $$ = (Node *)n;
2223 }
2224 | DEFAULT b_expr
2225 {
2226 Constraint *n = makeNode(Constraint);
2227 n->contype = CONSTR_DEFAULT;
2228 n->name = NULL;
2229 n->raw_expr = $2;
2230 n->cooked_expr = NULL;
2231 n->keys = NULL;
2232 n->indexspace = NULL;
2233 $$ = (Node *)n;
2234 }
2235 | REFERENCES qualified_name opt_column_list key_match key_actions
2236 {
2237 FkConstraint *n = makeNode(FkConstraint);
2238 n->constr_name = NULL;
2239 n->pktable = $2;
2240 n->fk_attrs = NIL;
2241 n->pk_attrs = $3;
2242 n->fk_matchtype = $4;
2243 n->fk_upd_action = (char) ($5 >> 8);
2244 n->fk_del_action = (char) ($5 & 0xFF);
2245 n->deferrable = FALSE;
2246 n->initdeferred = FALSE;
2247 $$ = (Node *)n;
2248 }
2249 ;
2250
2251 /*
2252 * ConstraintAttr represents constraint attributes, which we parse as if
2253 * they were independent constraint clauses, in order to avoid shift/reduce
2254 * conflicts (since NOT might start either an independent NOT NULL clause
2255 * or an attribute). parse_utilcmd.c is responsible for attaching the
2256 * attribute information to the preceding "real" constraint node, and for
2257 * complaining if attribute clauses appear in the wrong place or wrong
2258 * combinations.
2259 *
2260 * See also ConstraintAttributeSpec, which can be used in places where
2261 * there is no parsing conflict.
2262 */
2263 ConstraintAttr:
2264 DEFERRABLE
2265 {
2266 Constraint *n = makeNode(Constraint);
2267 n->contype = CONSTR_ATTR_DEFERRABLE;
2268 $$ = (Node *)n;
2269 }
2270 | NOT DEFERRABLE
2271 {
2272 Constraint *n = makeNode(Constraint);
2273 n->contype = CONSTR_ATTR_NOT_DEFERRABLE;
2274 $$ = (Node *)n;
2275 }
2276 | INITIALLY DEFERRED
2277 {
2278 Constraint *n = makeNode(Constraint);
2279 n->contype = CONSTR_ATTR_DEFERRED;
2280 $$ = (Node *)n;
2281 }
2282 | INITIALLY IMMEDIATE
2283 {
2284 Constraint *n = makeNode(Constraint);
2285 n->contype = CONSTR_ATTR_IMMEDIATE;
2286 $$ = (Node *)n;
2287 }
2288 ;
2289
2290
2291 /*
2292 * SQL99 supports wholesale borrowing of a table definition via the LIKE clause.
2293 * This seems to be a poor man's inheritance capability, with the resulting
2294 * tables completely decoupled except for the original commonality in definitions.
2295 *
2296 * This is very similar to CREATE TABLE AS except for the INCLUDING DEFAULTS extension
2297 * which is a part of SQL:2003.
2298 */
2299 TableLikeClause:
2300 LIKE qualified_name TableLikeOptionList
2301 {
2302 InhRelation *n = makeNode(InhRelation);
2303 n->relation = $2;
2304 n->options = $3;
2305 $$ = (Node *)n;
2306 }
2307 ;
2308
2309 TableLikeOptionList:
2310 TableLikeOptionList TableLikeOption { $$ = lappend_int($1, $2); }
2311 | /* EMPTY */ { $$ = NIL; }
2312 ;
2313
2314 TableLikeOption:
2315 INCLUDING DEFAULTS { $$ = CREATE_TABLE_LIKE_INCLUDING_DEFAULTS; }
2316 | EXCLUDING DEFAULTS { $$ = CREATE_TABLE_LIKE_EXCLUDING_DEFAULTS; }
2317 | INCLUDING CONSTRAINTS { $$ = CREATE_TABLE_LIKE_INCLUDING_CONSTRAINTS; }
2318 | EXCLUDING CONSTRAINTS { $$ = CREATE_TABLE_LIKE_EXCLUDING_CONSTRAINTS; }
2319 | INCLUDING INDEXES { $$ = CREATE_TABLE_LIKE_INCLUDING_INDEXES; }
2320 | EXCLUDING INDEXES { $$ = CREATE_TABLE_LIKE_EXCLUDING_INDEXES; }
2321 ;
2322
2323
2324 /* ConstraintElem specifies constraint syntax which is not embedded into
2325 * a column definition. ColConstraintElem specifies the embedded form.
2326 * - thomas 1997-12-03
2327 */
2328 TableConstraint:
2329 CONSTRAINT name ConstraintElem
2330 {
2331 switch (nodeTag($3))
2332 {
2333 case T_Constraint:
2334 {
2335 Constraint *n = (Constraint *)$3;
2336 n->name = $2;
2337 }
2338 break;
2339 case T_FkConstraint:
2340 {
2341 FkConstraint *n = (FkConstraint *)$3;
2342 n->constr_name = $2;
2343 }
2344 break;
2345 default:
2346 break;
2347 }
2348 $$ = $3;
2349 }
2350 | ConstraintElem { $$ = $1; }
2351 ;
2352
2353 ConstraintElem:
2354 CHECK '(' a_expr ')'
2355 {
2356 Constraint *n = makeNode(Constraint);
2357 n->contype = CONSTR_CHECK;
2358 n->name = NULL;
2359 n->raw_expr = $3;
2360 n->cooked_expr = NULL;
2361 n->indexspace = NULL;
2362 $$ = (Node *)n;
2363 }
2364 | UNIQUE '(' columnList ')' opt_definition OptConsTableSpace
2365 {
2366 Constraint *n = makeNode(Constraint);
2367 n->contype = CONSTR_UNIQUE;
2368 n->name = NULL;
2369 n->raw_expr = NULL;
2370 n->cooked_expr = NULL;
2371 n->keys = $3;
2372 n->options = $5;
2373 n->indexspace = $6;
2374 $$ = (Node *)n;
2375 }
2376 | PRIMARY KEY '(' columnList ')' opt_definition OptConsTableSpace
2377 {
2378 Constraint *n = makeNode(Constraint);
2379 n->contype = CONSTR_PRIMARY;
2380 n->name = NULL;
2381 n->raw_expr = NULL;
2382 n->cooked_expr = NULL;
2383 n->keys = $4;
2384 n->options = $6;
2385 n->indexspace = $7;
2386 $$ = (Node *)n;
2387 }
2388 | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name
2389 opt_column_list key_match key_actions ConstraintAttributeSpec
2390 {
2391 FkConstraint *n = makeNode(FkConstraint);
2392 n->constr_name = NULL;
2393 n->pktable = $7;
2394 n->fk_attrs = $4;
2395 n->pk_attrs = $8;
2396 n->fk_matchtype = $9;
2397 n->fk_upd_action = (char) ($10 >> 8);
2398 n->fk_del_action = (char) ($10 & 0xFF);
2399 n->deferrable = ($11 & 1) != 0;
2400 n->initdeferred = ($11 & 2) != 0;
2401 $$ = (Node *)n;
2402 }
2403 ;
2404
2405 opt_column_list:
2406 '(' columnList ')' { $$ = $2; }
2407 | /*EMPTY*/ { $$ = NIL; }
2408 ;
2409
2410 columnList:
2411 columnElem { $$ = list_make1($1); }
2412 | columnList ',' columnElem { $$ = lappend($1, $3); }
2413 ;
2414
2415 columnElem: ColId
2416 {
2417 $$ = (Node *) makeString($1);
2418 }
2419 ;
2420
2421 key_match: MATCH FULL
2422 {
2423 $$ = FKCONSTR_MATCH_FULL;
2424 }
2425 | MATCH PARTIAL
2426 {
2427 ereport(ERROR,
2428 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2429 errmsg("MATCH PARTIAL not yet implemented"),
2430 scanner_errposition(@1)));
2431 $$ = FKCONSTR_MATCH_PARTIAL;
2432 }
2433 | MATCH SIMPLE
2434 {
2435 $$ = FKCONSTR_MATCH_UNSPECIFIED;
2436 }
2437 | /*EMPTY*/
2438 {
2439 $$ = FKCONSTR_MATCH_UNSPECIFIED;
2440 }
2441 ;
2442
2443 /*
2444 * We combine the update and delete actions into one value temporarily
2445 * for simplicity of parsing, and then break them down again in the
2446 * calling production. update is in the left 8 bits, delete in the right.
2447 * Note that NOACTION is the default.
2448 */
2449 key_actions:
2450 key_update
2451 { $$ = ($1 << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); }
2452 | key_delete
2453 { $$ = (FKCONSTR_ACTION_NOACTION << 8) | ($1 & 0xFF); }
2454 | key_update key_delete
2455 { $$ = ($1 << 8) | ($2 & 0xFF); }
2456 | key_delete key_update
2457 { $$ = ($2 << 8) | ($1 & 0xFF); }
2458 | /*EMPTY*/
2459 { $$ = (FKCONSTR_ACTION_NOACTION << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); }
2460 ;
2461
2462 key_update: ON UPDATE key_action { $$ = $3; }
2463 ;
2464
2465 key_delete: ON DELETE_P key_action { $$ = $3; }
2466 ;
2467
2468 key_action:
2469 NO ACTION { $$ = FKCONSTR_ACTION_NOACTION; }
2470 | RESTRICT { $$ = FKCONSTR_ACTION_RESTRICT; }
2471 | CASCADE { $$ = FKCONSTR_ACTION_CASCADE; }
2472 | SET NULL_P { $$ = FKCONSTR_ACTION_SETNULL; }
2473 | SET DEFAULT { $$ = FKCONSTR_ACTION_SETDEFAULT; }
2474 ;
2475
2476 OptInherit: INHERITS '(' qualified_name_list ')' { $$ = $3; }
2477 | /*EMPTY*/ { $$ = NIL; }
2478 ;
2479
2480 /* WITH (options) is preferred, WITH OIDS and WITHOUT OIDS are legacy forms */
2481 OptWith:
2482 WITH reloptions { $$ = $2; }
2483 | WITH OIDS { $$ = list_make1(defWithOids(true)); }
2484 | WITHOUT OIDS { $$ = list_make1(defWithOids(false)); }
2485 | /*EMPTY*/ { $$ = NIL; }
2486 ;
2487
2488 OnCommitOption: ON COMMIT DROP { $$ = ONCOMMIT_DROP; }
2489 | ON COMMIT DELETE_P ROWS { $$ = ONCOMMIT_DELETE_ROWS; }
2490 | ON COMMIT PRESERVE ROWS { $$ = ONCOMMIT_PRESERVE_ROWS; }
2491 | /*EMPTY*/ { $$ = ONCOMMIT_NOOP; }
2492 ;
2493
2494 OptTableSpace: TABLESPACE name { $$ = $2; }
2495 | /*EMPTY*/ { $$ = NULL; }
2496 ;
2497
2498 OptConsTableSpace: USING INDEX TABLESPACE name { $$ = $4; }
2499 | /*EMPTY*/ { $$ = NULL; }
2500 ;
2501
2502
2503 /*
2504 * Note: CREATE TABLE ... AS SELECT ... is just another spelling for
2505 * SELECT ... INTO.
2506 */
2507
2508 CreateAsStmt:
2509 CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
2510 {
2511 /*
2512 * When the SelectStmt is a set-operation tree, we must
2513 * stuff the INTO information into the leftmost component
2514 * Select, because that's where analyze.c will expect
2515 * to find it. Similarly, the output column names must
2516 * be attached to that Select's target list.
2517 */
2518 SelectStmt *n = findLeftmostSelect((SelectStmt *) $6);
2519 if (n->intoClause != NULL)
2520 ereport(ERROR,
2521 (errcode(ERRCODE_SYNTAX_ERROR),
2522 errmsg("CREATE TABLE AS cannot specify INTO"),
2523 scanner_errposition(exprLocation((Node *) n->intoClause))));
2524 $4->rel->istemp = $2;
2525 n->intoClause = $4;
2526 /* Implement WITH NO DATA by forcing top-level LIMIT 0 */
2527 if (!$7)
2528 ((SelectStmt *) $6)->limitCount = makeIntConst(0, -1);
2529 $$ = $6;
2530 }
2531 ;
2532
2533 create_as_target:
2534 qualified_name OptCreateAs OptWith OnCommitOption OptTableSpace
2535 {
2536 $$ = makeNode(IntoClause);
2537 $$->rel = $1;
2538 $$->colNames = $2;
2539 $$->options = $3;
2540 $$->onCommit = $4;
2541 $$->tableSpaceName = $5;
2542 }
2543 ;
2544
2545 OptCreateAs:
2546 '(' CreateAsList ')' { $$ = $2; }
2547 | /*EMPTY*/ { $$ = NIL; }
2548 ;
2549
2550 CreateAsList:
2551 CreateAsElement { $$ = list_make1($1); }
2552 | CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
2553 ;
2554
2555 CreateAsElement:
2556 ColId
2557 {
2558 ColumnDef *n = makeNode(ColumnDef);
2559 n->colname = $1;
2560 n->typename = NULL;
2561 n->inhcount = 0;
2562 n->is_local = true;
2563 n->is_not_null = false;
2564 n->raw_default = NULL;
2565 n->cooked_default = NULL;
2566 n->constraints = NIL;
2567 $$ = (Node *)n;
2568 }
2569 ;
2570
2571 opt_with_data:
2572 WITH DATA_P { $$ = TRUE; }
2573 | WITH NO DATA_P { $$ = FALSE; }
2574 | /*EMPTY*/ { $$ = TRUE; }
2575 ;
2576
2577
2578 /*****************************************************************************
2579 *
2580 * QUERY :
2581 * CREATE SEQUENCE seqname
2582 * ALTER SEQUENCE seqname
2583 *
2584 *****************************************************************************/
2585
2586 CreateSeqStmt:
2587 CREATE OptTemp SEQUENCE qualified_name OptSeqOptList
2588 {
2589 CreateSeqStmt *n = makeNode(CreateSeqStmt);
2590 $4->istemp = $2;
2591 n->sequence = $4;
2592 n->options = $5;
2593 $$ = (Node *)n;
2594 }
2595 ;
2596
2597 AlterSeqStmt:
2598 ALTER SEQUENCE qualified_name SeqOptList
2599 {
2600 AlterSeqStmt *n = makeNode(AlterSeqStmt);
2601 n->sequence = $3;
2602 n->options = $4;
2603 $$ = (Node *)n;
2604 }
2605 ;
2606
2607 OptSeqOptList: SeqOptList { $$ = $1; }
2608 | /*EMPTY*/ { $$ = NIL; }
2609 ;
2610
2611 SeqOptList: SeqOptElem { $$ = list_make1($1); }
2612 | SeqOptList SeqOptElem { $$ = lappend($1, $2); }
2613 ;
2614
2615 SeqOptElem: CACHE NumericOnly
2616 {
2617 $$ = makeDefElem("cache", (Node *)$2);
2618 }
2619 | CYCLE
2620 {
2621 $$ = makeDefElem("cycle", (Node *)makeInteger(TRUE));
2622 }
2623 | NO CYCLE
2624 {
2625 $$ = makeDefElem("cycle", (Node *)makeInteger(FALSE));
2626 }
2627 | INCREMENT opt_by NumericOnly
2628 {
2629 $$ = makeDefElem("increment", (Node *)$3);
2630 }
2631 | MAXVALUE NumericOnly
2632 {
2633 $$ = makeDefElem("maxvalue", (Node *)$2);
2634 }
2635 | MINVALUE NumericOnly
2636 {
2637 $$ = makeDefElem("minvalue", (Node *)$2);
2638 }
2639 | NO MAXVALUE
2640 {
2641 $$ = makeDefElem("maxvalue", NULL);
2642 }
2643 | NO MINVALUE
2644 {
2645 $$ = makeDefElem("minvalue", NULL);
2646 }
2647 | OWNED BY any_name
2648 {
2649 $$ = makeDefElem("owned_by", (Node *)$3);
2650 }
2651 | START opt_with NumericOnly
2652 {
2653 $$ = makeDefElem("start", (Node *)$3);
2654 }
2655 | RESTART
2656 {
2657 $$ = makeDefElem("restart", NULL);
2658 }
2659 | RESTART opt_with NumericOnly
2660 {
2661 $$ = makeDefElem("restart", (Node *)$3);
2662 }
2663 ;
2664
2665 opt_by: BY {}
2666 | /* empty */ {}
2667 ;
2668
2669 NumericOnly:
2670 FCONST { $$ = makeFloat($1); }
2671 | '-' FCONST
2672 {
2673 $$ = makeFloat($2);
2674 doNegateFloat($$);
2675 }
2676 | SignedIconst { $$ = makeInteger($1); };
2677 ;
2678
2679 /*****************************************************************************
2680 *
2681 * QUERIES :
2682 * CREATE PROCEDURAL LANGUAGE ...
2683 * DROP PROCEDURAL LANGUAGE ...
2684 *
2685 *****************************************************************************/
2686
2687 CreatePLangStmt:
2688 CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
2689 {
2690 CreatePLangStmt *n = makeNode(CreatePLangStmt);
2691 n->plname = $5;
2692 /* parameters are all to be supplied by system */
2693 n->plhandler = NIL;
2694 n->plvalidator = NIL;
2695 n->pltrusted = false;
2696 $$ = (Node *)n;
2697 }
2698 | CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
2699 HANDLER handler_name opt_validator opt_lancompiler
2700 {
2701 CreatePLangStmt *n = makeNode(CreatePLangStmt);
2702 n->plname = $5;
2703 n->plhandler = $7;
2704 n->plvalidator = $8;
2705 n->pltrusted = $2;
2706 /* LANCOMPILER is now ignored entirely */
2707 $$ = (Node *)n;
2708 }
2709 ;
2710
2711 opt_trusted:
2712 TRUSTED { $$ = TRUE; }
2713 | /*EMPTY*/ { $$ = FALSE; }
2714 ;
2715
2716 /* This ought to be just func_name, but that causes reduce/reduce conflicts
2717 * (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
2718 * Work around by using simple names, instead.
2719 */
2720 handler_name:
2721 name { $$ = list_make1(makeString($1)); }
2722 | name attrs { $$ = lcons(makeString($1), $2); }
2723 ;
2724
2725 validator_clause:
2726 VALIDATOR handler_name { $$ = $2; }
2727 | NO VALIDATOR { $$ = NIL; }
2728 ;
2729
2730 opt_validator:
2731 validator_clause { $$ = $1; }
2732 | /*EMPTY*/ { $$ = NIL; }
2733 ;
2734
2735 opt_lancompiler:
2736 LANCOMPILER Sconst { $$ = $2; }
2737 | /*EMPTY*/ { $$ = NULL; }
2738 ;
2739
2740 DropPLangStmt:
2741 DROP opt_procedural LANGUAGE ColId_or_Sconst opt_drop_behavior
2742 {
2743 DropPLangStmt *n = makeNode(DropPLangStmt);
2744 n->plname = $4;
2745 n->behavior = $5;
2746 n->missing_ok = false;
2747 $$ = (Node *)n;
2748 }
2749 | DROP opt_procedural LANGUAGE IF_P EXISTS ColId_or_Sconst opt_drop_behavior
2750 {
2751 DropPLangStmt *n = makeNode(DropPLangStmt);
2752 n->plname = $6;
2753 n->behavior = $7;
2754 n->missing_ok = true;
2755 $$ = (Node *)n;
2756 }
2757 ;
2758
2759 opt_procedural:
2760 PROCEDURAL {}
2761 | /*EMPTY*/ {}
2762 ;
2763
2764 /*****************************************************************************
2765 *
2766 * QUERY:
2767 * CREATE TABLESPACE tablespace LOCATION '/path/to/tablespace/'
2768 *
2769 *****************************************************************************/
2770
2771 CreateTableSpaceStmt: CREATE TABLESPACE name OptTableSpaceOwner LOCATION Sconst
2772 {
2773 CreateTableSpaceStmt *n = makeNode(CreateTableSpaceStmt);
2774 n->tablespacename = $3;
2775 n->owner = $4;
2776 n->location = $6;
2777 $$ = (Node *) n;
2778 }
2779 ;
2780
2781 OptTableSpaceOwner: OWNER name { $$ = $2; }
2782 | /*EMPTY */ { $$ = NULL; }
2783 ;
2784
2785 /*****************************************************************************
2786 *
2787 * QUERY :
2788 * DROP TABLESPACE <tablespace>
2789 *
2790 * No need for drop behaviour as we cannot implement dependencies for
2791 * objects in other databases; we can only support RESTRICT.
2792 *
2793 ****************************************************************************/
2794
2795 DropTableSpaceStmt: DROP TABLESPACE name
2796 {
2797 DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt);
2798 n->tablespacename = $3;
2799 n->missing_ok = false;
2800 $$ = (Node *) n;
2801 }
2802 | DROP TABLESPACE IF_P EXISTS name
2803 {
2804 DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt);
2805 n->tablespacename = $5;
2806 n->missing_ok = true;
2807 $$ = (Node *) n;
2808 }
2809 ;
2810
2811 /*****************************************************************************
2812 *
2813 * QUERY:
2814 * CREATE FOREIGN DATA WRAPPER name [ VALIDATOR name ]
2815 *
2816 *****************************************************************************/
2817
2818 CreateFdwStmt: CREATE FOREIGN DATA_P WRAPPER name opt_validator create_generic_options
2819 {
2820 CreateFdwStmt *n = makeNode(CreateFdwStmt);
2821 n->fdwname = $5;
2822 n->validator = $6;
2823 n->options = $7;
2824 $$ = (Node *) n;
2825 }
2826 ;
2827
2828 /*****************************************************************************
2829 *
2830 * QUERY :
2831 * DROP FOREIGN DATA WRAPPER name
2832 *
2833 ****************************************************************************/
2834
2835 DropFdwStmt: DROP FOREIGN DATA_P WRAPPER name opt_drop_behavior
2836 {
2837 DropFdwStmt *n = makeNode(DropFdwStmt);
2838 n->fdwname = $5;
2839 n->missing_ok = false;
2840 n->behavior = $6;
2841 $$ = (Node *) n;
2842 }
2843 | DROP FOREIGN DATA_P WRAPPER IF_P EXISTS name opt_drop_behavior
2844 {
2845 DropFdwStmt *n = makeNode(DropFdwStmt);
2846 n->fdwname = $7;
2847 n->missing_ok = true;
2848 n->behavior = $8;
2849 $$ = (Node *) n;
2850 }
2851 ;
2852
2853 /*****************************************************************************
2854 *
2855 * QUERY :
2856 * ALTER FOREIGN DATA WRAPPER name
2857 *
2858 ****************************************************************************/
2859
2860 AlterFdwStmt: ALTER FOREIGN DATA_P WRAPPER name validator_clause alter_generic_options
2861 {
2862 AlterFdwStmt *n = makeNode(AlterFdwStmt);
2863 n->fdwname = $5;
2864 n->validator = $6;
2865 n->change_validator = true;
2866 n->options = $7;
2867 $$ = (Node *) n;
2868 }
2869 | ALTER FOREIGN DATA_P WRAPPER name validator_clause
2870 {
2871 AlterFdwStmt *n = makeNode(AlterFdwStmt);
2872 n->fdwname = $5;
2873 n->validator = $6;
2874 n->change_validator = true;
2875 $$ = (Node *) n;
2876 }
2877 | ALTER FOREIGN DATA_P WRAPPER name alter_generic_options
2878 {
2879 AlterFdwStmt *n = makeNode(AlterFdwStmt);
2880 n->fdwname = $5;
2881 n->options = $6;
2882 $$ = (Node *) n;
2883 }
2884 ;
2885
2886 /* Options definition for CREATE FDW, SERVER and USER MAPPING */
2887 create_generic_options:
2888 OPTIONS '(' generic_option_list ')' { $$ = $3; }
2889 | /*EMPTY*/ { $$ = NIL; }
2890 ;
2891
2892 generic_option_list:
2893 generic_option_elem
2894 {
2895 $$ = list_make1($1);
2896 }
2897 | generic_option_list ',' generic_option_elem
2898 {
2899 $$ = lappend($1, $3);
2900 }
2901 ;
2902
2903 /* Options definition for ALTER FDW, SERVER and USER MAPPING */
2904 alter_generic_options:
2905 OPTIONS '(' alter_generic_option_list ')' { $$ = $3; }
2906 ;
2907
2908 alter_generic_option_list:
2909 alter_generic_option_elem
2910 {
2911 $$ = list_make1($1);
2912 }
2913 | alter_generic_option_list ',' alter_generic_option_elem
2914 {
2915 $$ = lappend($1, $3);
2916 }
2917 ;
2918
2919 alter_generic_option_elem:
2920 generic_option_elem
2921 {
2922 $$ = $1;
2923 }
2924 | SET generic_option_elem
2925 {
2926 $$ = $2;
2927 $$->defaction = DEFELEM_SET;
2928 }
2929 | ADD_P generic_option_elem
2930 {
2931 $$ = $2;
2932 $$->defaction = DEFELEM_ADD;
2933 }
2934 | DROP generic_option_name
2935 {
2936 $$ = makeDefElemExtended(NULL, $2, NULL, DEFELEM_DROP);
2937 }
2938 ;
2939
2940 generic_option_elem:
2941 generic_option_name generic_option_arg
2942 {
2943 $$ = makeDefElem($1, $2);
2944 }
2945 ;
2946
2947 generic_option_name:
2948 ColLabel { $$ = $1; }
2949 ;
2950
2951 /* We could use def_arg here, but the spec only requires string literals */
2952 generic_option_arg:
2953 Sconst { $$ = (Node *) makeString($1); }
2954 ;
2955
2956 /*****************************************************************************
2957 *
2958 * QUERY:
2959 * CREATE SERVER name [TYPE] [VERSION] [OPTIONS]
2960 *
2961 *****************************************************************************/
2962
2963 CreateForeignServerStmt: CREATE SERVER name opt_type opt_foreign_server_version
2964 FOREIGN DATA_P WRAPPER name create_generic_options
2965 {
2966 CreateForeignServerStmt *n = makeNode(CreateForeignServerStmt);
2967 n->servername = $3;
2968 n->servertype = $4;
2969 n->version = $5;
2970 n->fdwname = $9;
2971 n->options = $10;
2972 $$ = (Node *) n;
2973 }
2974 ;
2975
2976 opt_type:
2977 TYPE_P Sconst { $$ = $2; }
2978 | /*EMPTY*/ { $$ = NULL; }
2979 ;
2980
2981
2982 foreign_server_version:
2983 VERSION_P Sconst { $$ = $2; }
2984 | VERSION_P NULL_P { $$ = NULL; }
2985 ;
2986
2987 opt_foreign_server_version:
2988 foreign_server_version { $$ = $1; }
2989 | /*EMPTY*/ { $$ = NULL; }
2990 ;
2991
2992 /*****************************************************************************
2993 *
2994 * QUERY :
2995 * DROP SERVER name
2996 *
2997 ****************************************************************************/
2998
2999 DropForeignServerStmt: DROP SERVER name opt_drop_behavior
3000 {
3001 DropForeignServerStmt *n = makeNode(DropForeignServerStmt);
3002 n->servername = $3;
3003 n->missing_ok = false;
3004 n->behavior = $4;
3005 $$ = (Node *) n;
3006 }
3007 | DROP SERVER IF_P EXISTS name opt_drop_behavior
3008 {
3009 DropForeignServerStmt *n = makeNode(DropForeignServerStmt);
3010 n->servername = $5;
3011 n->missing_ok = true;
3012 n->behavior = $6;
3013 $$ = (Node *) n;
3014 }
3015 ;
3016
3017 /*****************************************************************************
3018 *
3019 * QUERY :
3020 * ALTER SERVER name [VERSION] [OPTIONS]
3021 *
3022 ****************************************************************************/
3023
3024 AlterForeignServerStmt: ALTER SERVER name foreign_server_version alter_generic_options
3025 {
3026 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
3027 n->servername = $3;
3028 n->version = $4;
3029 n->options = $5;
3030 n->has_version = true;
3031 $$ = (Node *) n;
3032 }
3033 | ALTER SERVER name foreign_server_version
3034 {
3035 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
3036 n->servername = $3;
3037 n->version = $4;
3038 n->has_version = true;
3039 $$ = (Node *) n;
3040 }
3041 | ALTER SERVER name alter_generic_options
3042 {
3043 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
3044 n->servername = $3;
3045 n->options = $4;
3046 $$ = (Node *) n;
3047 }
3048 ;
3049
3050 /*****************************************************************************
3051 *
3052 * QUERY:
3053 * CREATE USER MAPPING FOR auth_ident SERVER name [OPTIONS]
3054 *
3055 *****************************************************************************/
3056
3057 CreateUserMappingStmt: CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
3058 {
3059 CreateUserMappingStmt *n = makeNode(CreateUserMappingStmt);
3060 n->username = $5;
3061 n->servername = $7;
3062 n->options = $8;
3063 $$ = (Node *) n;
3064 }
3065 ;
3066
3067 /* User mapping authorization identifier */
3068 auth_ident:
3069 CURRENT_USER { $$ = "current_user"; }
3070 | USER { $$ = "current_user"; }
3071 | RoleId { $$ = (strcmp($1, "public") == 0) ? NULL : $1; }
3072 ;
3073
3074 /*****************************************************************************
3075 *
3076 * QUERY :
3077 * DROP USER MAPPING FOR auth_ident SERVER name
3078 *
3079 ****************************************************************************/
3080
3081 DropUserMappingStmt: DROP USER MAPPING FOR auth_ident SERVER name
3082 {
3083 DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
3084 n->username = $5;
3085 n->servername = $7;
3086 n->missing_ok = false;
3087 $$ = (Node *) n;
3088 }
3089 | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
3090 {
3091 DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
3092 n->username = $7;
3093 n->servername = $9;
3094 n->missing_ok = true;
3095 $$ = (Node *) n;
3096 }
3097 ;
3098
3099 /*****************************************************************************
3100 *
3101 * QUERY :
3102 * ALTER USER MAPPING FOR auth_ident SERVER name OPTIONS
3103 *
3104 ****************************************************************************/
3105
3106 AlterUserMappingStmt: ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
3107 {
3108 AlterUserMappingStmt *n = makeNode(AlterUserMappingStmt);
3109 n->username = $5;
3110 n->servername = $7;
3111 n->options = $8;
3112 $$ = (Node *) n;
3113 }
3114 ;
3115
3116 /*****************************************************************************
3117 *
3118 * QUERIES :
3119 * CREATE TRIGGER ...
3120 * DROP TRIGGER ...
3121 *
3122 *****************************************************************************/
3123
3124 CreateTrigStmt:
3125 CREATE TRIGGER name TriggerActionTime TriggerEvents ON
3126 qualified_name TriggerForSpec EXECUTE PROCEDURE
3127 func_name '(' TriggerFuncArgs ')'
3128 {
3129 CreateTrigStmt *n = makeNode(CreateTrigStmt);
3130 n->trigname = $3;
3131 n->relation = $7;
3132 n->funcname = $11;
3133 n->args = $13;
3134 n->before = $4;
3135 n->row = $8;
3136 n->events = $5;
3137 n->isconstraint = FALSE;
3138 n->deferrable = FALSE;
3139 n->initdeferred = FALSE;
3140 n->constrrel = NULL;
3141 $$ = (Node *)n;
3142 }
3143 | CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
3144 qualified_name OptConstrFromTable
3145 ConstraintAttributeSpec
3146 FOR EACH ROW EXECUTE PROCEDURE
3147 func_name '(' TriggerFuncArgs ')'
3148 {
3149 CreateTrigStmt *n = makeNode(CreateTrigStmt);
3150 n->trigname = $4;
3151 n->relation = $8;
3152 n->funcname = $16;
3153 n->args = $18;
3154 n->before = FALSE;
3155 n->row = TRUE;
3156 n->events = $6;
3157 n->isconstraint = TRUE;
3158 n->deferrable = ($10 & 1) != 0;
3159 n->initdeferred = ($10 & 2) != 0;
3160 n->constrrel = $9;
3161 $$ = (Node *)n;
3162 }
3163 ;
3164
3165 TriggerActionTime:
3166 BEFORE { $$ = TRUE; }
3167 | AFTER { $$ = FALSE; }
3168 ;
3169
3170 TriggerEvents:
3171 TriggerOneEvent
3172 { $$ = $1; }
3173 | TriggerEvents OR TriggerOneEvent
3174 {
3175 if ($1 & $3)
3176 yyerror("duplicate trigger events specified");
3177 $$ = $1 | $3;
3178 }
3179 ;
3180
3181 TriggerOneEvent:
3182 INSERT { $$ = TRIGGER_TYPE_INSERT; }
3183 | DELETE_P { $$ = TRIGGER_TYPE_DELETE; }
3184 | UPDATE { $$ = TRIGGER_TYPE_UPDATE; }
3185 | TRUNCATE { $$ = TRIGGER_TYPE_TRUNCATE; }
3186 ;
3187
3188 TriggerForSpec:
3189 FOR TriggerForOpt TriggerForType
3190 {
3191 $$ = $3;
3192 }
3193 | /* EMPTY */
3194 {
3195 /*
3196 * If ROW/STATEMENT not specified, default to
3197 * STATEMENT, per SQL
3198 */
3199 $$ = FALSE;
3200 }
3201 ;
3202
3203 TriggerForOpt:
3204 EACH {}
3205 | /*EMPTY*/ {}
3206 ;
3207
3208 TriggerForType:
3209 ROW { $$ = TRUE; }
3210 | STATEMENT { $$ = FALSE; }
3211 ;
3212
3213 TriggerFuncArgs:
3214 TriggerFuncArg { $$ = list_make1($1); }
3215 | TriggerFuncArgs ',' TriggerFuncArg { $$ = lappend($1, $3); }
3216 | /*EMPTY*/ { $$ = NIL; }
3217 ;
3218
3219 TriggerFuncArg:
3220 Iconst
3221 {
3222 char buf[64];
3223 snprintf(buf, sizeof(buf), "%d", $1);
3224 $$ = makeString(pstrdup(buf));
3225 }
3226 | FCONST { $$ = makeString($1); }
3227 | Sconst { $$ = makeString($1); }
3228 | BCONST { $$ = makeString($1); }
3229 | XCONST { $$ = makeString($1); }
3230 | ColId { $$ = makeString($1); }
3231 ;
3232
3233 OptConstrFromTable:
3234 FROM qualified_name { $$ = $2; }
3235 | /*EMPTY*/ { $$ = NULL; }
3236 ;
3237
3238 ConstraintAttributeSpec:
3239 ConstraintDeferrabilitySpec
3240 { $$ = $1; }
3241 | ConstraintDeferrabilitySpec ConstraintTimeSpec
3242 {
3243 if ($1 == 0 && $2 != 0)
3244 ereport(ERROR,
3245 (errcode(ERRCODE_SYNTAX_ERROR),
3246 errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
3247 scanner_errposition(@1)));
3248 $$ = $1 | $2;
3249 }
3250 | ConstraintTimeSpec
3251 {
3252 if ($1 != 0)
3253 $$ = 3;
3254 else
3255 $$ = 0;
3256 }
3257 | ConstraintTimeSpec ConstraintDeferrabilitySpec
3258 {
3259 if ($2 == 0 && $1 != 0)
3260 ereport(ERROR,
3261 (errcode(ERRCODE_SYNTAX_ERROR),
3262 errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
3263 scanner_errposition(@1)));
3264 $$ = $1 | $2;
3265 }
3266 | /*EMPTY*/
3267 { $$ = 0; }
3268 ;
3269
3270 ConstraintDeferrabilitySpec:
3271 NOT DEFERRABLE { $$ = 0; }
3272 | DEFERRABLE { $$ = 1; }
3273 ;
3274
3275 ConstraintTimeSpec:
3276 INITIALLY IMMEDIATE { $$ = 0; }
3277 | INITIALLY DEFERRED { $$ = 2; }
3278 ;
3279
3280
3281 DropTrigStmt:
3282 DROP TRIGGER name ON qualified_name opt_drop_behavior
3283 {
3284 DropPropertyStmt *n = makeNode(DropPropertyStmt);
3285 n->relation = $5;
3286 n->property = $3;
3287 n->behavior = $6;
3288 n->removeType = OBJECT_TRIGGER;
3289 n->missing_ok = false;
3290 $$ = (Node *) n;
3291 }
3292 | DROP TRIGGER IF_P EXISTS name ON qualified_name opt_drop_behavior
3293 {
3294 DropPropertyStmt *n = makeNode(DropPropertyStmt);
3295 n->relation = $7;
3296 n->property = $5;
3297 n->behavior = $8;
3298 n->removeType = OBJECT_TRIGGER;
3299 n->missing_ok = true;
3300 $$ = (Node *) n;
3301 }
3302 ;
3303
3304
3305 /*****************************************************************************
3306 *
3307 * QUERIES :
3308 * CREATE ASSERTION ...
3309 * DROP ASSERTION ...
3310 *
3311 *****************************************************************************/
3312
3313 CreateAssertStmt:
3314 CREATE ASSERTION name CHECK '(' a_expr ')'
3315 ConstraintAttributeSpec
3316 {
3317 CreateTrigStmt *n = makeNode(CreateTrigStmt);
3318 n->trigname = $3;
3319 n->args = list_make1($6);
3320 n->isconstraint = TRUE;
3321 n->deferrable = ($8 & 1) != 0;
3322 n->initdeferred = ($8 & 2) != 0;
3323
3324 ereport(ERROR,
3325 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3326 errmsg("CREATE ASSERTION is not yet implemented")));
3327
3328 $$ = (Node *)n;
3329 }
3330 ;
3331
3332 DropAssertStmt:
3333 DROP ASSERTION name opt_drop_behavior
3334 {
3335 DropPropertyStmt *n = makeNode(DropPropertyStmt);
3336 n->relation = NULL;
3337 n->property = $3;
3338 n->behavior = $4;
3339 n->removeType = OBJECT_TRIGGER; /* XXX */
3340 ereport(ERROR,
3341 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3342 errmsg("DROP ASSERTION is not yet implemented")));
3343 $$ = (Node *) n;
3344 }
3345 ;
3346
3347
3348 /*****************************************************************************
3349 *
3350 * QUERY :
3351 * define (aggregate,operator,type)
3352 *
3353 *****************************************************************************/
3354
3355 DefineStmt:
3356 CREATE AGGREGATE func_name aggr_args definition
3357 {
3358 DefineStmt *n = makeNode(DefineStmt);
3359 n->kind = OBJECT_AGGREGATE;
3360 n->oldstyle = false;
3361 n->defnames = $3;
3362 n->args = $4;
3363 n->definition = $5;
3364 $$ = (Node *)n;
3365 }
3366 | CREATE AGGREGATE func_name old_aggr_definition
3367 {
3368 /* old-style (pre-8.2) syntax for CREATE AGGREGATE */
3369 DefineStmt *n = makeNode(DefineStmt);
3370 n->kind = OBJECT_AGGREGATE;
3371 n->oldstyle = true;
3372 n->defnames = $3;
3373 n->args = NIL;
3374 n->definition = $4;
3375 $$ = (Node *)n;
3376 }
3377 | CREATE OPERATOR any_operator definition
3378 {
3379 DefineStmt *n = makeNode(DefineStmt);
3380 n->kind = OBJECT_OPERATOR;
3381 n->oldstyle = false;
3382 n->defnames = $3;
3383 n->args = NIL;
3384 n->definition = $4;
3385 $$ = (Node *)n;
3386 }
3387 | CREATE TYPE_P any_name definition
3388 {
3389 DefineStmt *n = makeNode(DefineStmt);
3390 n->kind = OBJECT_TYPE;
3391 n->oldstyle = false;
3392 n->defnames = $3;
3393 n->args = NIL;
3394 n->definition = $4;
3395 $$ = (Node *)n;
3396 }
3397 | CREATE TYPE_P any_name
3398 {
3399 /* Shell type (identified by lack of definition) */
3400 DefineStmt *n = makeNode(DefineStmt);
3401 n->kind = OBJECT_TYPE;
3402 n->oldstyle = false;
3403 n->defnames = $3;
3404 n->args = NIL;
3405 n->definition = NIL;
3406 $$ = (Node *)n;
3407 }
3408 | CREATE TYPE_P any_name AS '(' TableFuncElementList ')'
3409 {
3410 CompositeTypeStmt *n = makeNode(CompositeTypeStmt);
3411 RangeVar *r = makeNode(RangeVar);
3412
3413 /* can't use qualified_name, sigh */
3414 switch (list_length($3))
3415 {
3416 case 1:
3417 r->catalogname = NULL;
3418 r->schemaname = NULL;
3419 r->relname = strVal(linitial($3));
3420 break;
3421 case 2:
3422 r->catalogname = NULL;
3423 r->schemaname = strVal(linitial($3));
3424 r->relname = strVal(lsecond($3));
3425 break;
3426 case 3:
3427 r->catalogname = strVal(linitial($3));
3428 r->schemaname = strVal(lsecond($3));
3429 r->relname = strVal(lthird($3));
3430 break;
3431 default:
3432 ereport(ERROR,
3433 (errcode(ERRCODE_SYNTAX_ERROR),
3434 errmsg("improper qualified name (too many dotted names): %s",
3435 NameListToString($3)),
3436 scanner_errposition(@3)));
3437 break;
3438 }
3439 r->location = @3;
3440 n->typevar = r;
3441 n->coldeflist = $6;
3442 $$ = (Node *)n;
3443 }
3444 | CREATE TYPE_P any_name AS ENUM_P '(' enum_val_list ')'
3445 {
3446 CreateEnumStmt *n = makeNode(CreateEnumStmt);
3447 n->typename = $3;
3448 n->vals = $7;
3449 $$ = (Node *)n;
3450 }
3451 | CREATE TEXT_P SEARCH PARSER any_name definition
3452 {
3453 DefineStmt *n = makeNode(DefineStmt);
3454 n->kind = OBJECT_TSPARSER;
3455 n->args = NIL;
3456 n->defnames = $5;
3457 n->definition = $6;
3458 $$ = (Node *)n;
3459 }
3460 | CREATE TEXT_P SEARCH DICTIONARY any_name definition
3461 {
3462 DefineStmt *n = makeNode(DefineStmt);
3463 n->kind = OBJECT_TSDICTIONARY;
3464 n->args = NIL;
3465 n->defnames = $5;
3466 n->definition = $6;
3467 $$ = (Node *)n;
3468 }
3469 | CREATE TEXT_P SEARCH TEMPLATE any_name definition
3470 {
3471 DefineStmt *n = makeNode(DefineStmt);
3472 n->kind = OBJECT_TSTEMPLATE;
3473 n->args = NIL;
3474 n->defnames = $5;
3475 n->definition = $6;
3476 $$ = (Node *)n;
3477 }
3478 | CREATE TEXT_P SEARCH CONFIGURATION any_name definition
3479 {
3480 DefineStmt *n = makeNode(DefineStmt);
3481 n->kind = OBJECT_TSCONFIGURATION;
3482 n->args = NIL;
3483 n->defnames = $5;
3484 n->definition = $6;
3485 $$ = (Node *)n;
3486 }
3487 ;
3488
3489 definition: '(' def_list ')' { $$ = $2; }
3490 ;
3491
3492 def_list: def_elem { $$ = list_make1($1); }
3493 | def_list ',' def_elem { $$ = lappend($1, $3); }
3494 ;
3495
3496 def_elem: ColLabel '=' def_arg
3497 {
3498 $$ = makeDefElem($1, (Node *) $3);
3499 }
3500 | ColLabel
3501 {
3502 $$ = makeDefElem($1, NULL);
3503 }
3504 ;
3505
3506 /* Note: any simple identifier will be returned as a type name! */
3507 def_arg: func_type { $$ = (Node *)$1; }
3508 | reserved_keyword { $$ = (Node *)makeString(pstrdup($1)); }
3509 | qual_all_Op { $$ = (Node *)$1; }
3510 | NumericOnly { $$ = (Node *)$1; }
3511 | Sconst { $$ = (Node *)makeString($1); }
3512 ;
3513
3514 aggr_args: '(' type_list ')' { $$ = $2; }
3515 | '(' '*' ')' { $$ = NIL; }
3516 ;
3517
3518 old_aggr_definition: '(' old_aggr_list ')' { $$ = $2; }
3519 ;
3520
3521 old_aggr_list: old_aggr_elem { $$ = list_make1($1); }
3522 | old_aggr_list ',' old_aggr_elem { $$ = lappend($1, $3); }
3523 ;
3524
3525 /*
3526 * Must use IDENT here to avoid reduce/reduce conflicts; fortunately none of
3527 * the item names needed in old aggregate definitions are likely to become
3528 * SQL keywords.
3529 */
3530 old_aggr_elem: IDENT '=' def_arg
3531 {
3532 $$ = makeDefElem($1, (Node *)$3);
3533 }
3534 ;
3535
3536 enum_val_list: Sconst
3537 { $$ = list_make1(makeString($1)); }
3538 | enum_val_list ',' Sconst
3539 { $$ = lappend($1, makeString($3)); }
3540 ;
3541
3542
3543 /*****************************************************************************
3544 *
3545 * QUERIES :
3546 * CREATE OPERATOR CLASS ...
3547 * CREATE OPERATOR FAMILY ...
3548 * ALTER OPERATOR FAMILY ...
3549 * DROP OPERATOR CLASS ...
3550 * DROP OPERATOR FAMILY ...
3551 *
3552 *****************************************************************************/
3553
3554 CreateOpClassStmt:
3555 CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename
3556 USING access_method opt_opfamily AS opclass_item_list
3557 {
3558 CreateOpClassStmt *n = makeNode(CreateOpClassStmt);
3559 n->opclassname = $4;
3560 n->isDefault = $5;
3561 n->datatype = $8;
3562 n->amname = $10;
3563 n->opfamilyname = $11;
3564 n->items = $13;
3565 $$ = (Node *) n;
3566 }
3567 ;
3568
3569 opclass_item_list:
3570 opclass_item { $$ = list_make1($1); }
3571 | opclass_item_list ',' opclass_item { $$ = lappend($1, $3); }
3572 ;
3573
3574 opclass_item:
3575 OPERATOR Iconst any_operator opt_recheck
3576 {
3577 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3578 n->itemtype = OPCLASS_ITEM_OPERATOR;
3579 n->name = $3;
3580 n->args = NIL;
3581 n->number = $2;
3582 $$ = (Node *) n;
3583 }
3584 | OPERATOR Iconst any_operator oper_argtypes opt_recheck
3585 {
3586 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3587 n->itemtype = OPCLASS_ITEM_OPERATOR;
3588 n->name = $3;
3589 n->args = $4;
3590 n->number = $2;
3591 $$ = (Node *) n;
3592 }
3593 | FUNCTION Iconst func_name func_args
3594 {
3595 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3596 n->itemtype = OPCLASS_ITEM_FUNCTION;
3597 n->name = $3;
3598 n->args = extractArgTypes($4);
3599 n->number = $2;
3600 $$ = (Node *) n;
3601 }
3602 | FUNCTION Iconst '(' type_list ')' func_name func_args
3603 {
3604 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3605 n->itemtype = OPCLASS_ITEM_FUNCTION;
3606 n->name = $6;
3607 n->args = extractArgTypes($7);
3608 n->number = $2;
3609 n->class_args = $4;
3610 $$ = (Node *) n;
3611 }
3612 | STORAGE Typename
3613 {
3614 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3615 n->itemtype = OPCLASS_ITEM_STORAGETYPE;
3616 n->storedtype = $2;
3617 $$ = (Node *) n;
3618 }
3619 ;
3620
3621 opt_default: DEFAULT { $$ = TRUE; }
3622 | /*EMPTY*/ { $$ = FALSE; }
3623 ;
3624
3625 opt_opfamily: FAMILY any_name { $$ = $2; }
3626 | /*EMPTY*/ { $$ = NIL; }
3627 ;
3628
3629 opt_recheck: RECHECK
3630 {
3631 /*
3632 * RECHECK no longer does anything in opclass definitions,
3633 * but we still accept it to ease porting of old database
3634 * dumps.
3635 */
3636 ereport(NOTICE,
3637 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3638 errmsg("RECHECK is no longer required"),
3639 errhint("Update your data type."),
3640 scanner_errposition(@1)));
3641 $$ = TRUE;
3642 }
3643 | /*EMPTY*/ { $$ = FALSE; }
3644 ;
3645
3646
3647 CreateOpFamilyStmt:
3648 CREATE OPERATOR FAMILY any_name USING access_method
3649 {
3650 CreateOpFamilyStmt *n = makeNode(CreateOpFamilyStmt);
3651 n->opfamilyname = $4;
3652 n->amname = $6;
3653 $$ = (Node *) n;
3654 }
3655 ;
3656
3657 AlterOpFamilyStmt:
3658 ALTER OPERATOR FAMILY any_name USING access_method ADD_P opclass_item_list
3659 {
3660 AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt);
3661 n->opfamilyname = $4;
3662 n->amname = $6;
3663 n->isDrop = false;
3664 n->items = $8;
3665 $$ = (Node *) n;
3666 }
3667 | ALTER OPERATOR FAMILY any_name USING access_method DROP opclass_drop_list
3668 {
3669 AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt);
3670 n->opfamilyname = $4;
3671 n->amname = $6;
3672 n->isDrop = true;
3673 n->items = $8;
3674 $$ = (Node *) n;
3675 }
3676 ;
3677
3678 opclass_drop_list:
3679 opclass_drop { $$ = list_make1($1); }
3680 | opclass_drop_list ',' opclass_drop { $$ = lappend($1, $3); }
3681 ;
3682
3683 opclass_drop:
3684 OPERATOR Iconst '(' type_list ')'
3685 {
3686 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3687 n->itemtype = OPCLASS_ITEM_OPERATOR;
3688 n->number = $2;
3689 n->args = $4;
3690 $$ = (Node *) n;
3691 }
3692 | FUNCTION Iconst '(' type_list ')'
3693 {
3694 CreateOpClassItem *n = makeNode(CreateOpClassItem);
3695 n->itemtype = OPCLASS_ITEM_FUNCTION;
3696 n->number = $2;
3697 n->args = $4;
3698 $$ = (Node *) n;
3699 }
3700 ;
3701
3702
3703 DropOpClassStmt:
3704 DROP OPERATOR CLASS any_name USING access_method opt_drop_behavior
3705 {
3706 RemoveOpClassStmt *n = makeNode(RemoveOpClassStmt);
3707 n->opclassname = $4;
3708 n->amname = $6;
3709 n->behavior = $7;
3710 n->missing_ok = false;
3711 $$ = (Node *) n;
3712 }
3713 | DROP OPERATOR CLASS IF_P EXISTS any_name USING access_method opt_drop_behavior
3714 {
3715 RemoveOpClassStmt *n = makeNode(RemoveOpClassStmt);
3716 n->opclassname = $6;
3717 n->amname = $8;
3718 n->behavior = $9;
3719 n->missing_ok = true;
3720 $$ = (Node *) n;
3721 }
3722 ;
3723
3724 DropOpFamilyStmt:
3725 DROP OPERATOR FAMILY any_name USING access_method opt_drop_behavior
3726 {
3727 RemoveOpFamilyStmt *n = makeNode(RemoveOpFamilyStmt);
3728 n->opfamilyname = $4;
3729 n->amname = $6;
3730 n->behavior = $7;
3731 n->missing_ok = false;
3732 $$ = (Node *) n;
3733 }
3734 | DROP OPERATOR FAMILY IF_P EXISTS any_name USING access_method opt_drop_behavior
3735 {
3736 RemoveOpFamilyStmt *n = makeNode(RemoveOpFamilyStmt);
3737 n->opfamilyname = $6;
3738 n->amname = $8;
3739 n->behavior = $9;
3740 n->missing_ok = true;
3741 $$ = (Node *) n;
3742 }
3743 ;
3744
3745
3746 /*****************************************************************************
3747 *
3748 * QUERY:
3749 *
3750 * DROP OWNED BY username [, username ...] [ RESTRICT | CASCADE ]
3751 * REASSIGN OWNED BY username [, username ...] TO username
3752 *
3753 *****************************************************************************/
3754 DropOwnedStmt:
3755 DROP OWNED BY name_list opt_drop_behavior
3756 {
3757 DropOwnedStmt *n = makeNode(DropOwnedStmt);
3758 n->roles = $4;
3759 n->behavior = $5;
3760 $$ = (Node *)n;
3761 }
3762 ;
3763
3764 ReassignOwnedStmt:
3765 REASSIGN OWNED BY name_list TO name
3766 {
3767 ReassignOwnedStmt *n = makeNode(ReassignOwnedStmt);
3768 n->roles = $4;
3769 n->newrole = $6;
3770 $$ = (Node *)n;
3771 }
3772 ;
3773
3774 /*****************************************************************************
3775 *
3776 * QUERY:
3777 *
3778 * DROP itemtype [ IF EXISTS ] itemname [, itemname ...]
3779 * [ RESTRICT | CASCADE ]
3780 *
3781 *****************************************************************************/
3782
3783 DropStmt: DROP drop_type IF_P EXISTS any_name_list opt_drop_behavior
3784 {
3785 DropStmt *n = makeNode(DropStmt);
3786 n->removeType = $2;
3787 n->missing_ok = TRUE;
3788 n->objects = $5;
3789 n->behavior = $6;
3790 $$ = (Node *)n;
3791 }
3792 | DROP drop_type any_name_list opt_drop_behavior
3793 {
3794 DropStmt *n = makeNode(DropStmt);
3795 n->removeType = $2;
3796 n->missing_ok = FALSE;
3797 n->objects = $3;
3798 n->behavior = $4;
3799 $$ = (Node *)n;
3800 }
3801 ;
3802
3803
3804 drop_type: TABLE { $$ = OBJECT_TABLE; }
3805 | SEQUENCE { $$ = OBJECT_SEQUENCE; }
3806 | VIEW { $$ = OBJECT_VIEW; }
3807 | INDEX { $$ = OBJECT_INDEX; }
3808 | TYPE_P { $$ = OBJECT_TYPE; }
3809 | DOMAIN_P { $$ = OBJECT_DOMAIN; }
3810 | CONVERSION_P { $$ = OBJECT_CONVERSION; }
3811 | SCHEMA { $$ = OBJECT_SCHEMA; }
3812 | TEXT_P SEARCH PARSER { $$ = OBJECT_TSPARSER; }
3813 | TEXT_P SEARCH DICTIONARY { $$ = OBJECT_TSDICTIONARY; }
3814 | TEXT_P SEARCH TEMPLATE { $$ = OBJECT_TSTEMPLATE; }
3815 | TEXT_P SEARCH CONFIGURATION { $$ = OBJECT_TSCONFIGURATION; }
3816 ;
3817
3818 any_name_list:
3819 any_name { $$ = list_make1($1); }
3820 | any_name_list ',' any_name { $$ = lappend($1, $3); }
3821 ;
3822
3823 any_name: ColId { $$ = list_make1(makeString($1)); }
3824 | ColId attrs { $$ = lcons(makeString($1), $2); }
3825 ;
3826
3827 attrs: '.' attr_name
3828 { $$ = list_make1(makeString($2)); }
3829 | attrs '.' attr_name
3830 { $$ = lappend($1, makeString($3)); }
3831 ;
3832
3833
3834 /*****************************************************************************
3835 *
3836 * QUERY:
3837 * truncate table relname1, relname2, ...
3838 *
3839 *****************************************************************************/
3840
3841 TruncateStmt:
3842 TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior
3843 {
3844 TruncateStmt *n = makeNode(TruncateStmt);
3845 n->relations = $3;
3846 n->restart_seqs = $4;
3847 n->behavior = $5;
3848 $$ = (Node *)n;
3849 }
3850 ;
3851
3852 opt_restart_seqs:
3853 CONTINUE_P IDENTITY_P { $$ = false; }
3854 | RESTART IDENTITY_P { $$ = true; }
3855 | /* EMPTY */ { $$ = false; }
3856 ;
3857
3858 /*****************************************************************************
3859 *
3860 * The COMMENT ON statement can take different forms based upon the type of
3861 * the object associated with the comment. The form of the statement is:
3862 *
3863 * COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW |
3864 * CONVERSION | LANGUAGE | OPERATOR CLASS | LARGE OBJECT |
3865 * CAST | COLUMN | SCHEMA | TABLESPACE | ROLE |
3866 * TEXT SEARCH PARSER | TEXT SEARCH DICTIONARY |
3867 * TEXT SEARCH TEMPLATE |
3868 * TEXT SEARCH CONFIGURATION ] <objname> |
3869 * AGGREGATE <aggname> (arg1, ...) |
3870 * FUNCTION <funcname> (arg1, arg2, ...) |
3871 * OPERATOR <op> (leftoperand_typ, rightoperand_typ) |
3872 * TRIGGER <triggername> ON <relname> |
3873 * CONSTRAINT <constraintname> ON <relname> |
3874 * RULE <rulename> ON <relname> ]
3875 * IS 'text'
3876 *
3877 *****************************************************************************/
3878
3879 CommentStmt:
3880 COMMENT ON comment_type any_name IS comment_text
3881 {
3882 CommentStmt *n = makeNode(CommentStmt);
3883 n->objtype = $3;
3884 n->objname = $4;
3885 n->objargs = NIL;
3886 n->comment = $6;
3887 $$ = (Node *) n;
3888 }
3889 | COMMENT ON AGGREGATE func_name aggr_args IS comment_text
3890 {
3891 CommentStmt *n = makeNode(CommentStmt);
3892 n->objtype = OBJECT_AGGREGATE;
3893 n->objname = $4;
3894 n->objargs = $5;
3895 n->comment = $7;
3896 $$ = (Node *) n;
3897 }
3898 | COMMENT ON FUNCTION func_name func_args IS comment_text
3899 {
3900 CommentStmt *n = makeNode(CommentStmt);
3901 n->objtype = OBJECT_FUNCTION;
3902 n->objname = $4;
3903 n->objargs = extractArgTypes($5);
3904 n->comment = $7;
3905 $$ = (Node *) n;
3906 }
3907 | COMMENT ON OPERATOR any_operator oper_argtypes IS comment_text
3908 {
3909 CommentStmt *n = makeNode(CommentStmt);
3910 n->objtype = OBJECT_OPERATOR;
3911 n->objname = $4;
3912 n->objargs = $5;
3913 n->comment = $7;
3914 $$ = (Node *) n;
3915 }
3916 | COMMENT ON CONSTRAINT name ON any_name IS comment_text
3917 {
3918 CommentStmt *n = makeNode(CommentStmt);
3919 n->objtype = OBJECT_CONSTRAINT;
3920 n->objname = lappend($6, makeString($4));
3921 n->objargs = NIL;
3922 n->comment = $8;
3923 $$ = (Node *) n;
3924 }
3925 | COMMENT ON RULE name ON any_name IS comment_text
3926 {
3927 CommentStmt *n = makeNode(CommentStmt);
3928 n->objtype = OBJECT_RULE;
3929 n->objname = lappend($6, makeString($4));
3930 n->objargs = NIL;
3931 n->comment = $8;
3932 $$ = (Node *) n;
3933 }
3934 | COMMENT ON RULE name IS comment_text
3935 {
3936 /* Obsolete syntax supported for awhile for compatibility */
3937 CommentStmt *n = makeNode(CommentStmt);
3938 n->objtype = OBJECT_RULE;
3939 n->objname = list_make1(makeString($4));
3940 n->objargs = NIL;
3941 n->comment = $6;
3942 $$ = (Node *) n;
3943 }
3944 | COMMENT ON TRIGGER name ON any_name IS comment_text
3945 {
3946 CommentStmt *n = makeNode(CommentStmt);
3947 n->objtype = OBJECT_TRIGGER;
3948 n->objname = lappend($6, makeString($4));
3949 n->objargs = NIL;
3950 n->comment = $8;
3951 $$ = (Node *) n;
3952 }
3953 | COMMENT ON OPERATOR CLASS any_name USING access_method IS comment_text
3954 {
3955 CommentStmt *n = makeNode(CommentStmt);
3956 n->objtype = OBJECT_OPCLASS;
3957 n->objname = $5;
3958 n->objargs = list_make1(makeString($7));
3959 n->comment = $9;
3960 $$ = (Node *) n;
3961 }
3962 | COMMENT ON OPERATOR FAMILY any_name USING access_method IS comment_text
3963 {
3964 CommentStmt *n = makeNode(CommentStmt);
3965 n->objtype = OBJECT_OPFAMILY;
3966 n->objname = $5;
3967 n->objargs = list_make1(makeString($7));
3968 n->comment = $9;
3969 $$ = (Node *) n;
3970 }
3971 | COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
3972 {
3973 CommentStmt *n = makeNode(CommentStmt);
3974 n->objtype = OBJECT_LARGEOBJECT;
3975 n->objname = list_make1($5);
3976 n->objargs = NIL;
3977 n->comment = $7;
3978 $$ = (Node *) n;
3979 }
3980 | COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
3981 {
3982 CommentStmt *n = makeNode(CommentStmt);
3983 n->objtype = OBJECT_CAST;
3984 n->objname = list_make1($5);
3985 n->objargs = list_make1($7);
3986 n->comment = $10;
3987 $$ = (Node *) n;
3988 }
3989 | COMMENT ON opt_procedural LANGUAGE any_name IS comment_text
3990 {
3991 CommentStmt *n = makeNode(CommentStmt);
3992 n->objtype = OBJECT_LANGUAGE;
3993 n->objname = $5;
3994 n->objargs = NIL;
3995 n->comment = $7;
3996 $$ = (Node *) n;
3997 }
3998 | COMMENT ON TEXT_P SEARCH PARSER any_name IS comment_text
3999 {
4000 CommentStmt *n = makeNode(CommentStmt);
4001 n->objtype = OBJECT_TSPARSER;
4002 n->objname = $6;
4003 n->comment = $8;
4004 $$ = (Node *) n;
4005 }
4006 | COMMENT ON TEXT_P SEARCH DICTIONARY any_name IS comment_text
4007 {
4008 CommentStmt *n = makeNode(CommentStmt);
4009 n->objtype = OBJECT_TSDICTIONARY;
4010 n->objname = $6;
4011 n->comment = $8;
4012 $$ = (Node *) n;
4013 }
4014 | COMMENT ON TEXT_P SEARCH TEMPLATE any_name IS comment_text
4015 {
4016 CommentStmt *n = makeNode(CommentStmt);
4017 n->objtype = OBJECT_TSTEMPLATE;
4018 n->objname = $6;
4019 n->comment = $8;
4020 $$ = (Node *) n;
4021 }
4022 | COMMENT ON TEXT_P SEARCH CONFIGURATION any_name IS comment_text
4023 {
4024 CommentStmt *n = makeNode(CommentStmt);
4025 n->objtype = OBJECT_TSCONFIGURATION;
4026 n->objname = $6;
4027 n->comment = $8;
4028 $$ = (Node *) n;
4029 }
4030 ;
4031
4032 comment_type:
4033 COLUMN { $$ = OBJECT_COLUMN; }
4034 | DATABASE { $$ = OBJECT_DATABASE; }
4035 | SCHEMA { $$ = OBJECT_SCHEMA; }
4036 | INDEX { $$ = OBJECT_INDEX; }
4037 | SEQUENCE { $$ = OBJECT_SEQUENCE; }
4038 | TABLE { $$ = OBJECT_TABLE; }
4039 | DOMAIN_P { $$ = OBJECT_TYPE; }
4040 | TYPE_P { $$ = OBJECT_TYPE; }
4041 | VIEW { $$ = OBJECT_VIEW; }
4042 | CONVERSION_P { $$ = OBJECT_CONVERSION; }
4043 | TABLESPACE { $$ = OBJECT_TABLESPACE; }
4044 | ROLE { $$ = OBJECT_ROLE; }
4045 ;
4046
4047 comment_text:
4048 Sconst { $$ = $1; }
4049 | NULL_P { $$ = NULL; }
4050 ;
4051
4052 /*****************************************************************************
4053 *
4054 * QUERY:
4055 * fetch/move
4056 *
4057 *****************************************************************************/
4058
4059 FetchStmt: FETCH fetch_direction from_in name
4060 {
4061 FetchStmt *n = (FetchStmt *) $2;
4062 n->portalname = $4;
4063 n->ismove = FALSE;
4064 $$ = (Node *)n;
4065 }
4066 | FETCH name
4067 {
4068 FetchStmt *n = makeNode(FetchStmt);
4069 n->direction = FETCH_FORWARD;
4070 n->howMany = 1;
4071 n->portalname = $2;
4072 n->ismove = FALSE;
4073 $$ = (Node *)n;
4074 }
4075 | MOVE fetch_direction from_in name
4076 {
4077 FetchStmt *n = (FetchStmt *) $2;
4078 n->portalname = $4;
4079 n->ismove = TRUE;
4080 $$ = (Node *)n;
4081 }
4082 | MOVE name
4083 {
4084 FetchStmt *n = makeNode(FetchStmt);
4085 n->direction = FETCH_FORWARD;
4086 n->howMany = 1;
4087 n->portalname = $2;
4088 n->ismove = TRUE;
4089 $$ = (Node *)n;
4090 }
4091 ;
4092
4093 fetch_direction:
4094 /*EMPTY*/
4095 {
4096 FetchStmt *n = makeNode(FetchStmt);
4097 n->direction = FETCH_FORWARD;
4098 n->howMany = 1;
4099 $$ = (Node *)n;
4100 }
4101 | NEXT
4102 {
4103 FetchStmt *n = makeNode(FetchStmt);
4104 n->direction = FETCH_FORWARD;
4105 n->howMany = 1;
4106 $$ = (Node *)n;
4107 }
4108 | PRIOR
4109 {
4110 FetchStmt *n = makeNode(FetchStmt);
4111 n->direction = FETCH_BACKWARD;
4112 n->howMany = 1;
4113 $$ = (Node *)n;
4114 }
4115 | FIRST_P
4116 {
4117 FetchStmt *n = makeNode(FetchStmt);
4118 n->direction = FETCH_ABSOLUTE;
4119 n->howMany = 1;
4120 $$ = (Node *)n;
4121 }
4122 | LAST_P
4123 {
4124 FetchStmt *n = makeNode(FetchStmt);
4125 n->direction = FETCH_ABSOLUTE;
4126 n->howMany = -1;
4127 $$ = (Node *)n;
4128 }
4129 | ABSOLUTE_P SignedIconst
4130 {
4131 FetchStmt *n = makeNode(FetchStmt);
4132 n->direction = FETCH_ABSOLUTE;
4133 n->howMany = $2;
4134 $$ = (Node *)n;
4135 }
4136 | RELATIVE_P SignedIconst
4137 {
4138 FetchStmt *n = makeNode(FetchStmt);
4139 n->direction = FETCH_RELATIVE;
4140 n->howMany = $2;
4141 $$ = (Node *)n;
4142 }
4143 | SignedIconst
4144 {
4145 FetchStmt *n = makeNode(FetchStmt);
4146 n->direction = FETCH_FORWARD;
4147 n->howMany = $1;
4148 $$ = (Node *)n;
4149 }
4150 | ALL
4151 {
4152 FetchStmt *n = makeNode(FetchStmt);
4153 n->direction = FETCH_FORWARD;
4154 n->howMany = FETCH_ALL;
4155 $$ = (Node *)n;
4156 }
4157 | FORWARD
4158 {
4159 FetchStmt *n = makeNode(FetchStmt);
4160 n->direction = FETCH_FORWARD;
4161 n->howMany = 1;
4162 $$ = (Node *)n;
4163 }
4164 | FORWARD SignedIconst
4165 {
4166 FetchStmt *n = makeNode(FetchStmt);
4167 n->direction = FETCH_FORWARD;
4168 n->howMany = $2;
4169 $$ = (Node *)n;
4170 }
4171 | FORWARD ALL
4172 {
4173 FetchStmt *n = makeNode(FetchStmt);
4174 n->direction = FETCH_FORWARD;
4175 n->howMany = FETCH_ALL;
4176 $$ = (Node *)n;
4177 }
4178 | BACKWARD
4179 {
4180 FetchStmt *n = makeNode(FetchStmt);
4181 n->direction = FETCH_BACKWARD;
4182 n->howMany = 1;
4183 $$ = (Node *)n;
4184 }
4185 | BACKWARD SignedIconst
4186 {
4187 FetchStmt *n = makeNode(FetchStmt);
4188 n->direction = FETCH_BACKWARD;
4189 n->howMany = $2;
4190 $$ = (Node *)n;
4191 }
4192 | BACKWARD ALL
4193 {
4194 FetchStmt *n = makeNode(FetchStmt);
4195 n->direction = FETCH_BACKWARD;
4196 n->howMany = FETCH_ALL;
4197 $$ = (Node *)n;
4198 }
4199 ;
4200
4201 from_in: FROM {}
4202 | IN_P {}
4203 ;
4204
4205
4206 /*****************************************************************************
4207 *
4208 * GRANT and REVOKE statements
4209 *
4210 *****************************************************************************/
4211
4212 GrantStmt: GRANT privileges ON privilege_target TO grantee_list
4213 opt_grant_grant_option
4214 {
4215 GrantStmt *n = makeNode(GrantStmt);
4216 n->is_grant = true;
4217 n->privileges = $2;
4218 n->objtype = ($4)->objtype;
4219 n->objects = ($4)->objs;
4220 n->grantees = $6;
4221 n->grant_option = $7;
4222 $$ = (Node*)n;
4223 }
4224 ;
4225
4226 RevokeStmt:
4227 REVOKE privileges ON privilege_target
4228 FROM grantee_list opt_drop_behavior
4229 {
4230 GrantStmt *n = makeNode(GrantStmt);
4231 n->is_grant = false;
4232 n->grant_option = false;
4233 n->privileges = $2;
4234 n->objtype = ($4)->objtype;
4235 n->objects = ($4)->objs;
4236 n->grantees = $6;
4237 n->behavior = $7;
4238 $$ = (Node *)n;
4239 }
4240 | REVOKE GRANT OPTION FOR privileges ON privilege_target
4241 FROM grantee_list opt_drop_behavior
4242 {
4243 GrantStmt *n = makeNode(GrantStmt);
4244 n->is_grant = false;
4245 n->grant_option = true;
4246 n->privileges = $5;
4247 n->objtype = ($7)->objtype;
4248 n->objects = ($7)->objs;
4249 n->grantees = $9;
4250 n->behavior = $10;
4251 $$ = (Node *)n;
4252 }
4253 ;
4254
4255
4256 /*
4257 * Privilege names are represented as strings; the validity of the privilege
4258 * names gets checked at execution. This is a bit annoying but we have little
4259 * choice because of the syntactic conflict with lists of role names in
4260 * GRANT/REVOKE. What's more, we have to call out in the "privilege"
4261 * production any reserved keywords that need to be usable as privilege names.
4262 */
4263
4264 /* either ALL [PRIVILEGES] or a list of individual privileges */
4265 privileges: privilege_list
4266 { $$ = $1; }
4267 | ALL
4268 { $$ = NIL; }
4269 | ALL PRIVILEGES
4270 { $$ = NIL; }
4271 | ALL '(' columnList ')'
4272 {
4273 AccessPriv *n = makeNode(AccessPriv);
4274 n->priv_name = NULL;
4275 n->cols = $3;
4276 $$ = list_make1(n);
4277 }
4278 | ALL PRIVILEGES '(' columnList ')'
4279 {
4280 AccessPriv *n = makeNode(AccessPriv);
4281 n->priv_name = NULL;
4282 n->cols = $4;
4283 $$ = list_make1(n);
4284 }
4285 ;
4286
4287 privilege_list: privilege { $$ = list_make1($1); }
4288 | privilege_list ',' privilege { $$ = lappend($1, $3); }
4289 ;
4290
4291 privilege: SELECT opt_column_list
4292 {
4293 AccessPriv *n = makeNode(AccessPriv);
4294 n->priv_name = pstrdup($1);
4295 n->cols = $2;
4296 $$ = n;
4297 }
4298 | REFERENCES opt_column_list
4299 {
4300 AccessPriv *n = makeNode(AccessPriv);
4301 n->priv_name = pstrdup($1);
4302 n->cols = $2;
4303 $$ = n;
4304 }
4305 | CREATE opt_column_list
4306 {
4307 AccessPriv *n = makeNode(AccessPriv);
4308 n->priv_name = pstrdup($1);
4309 n->cols = $2;
4310 $$ = n;
4311 }
4312 | ColId opt_column_list
4313 {
4314 AccessPriv *n = makeNode(AccessPriv);
4315 n->priv_name = $1;
4316 n->cols = $2;
4317 $$ = n;
4318 }
4319 ;
4320
4321
4322 /* Don't bother trying to fold the first two rules into one using
4323 * opt_table. You're going to get conflicts.
4324 */
4325 privilege_target:
4326 qualified_name_list
4327 {
4328 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4329 n->objtype = ACL_OBJECT_RELATION;
4330 n->objs = $1;
4331 $$ = n;
4332 }
4333 | TABLE qualified_name_list
4334 {
4335 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4336 n->objtype = ACL_OBJECT_RELATION;
4337 n->objs = $2;
4338 $$ = n;
4339 }
4340 | SEQUENCE qualified_name_list
4341 {
4342 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4343 n->objtype = ACL_OBJECT_SEQUENCE;
4344 n->objs = $2;
4345 $$ = n;
4346 }
4347 | FOREIGN DATA_P WRAPPER name_list
4348 {
4349 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4350 n->objtype = ACL_OBJECT_FDW;
4351 n->objs = $4;
4352 $$ = n;
4353 }
4354 | FOREIGN SERVER name_list
4355 {
4356 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4357 n->objtype = ACL_OBJECT_FOREIGN_SERVER;
4358 n->objs = $3;
4359 $$ = n;
4360 }
4361 | FUNCTION function_with_argtypes_list
4362 {
4363 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4364 n->objtype = ACL_OBJECT_FUNCTION;
4365 n->objs = $2;
4366 $$ = n;
4367 }
4368 | DATABASE name_list
4369 {
4370 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4371 n->objtype = ACL_OBJECT_DATABASE;
4372 n->objs = $2;
4373 $$ = n;
4374 }
4375 | LANGUAGE name_list
4376 {
4377 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4378 n->objtype = ACL_OBJECT_LANGUAGE;
4379 n->objs = $2;
4380 $$ = n;
4381 }
4382 | SCHEMA name_list
4383 {
4384 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4385 n->objtype = ACL_OBJECT_NAMESPACE;
4386 n->objs = $2;
4387 $$ = n;
4388 }
4389 | TABLESPACE name_list
4390 {
4391 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget));
4392 n->objtype = ACL_OBJECT_TABLESPACE;
4393 n->objs = $2;
4394 $$ = n;
4395 }
4396 ;
4397
4398
4399 grantee_list:
4400 grantee { $$ = list_make1($1); }
4401 | grantee_list ',' grantee { $$ = lappend($1, $3); }
4402 ;
4403
4404 grantee: RoleId
4405 {
4406 PrivGrantee *n = makeNode(PrivGrantee);
4407 /* This hack lets us avoid reserving PUBLIC as a keyword*/
4408 if (strcmp($1, "public") == 0)
4409 n->rolname = NULL;
4410 else
4411 n->rolname = $1;
4412 $$ = (Node *)n;
4413 }
4414 | GROUP_P RoleId
4415 {
4416 PrivGrantee *n = makeNode(PrivGrantee);
4417 /* Treat GROUP PUBLIC as a synonym for PUBLIC */
4418 if (strcmp($2, "public") == 0)
4419 n->rolname = NULL;
4420 else
4421 n->rolname = $2;
4422 $$ = (Node *)n;
4423 }
4424 ;
4425
4426
4427 opt_grant_grant_option:
4428 WITH GRANT OPTION { $$ = TRUE; }
4429 | /*EMPTY*/ { $$ = FALSE; }
4430 ;
4431
4432 function_with_argtypes_list:
4433 function_with_argtypes { $$ = list_make1($1); }
4434 | function_with_argtypes_list ',' function_with_argtypes
4435 { $$ = lappend($1, $3); }
4436 ;
4437
4438 function_with_argtypes:
4439 func_name func_args
4440 {
4441 FuncWithArgs *n = makeNode(FuncWithArgs);
4442 n->funcname = $1;
4443 n->funcargs = extractArgTypes($2);
4444 $$ = n;
4445 }
4446 ;
4447
4448 /*****************************************************************************
4449 *
4450 * GRANT and REVOKE ROLE statements
4451 *
4452 *****************************************************************************/
4453
4454 GrantRoleStmt:
4455 GRANT privilege_list TO name_list opt_grant_admin_option opt_granted_by
4456 {
4457 GrantRoleStmt *n = makeNode(GrantRoleStmt);
4458 n->is_grant = true;
4459 n->granted_roles = $2;
4460 n->grantee_roles = $4;
4461 n->admin_opt = $5;
4462 n->grantor = $6;
4463 $$ = (Node*)n;
4464 }
4465 ;
4466
4467 RevokeRoleStmt:
4468 REVOKE privilege_list FROM name_list opt_granted_by opt_drop_behavior
4469 {
4470 GrantRoleStmt *n = makeNode(GrantRoleStmt);
4471 n->is_grant = false;
4472 n->admin_opt = false;
4473 n->granted_roles = $2;
4474 n->grantee_roles = $4;
4475 n->behavior = $6;
4476 $$ = (Node*)n;
4477 }
4478 | REVOKE ADMIN OPTION FOR privilege_list FROM name_list opt_granted_by opt_drop_behavior
4479 {
4480 GrantRoleStmt *n = makeNode(GrantRoleStmt);
4481 n->is_grant = false;
4482 n->admin_opt = true;
4483 n->granted_roles = $5;
4484 n->grantee_roles = $7;
4485 n->behavior = $9;
4486 $$ = (Node*)n;
4487 }
4488 ;
4489
4490 opt_grant_admin_option: WITH ADMIN OPTION { $$ = TRUE; }
4491 | /*EMPTY*/ { $$ = FALSE; }
4492 ;
4493
4494 opt_granted_by: GRANTED BY RoleId { $$ = $3; }
4495 | /*EMPTY*/ { $$ = NULL; }
4496 ;
4497
4498
4499 /*****************************************************************************
4500 *
4501 * QUERY: CREATE INDEX
4502 *
4503 * Note: we can't factor CONCURRENTLY into a separate production without
4504 * making it a reserved word.
4505 *
4506 * Note: we cannot put TABLESPACE clause after WHERE clause unless we are
4507 * willing to make TABLESPACE a fully reserved word.
4508 *****************************************************************************/
4509
4510 IndexStmt: CREATE index_opt_unique INDEX index_name
4511 ON qualified_name access_method_clause '(' index_params ')'
4512 opt_reloptions OptTableSpace where_clause
4513 {
4514 IndexStmt *n = makeNode(IndexStmt);
4515 n->unique = $2;
4516 n->concurrent = false;
4517 n->idxname = $4;
4518 n->relation = $6;
4519 n->accessMethod = $7;
4520 n->indexParams = $9;
4521 n->options = $11;
4522 n->tableSpace = $12;
4523 n->whereClause = $13;
4524 $$ = (Node *)n;
4525 }
4526 | CREATE index_opt_unique INDEX CONCURRENTLY index_name
4527 ON qualified_name access_method_clause '(' index_params ')'
4528 opt_reloptions OptTableSpace where_clause
4529 {
4530 IndexStmt *n = makeNode(IndexStmt);
4531 n->unique = $2;
4532 n->concurrent = true;
4533 n->idxname = $5;
4534 n->relation = $7;
4535 n->accessMethod = $8;
4536 n->indexParams = $10;
4537 n->options = $12;
4538 n->tableSpace = $13;
4539 n->whereClause = $14;
4540 $$ = (Node *)n;
4541 }
4542 ;
4543
4544 index_opt_unique:
4545 UNIQUE { $$ = TRUE; }
4546 | /*EMPTY*/ { $$ = FALSE; }
4547 ;
4548
4549 access_method_clause:
4550 USING access_method { $$ = $2; }
4551 | /*EMPTY*/ { $$ = DEFAULT_INDEX_TYPE; }
4552 ;
4553
4554 index_params: index_elem { $$ = list_make1($1); }
4555 | index_params ',' index_elem { $$ = lappend($1, $3); }
4556 ;
4557
4558 /*
4559 * Index attributes can be either simple column references, or arbitrary
4560 * expressions in parens. For backwards-compatibility reasons, we allow
4561 * an expression that's just a function call to be written without parens.
4562 */
4563 index_elem: ColId opt_class opt_asc_desc opt_nulls_order
4564 {
4565 $$ = makeNode(IndexElem);
4566 $$->name = $1;
4567 $$->expr = NULL;
4568 $$->opclass = $2;
4569 $$->ordering = $3;
4570 $$->nulls_ordering = $4;
4571 }
4572 | func_expr opt_class opt_asc_desc opt_nulls_order
4573 {
4574 $$ = makeNode(IndexElem);
4575 $$->name = NULL;
4576 $$->expr = $1;
4577 $$->opclass = $2;
4578 $$->ordering = $3;
4579 $$->nulls_ordering = $4;
4580 }
4581 | '(' a_expr ')' opt_class opt_asc_desc opt_nulls_order
4582 {
4583 $$ = makeNode(IndexElem);
4584 $$->name = NULL;
4585 $$->expr = $2;
4586 $$->opclass = $4;
4587 $$->ordering = $5;
4588 $$->nulls_ordering = $6;
4589 }
4590 ;
4591
4592 opt_class: any_name { $$ = $1; }
4593 | USING any_name { $$ = $2; }
4594 | /*EMPTY*/ { $$ = NIL; }
4595 ;
4596
4597 opt_asc_desc: ASC { $$ = SORTBY_ASC; }
4598 | DESC { $$ = SORTBY_DESC; }
4599 | /*EMPTY*/ { $$ = SORTBY_DEFAULT; }
4600 ;
4601
4602 opt_nulls_order: NULLS_FIRST { $$ = SORTBY_NULLS_FIRST; }
4603 | NULLS_LAST { $$ = SORTBY_NULLS_LAST; }
4604 | /*EMPTY*/ { $$ = SORTBY_NULLS_DEFAULT; }
4605 ;
4606
4607
4608 /*****************************************************************************
4609 *
4610 * QUERY:
4611 * create [or replace] function <fname>
4612 * [(<type-1> { , <type-n>})]
4613 * returns <type-r>
4614 * as <filename or code in language as appropriate>
4615 * language <lang> [with parameters]
4616 *
4617 *****************************************************************************/
4618
4619 CreateFunctionStmt:
4620 CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
4621 RETURNS func_return createfunc_opt_list opt_definition
4622 {
4623 CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
4624 n->replace = $2;
4625 n->funcname = $4;
4626 n->parameters = $5;
4627 n->returnType = $7;
4628 n->options = $8;
4629 n->withClause = $9;
4630 $$ = (Node *)n;
4631 }
4632 | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
4633 RETURNS TABLE '(' table_func_column_list ')' createfunc_opt_list opt_definition
4634 {
4635 CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
4636 n->replace = $2;
4637 n->funcname = $4;
4638 n->parameters = mergeTableFuncParameters($5, $9);
4639 n->returnType = TableFuncTypeName($9);
4640 n->returnType->location = @7;
4641 n->options = $11;
4642 n->withClause = $12;
4643 $$ = (Node *)n;
4644 }
4645 | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
4646 createfunc_opt_list opt_definition
4647 {
4648 CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
4649 n->replace = $2;
4650 n->funcname = $4;
4651 n->parameters = $5;
4652 n->returnType = NULL;
4653 n->options = $6;
4654 n->withClause = $7;
4655 $$ = (Node *)n;
4656 }
4657 ;
4658
4659 opt_or_replace:
4660 OR REPLACE { $$ = TRUE; }
4661 | /*EMPTY*/ { $$ = FALSE; }
4662 ;
4663
4664 func_args: '(' func_args_list ')' { $$ = $2; }
4665 | '(' ')' { $$ = NIL; }
4666 ;
4667
4668 func_args_list:
4669 func_arg { $$ = list_make1($1); }
4670 | func_args_list ',' func_arg { $$ = lappend($1, $3); }
4671 ;
4672
4673 /*
4674 * func_args_with_defaults is separate because we only want to accept
4675 * defaults in CREATE FUNCTION, not in ALTER etc.
4676 */
4677 func_args_with_defaults:
4678 '(' func_args_with_defaults_list ')' { $$ = $2; }
4679 | '(' ')' { $$ = NIL; }
4680 ;
4681
4682 func_args_with_defaults_list:
4683 func_arg_with_default { $$ = list_make1($1); }
4684 | func_args_with_defaults_list ',' func_arg_with_default
4685 { $$ = lappend($1, $3); }
4686 ;
4687
4688 /*
4689 * The style with arg_class first is SQL99 standard, but Oracle puts
4690 * param_name first; accept both since it's likely people will try both
4691 * anyway. Don't bother trying to save productions by letting arg_class
4692 * have an empty alternative ... you'll get shift/reduce conflicts.
4693 *
4694 * We can catch over-specified arguments here if we want to,
4695 * but for now better to silently swallow typmod, etc.
4696 * - thomas 2000-03-22
4697 */
4698 func_arg:
4699 arg_class param_name func_type
4700 {
4701 FunctionParameter *n = makeNode(FunctionParameter);
4702 n->name = $2;
4703 n->argType = $3;
4704 n->mode = $1;
4705 n->defexpr = NULL;
4706 $$ = n;
4707 }
4708 | param_name arg_class func_type
4709 {
4710 FunctionParameter *n = makeNode(FunctionParameter);
4711 n->name = $1;
4712 n->argType = $3;
4713 n->mode = $2;
4714 n->defexpr = NULL;
4715 $$ = n;
4716 }
4717 | param_name func_type
4718 {
4719 FunctionParameter *n = makeNode(FunctionParameter);
4720 n->name = $1;
4721 n->argType = $2;
4722 n->mode = FUNC_PARAM_IN;
4723 n->defexpr = NULL;
4724 $$ = n;
4725 }
4726 | arg_class func_type
4727 {
4728 FunctionParameter *n = makeNode(FunctionParameter);
4729 n->name = NULL;
4730 n->argType = $2;
4731 n->mode = $1;
4732 n->defexpr = NULL;
4733 $$ = n;
4734 }
4735 | func_type
4736 {
4737 FunctionParameter *n = makeNode(FunctionParameter);
4738 n->name = NULL;
4739 n->argType = $1;
4740 n->mode = FUNC_PARAM_IN;
4741 n->defexpr = NULL;
4742 $$ = n;
4743 }
4744 ;
4745
4746 /* INOUT is SQL99 standard, IN OUT is for Oracle compatibility */
4747 arg_class: IN_P { $$ = FUNC_PARAM_IN; }
4748 | OUT_P { $$ = FUNC_PARAM_OUT; }
4749 | INOUT { $$ = FUNC_PARAM_INOUT; }
4750 | IN_P OUT_P { $$ = FUNC_PARAM_INOUT; }
4751 | VARIADIC { $$ = FUNC_PARAM_VARIADIC; }
4752 ;
4753
4754 /*
4755 * Ideally param_name should be ColId, but that causes too many conflicts.
4756 */
4757 param_name: type_function_name
4758 ;
4759
4760 func_return:
4761 func_type
4762 {
4763 /* We can catch over-specified results here if we want to,
4764 * but for now better to silently swallow typmod, etc.
4765 * - thomas 2000-03-22
4766 */
4767 $$ = $1;
4768 }
4769 ;
4770
4771 /*
4772 * We would like to make the %TYPE productions here be ColId attrs etc,
4773 * but that causes reduce/reduce conflicts. type_function_name
4774 * is next best choice.
4775 */
4776 func_type: Typename { $$ = $1; }
4777 | type_function_name attrs '%' TYPE_P
4778 {
4779 $$ = makeTypeNameFromNameList(lcons(makeString($1), $2));
4780 $$->pct_type = true;
4781 $$->location = @1;
4782 }
4783 | SETOF type_function_name attrs '%' TYPE_P
4784 {
4785 $$ = makeTypeNameFromNameList(lcons(makeString($2), $3));
4786 $$->pct_type = true;
4787 $$->setof = TRUE;
4788 $$->location = @2;
4789 }
4790 ;
4791
4792 func_arg_with_default:
4793 func_arg
4794 {
4795 $$ = $1;
4796 }
4797 | func_arg DEFAULT a_expr
4798 {
4799 $$ = $1;
4800 $$->defexpr = $3;
4801 }
4802 | func_arg '=' a_expr
4803 {
4804 $$ = $1;
4805 $$->defexpr = $3;
4806 }
4807 ;
4808
4809
4810 createfunc_opt_list:
4811 /* Must be at least one to prevent conflict */
4812 createfunc_opt_item { $$ = list_make1($1); }
4813 | createfunc_opt_list createfunc_opt_item { $$ = lappend($1, $2); }
4814 ;
4815
4816 /*
4817 * Options common to both CREATE FUNCTION and ALTER FUNCTION
4818 */
4819 common_func_opt_item:
4820 CALLED ON NULL_P INPUT_P
4821 {
4822 $$ = makeDefElem("strict", (Node *)makeInteger(FALSE));
4823 }
4824 | RETURNS NULL_P ON NULL_P INPUT_P
4825 {
4826 $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
4827 }
4828 | STRICT_P
4829 {
4830 $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
4831 }
4832 | IMMUTABLE
4833 {
4834 $$ = makeDefElem("volatility", (Node *)makeString("immutable"));
4835 }
4836 | STABLE
4837 {
4838 $$ = makeDefElem("volatility", (Node *)makeString("stable"));
4839 }
4840 | VOLATILE
4841 {
4842 $$ = makeDefElem("volatility", (Node *)makeString("volatile"));
4843 }
4844 | EXTERNAL SECURITY DEFINER
4845 {
4846 $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
4847 }
4848 | EXTERNAL SECURITY INVOKER
4849 {
4850 $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
4851 }
4852 | SECURITY DEFINER
4853 {
4854 $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
4855 }
4856 | SECURITY INVOKER
4857 {
4858 $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
4859 }
4860 | COST NumericOnly
4861 {
4862 $$ = makeDefElem("cost", (Node *)$2);
4863 }
4864 | ROWS NumericOnly
4865 {
4866 $$ = makeDefElem("rows", (Node *)$2);
4867 }
4868 | SetResetClause
4869 {
4870 /* we abuse the normal content of a DefElem here */
4871 $$ = makeDefElem("set", (Node *)$1);
4872 }
4873 ;
4874
4875 createfunc_opt_item:
4876 AS func_as
4877 {
4878 $$ = makeDefElem("as", (Node *)$2);
4879 }
4880 | LANGUAGE ColId_or_Sconst
4881 {
4882 $$ = makeDefElem("language", (Node *)makeString($2));
4883 }
4884 | WINDOW
4885 {
4886 $$ = makeDefElem("window", (Node *)makeInteger(TRUE));
4887 }
4888 | common_func_opt_item
4889 {
4890 $$ = $1;
4891 }
4892 ;
4893
4894 func_as: Sconst { $$ = list_make1(makeString($1)); }
4895 | Sconst ',' Sconst
4896 {
4897 $$ = list_make2(makeString($1), makeString($3));
4898 }
4899 ;
4900
4901 opt_definition:
4902 WITH definition { $$ = $2; }
4903 | /*EMPTY*/ { $$ = NIL; }
4904 ;
4905
4906 table_func_column: param_name func_type
4907 {
4908 FunctionParameter *n = makeNode(FunctionParameter);
4909 n->name = $1;
4910 n->argType = $2;
4911 n->mode = FUNC_PARAM_TABLE;
4912 n->defexpr = NULL;
4913 $$ = n;
4914 }
4915 ;
4916
4917 table_func_column_list:
4918 table_func_column
4919 {
4920 $$ = list_make1($1);
4921 }
4922 | table_func_column_list ',' table_func_column
4923 {
4924 $$ = lappend($1, $3);
4925 }
4926 ;
4927
4928 /*****************************************************************************
4929 * ALTER FUNCTION
4930 *
4931 * RENAME and OWNER subcommands are already provided by the generic
4932 * ALTER infrastructure, here we just specify alterations that can
4933 * only be applied to functions.
4934 *
4935 *****************************************************************************/
4936 AlterFunctionStmt:
4937 ALTER FUNCTION function_with_argtypes alterfunc_opt_list opt_restrict
4938 {
4939 AlterFunctionStmt *n = makeNode(AlterFunctionStmt);
4940 n->func = $3;
4941 n->actions = $4;
4942 $$ = (Node *) n;
4943 }
4944 ;
4945
4946 alterfunc_opt_list:
4947 /* At least one option must be specified */
4948 common_func_opt_item { $$ = list_make1($1); }
4949 | alterfunc_opt_list common_func_opt_item { $$ = lappend($1, $2); }
4950 ;
4951
4952 /* Ignored, merely for SQL compliance */
4953 opt_restrict:
4954 RESTRICT
4955 | /* EMPTY */
4956 ;
4957
4958
4959 /*****************************************************************************
4960 *
4961 * QUERY:
4962 *
4963 * DROP FUNCTION funcname (arg1, arg2, ...) [ RESTRICT | CASCADE ]
4964 * DROP AGGREGATE aggname (arg1, ...) [ RESTRICT | CASCADE ]
4965 * DROP OPERATOR opname (leftoperand_typ, rightoperand_typ) [ RESTRICT | CASCADE ]
4966 *
4967 *****************************************************************************/
4968
4969 RemoveFuncStmt:
4970 DROP FUNCTION func_name func_args opt_drop_behavior
4971 {
4972 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
4973 n->kind = OBJECT_FUNCTION;
4974 n->name = $3;
4975 n->args = extractArgTypes($4);
4976 n->behavior = $5;
4977 n->missing_ok = false;
4978 $$ = (Node *)n;
4979 }
4980 | DROP FUNCTION IF_P EXISTS func_name func_args opt_drop_behavior
4981 {
4982 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
4983 n->kind = OBJECT_FUNCTION;
4984 n->name = $5;
4985 n->args = extractArgTypes($6);
4986 n->behavior = $7;
4987 n->missing_ok = true;
4988 $$ = (Node *)n;
4989 }
4990 ;
4991
4992 RemoveAggrStmt:
4993 DROP AGGREGATE func_name aggr_args opt_drop_behavior
4994 {
4995 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
4996 n->kind = OBJECT_AGGREGATE;
4997 n->name = $3;
4998 n->args = $4;
4999 n->behavior = $5;
5000 n->missing_ok = false;
5001 $$ = (Node *)n;
5002 }
5003 | DROP AGGREGATE IF_P EXISTS func_name aggr_args opt_drop_behavior
5004 {
5005 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
5006 n->kind = OBJECT_AGGREGATE;
5007 n->name = $5;
5008 n->args = $6;
5009 n->behavior = $7;
5010 n->missing_ok = true;
5011 $$ = (Node *)n;
5012 }
5013 ;
5014
5015 RemoveOperStmt:
5016 DROP OPERATOR any_operator oper_argtypes opt_drop_behavior
5017 {
5018 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
5019 n->kind = OBJECT_OPERATOR;
5020 n->name = $3;
5021 n->args = $4;
5022 n->behavior = $5;
5023 n->missing_ok = false;
5024 $$ = (Node *)n;
5025 }
5026 | DROP OPERATOR IF_P EXISTS any_operator oper_argtypes opt_drop_behavior
5027 {
5028 RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
5029 n->kind = OBJECT_OPERATOR;
5030 n->name = $5;
5031 n->args = $6;
5032 n->behavior = $7;
5033 n->missing_ok = true;
5034 $$ = (Node *)n;
5035 }
5036 ;
5037
5038 oper_argtypes:
5039 '(' Typename ')'
5040 {
5041 ereport(ERROR,
5042 (errcode(ERRCODE_SYNTAX_ERROR),
5043 errmsg("missing argument"),
5044 errhint("Use NONE to denote the missing argument of a unary operator."),
5045 scanner_errposition(@3)));
5046 }
5047 | '(' Typename ',' Typename ')'
5048 { $$ = list_make2($2, $4); }
5049 | '(' NONE ',' Typename ')' /* left unary */
5050 { $$ = list_make2(NULL, $4); }
5051 | '(' Typename ',' NONE ')' /* right unary */
5052 { $$ = list_make2($2, NULL); }
5053 ;
5054
5055 any_operator:
5056 all_Op
5057 { $$ = list_make1(makeString($1)); }
5058 | ColId '.' any_operator
5059 { $$ = lcons(makeString($1), $3); }
5060 ;
5061
5062
5063 /*****************************************************************************
5064 *
5065 * CREATE CAST / DROP CAST
5066 *
5067 *****************************************************************************/
5068
5069 CreateCastStmt: CREATE CAST '(' Typename AS Typename ')'
5070 WITH FUNCTION function_with_argtypes cast_context
5071 {
5072 CreateCastStmt *n = makeNode(CreateCastStmt);
5073 n->sourcetype = $4;
5074 n->targettype = $6;
5075 n->func = $10;
5076 n->context = (CoercionContext) $11;
5077 n->inout = false;
5078 $$ = (Node *)n;
5079 }
5080 | CREATE CAST '(' Typename AS Typename ')'
5081 WITHOUT FUNCTION cast_context
5082 {
5083 CreateCastStmt *n = makeNode(CreateCastStmt);
5084 n->sourcetype = $4;
5085 n->targettype = $6;
5086 n->func = NULL;
5087 n->context = (CoercionContext) $10;
5088 n->inout = false;
5089 $$ = (Node *)n;
5090 }
5091 | CREATE CAST '(' Typename AS Typename ')'
5092 WITH INOUT cast_context
5093 {
5094 CreateCastStmt *n = makeNode(CreateCastStmt);
5095 n->sourcetype = $4;
5096 n->targettype = $6;
5097 n->func = NULL;
5098 n->context = (CoercionContext) $10;
5099 n->inout = true;
5100 $$ = (Node *)n;
5101 }
5102 ;
5103
5104 cast_context: AS IMPLICIT_P { $$ = COERCION_IMPLICIT; }
5105 | AS ASSIGNMENT { $$ = COERCION_ASSIGNMENT; }
5106 | /*EMPTY*/ { $$ = COERCION_EXPLICIT; }
5107 ;
5108
5109
5110 DropCastStmt: DROP CAST opt_if_exists '(' Typename AS Typename ')' opt_drop_behavior
5111 {
5112 DropCastStmt *n = makeNode(DropCastStmt);
5113 n->sourcetype = $5;
5114 n->targettype = $7;
5115 n->behavior = $9;
5116 n->missing_ok = $3;
5117 $$ = (Node *)n;
5118 }
5119 ;
5120
5121 opt_if_exists: IF_P EXISTS { $$ = TRUE; }
5122 | /*EMPTY*/ { $$ = FALSE; }
5123 ;
5124
5125
5126 /*****************************************************************************
5127 *
5128 * QUERY:
5129 *
5130 * REINDEX type <name> [FORCE]
5131 *
5132 * FORCE no longer does anything, but we accept it for backwards compatibility
5133 *****************************************************************************/
5134
5135 ReindexStmt:
5136 REINDEX reindex_type qualified_name opt_force
5137 {
5138 ReindexStmt *n = makeNode(ReindexStmt);
5139 n->kind = $2;
5140 n->relation = $3;
5141 n->name = NULL;
5142 $$ = (Node *)n;
5143 }
5144 | REINDEX SYSTEM_P name opt_force
5145 {
5146 ReindexStmt *n = makeNode(ReindexStmt);
5147 n->kind = OBJECT_DATABASE;
5148 n->name = $3;
5149 n->relation = NULL;
5150 n->do_system = true;
5151 n->do_user = false;
5152 $$ = (Node *)n;
5153 }
5154 | REINDEX DATABASE name opt_force
5155 {
5156 ReindexStmt *n = makeNode(ReindexStmt);
5157 n->kind = OBJECT_DATABASE;
5158 n->name = $3;
5159 n->relation = NULL;
5160 n->do_system = true;
5161 n->do_user = true;
5162 $$ = (Node *)n;
5163 }
5164 ;
5165
5166 reindex_type:
5167 INDEX { $$ = OBJECT_INDEX; }
5168 | TABLE { $$ = OBJECT_TABLE; }
5169 ;
5170
5171 opt_force: FORCE { $$ = TRUE; }
5172 | /* EMPTY */ { $$ = FALSE; }
5173 ;
5174
5175
5176 /*****************************************************************************
5177 *
5178 * ALTER THING name RENAME TO newname
5179 *
5180 *****************************************************************************/
5181
5182 RenameStmt: ALTER AGGREGATE func_name aggr_args RENAME TO name
5183 {
5184 RenameStmt *n = makeNode(RenameStmt);
5185 n->renameType = OBJECT_AGGREGATE;
5186 n->object = $3;
5187 n->objarg = $4;
5188 n->newname = $7;
5189 $$ = (Node *)n;
5190 }
5191 | ALTER CONVERSION_P any_name RENAME TO name
5192 {
5193 RenameStmt *n = makeNode(RenameStmt);
5194 n->renameType = OBJECT_CONVERSION;
5195 n->object = $3;
5196 n->newname = $6;
5197 $$ = (Node *)n;
5198 }
5199 | ALTER DATABASE database_name RENAME TO database_name
5200 {
5201 RenameStmt *n = makeNode(RenameStmt);
5202 n->renameType = OBJECT_DATABASE;
5203 n->subname = $3;
5204 n->newname = $6;
5205 $$ = (Node *)n;
5206 }
5207 | ALTER FUNCTION function_with_argtypes RENAME TO name
5208 {
5209 RenameStmt *n = makeNode(RenameStmt);
5210 n->renameType = OBJECT_FUNCTION;
5211 n->object = $3->funcname;
5212 n->objarg = $3->funcargs;
5213 n->newname = $6;
5214 $$ = (Node *)n;
5215 }
5216 | ALTER GROUP_P RoleId RENAME TO RoleId
5217 {
5218 RenameStmt *n = makeNode(RenameStmt);
5219 n->renameType = OBJECT_ROLE;
5220 n->subname = $3;
5221 n->newname = $6;
5222 $$ = (Node *)n;
5223 }
5224 | ALTER opt_procedural LANGUAGE name RENAME TO name
5225 {
5226 RenameStmt *n = makeNode(RenameStmt);
5227 n->renameType = OBJECT_LANGUAGE;
5228 n->subname = $4;
5229 n->newname = $7;
5230 $$ = (Node *)n;
5231 }
5232 | ALTER OPERATOR CLASS any_name USING access_method RENAME TO name
5233 {
5234 RenameStmt *n = makeNode(RenameStmt);
5235 n->renameType = OBJECT_OPCLASS;
5236 n->object = $4;
5237 n->subname = $6;
5238 n->newname = $9;
5239 $$ = (Node *)n;
5240 }
5241 | ALTER OPERATOR FAMILY any_name USING access_method RENAME TO name
5242 {
5243 RenameStmt *n = makeNode(RenameStmt);
5244 n->renameType = OBJECT_OPFAMILY;
5245 n->object = $4;
5246 n->subname = $6;
5247 n->newname = $9;
5248 $$ = (Node *)n;
5249 }
5250 | ALTER SCHEMA name RENAME TO name
5251 {
5252 RenameStmt *n = makeNode(RenameStmt);
5253 n->renameType = OBJECT_SCHEMA;
5254 n->subname = $3;
5255 n->newname = $6;
5256 $$ = (Node *)n;
5257 }
5258 | ALTER TABLE relation_expr RENAME TO name
5259 {
5260 RenameStmt *n = makeNode(RenameStmt);
5261 n->renameType = OBJECT_TABLE;
5262 n->relation = $3;
5263 n->subname = NULL;
5264 n->newname = $6;
5265 $$ = (Node *)n;
5266 }
5267 | ALTER SEQUENCE qualified_name RENAME TO name
5268 {
5269 RenameStmt *n = makeNode(RenameStmt);
5270 n->renameType = OBJECT_SEQUENCE;
5271 n->relation = $3;
5272 n->subname = NULL;
5273 n->newname = $6;
5274 $$ = (Node *)n;
5275 }
5276 | ALTER VIEW qualified_name RENAME TO name
5277 {
5278 RenameStmt *n = makeNode(RenameStmt);
5279 n->renameType = OBJECT_VIEW;
5280 n->relation = $3;
5281 n->subname = NULL;
5282 n->newname = $6;
5283 $$ = (Node *)n;
5284 }
5285 | ALTER INDEX qualified_name RENAME TO name
5286 {
5287 RenameStmt *n = makeNode(RenameStmt);
5288 n->renameType = OBJECT_INDEX;
5289 n->relation = $3;
5290 n->subname = NULL;
5291 n->newname = $6;
5292 $$ = (Node *)n;
5293 }
5294 | ALTER TABLE relation_expr RENAME opt_column name TO name
5295 {
5296 RenameStmt *n = makeNode(RenameStmt);
5297 n->renameType = OBJECT_COLUMN;
5298 n->relation = $3;
5299 n->subname = $6;
5300 n->newname = $8;
5301 $$ = (Node *)n;
5302 }
5303 | ALTER TRIGGER name ON qualified_name RENAME TO name
5304 {
5305 RenameStmt *n = makeNode(RenameStmt);
5306 n->renameType = OBJECT_TRIGGER;
5307 n->relation = $5;
5308 n->subname = $3;
5309 n->newname = $8;
5310 $$ = (Node *)n;
5311 }
5312 | ALTER ROLE RoleId RENAME TO RoleId
5313 {
5314 RenameStmt *n = makeNode(RenameStmt);
5315 n->renameType = OBJECT_ROLE;
5316 n->subname = $3;
5317 n->newname = $6;
5318 $$ = (Node *)n;
5319 }
5320 | ALTER USER RoleId RENAME TO RoleId
5321 {
5322 RenameStmt *n = makeNode(RenameStmt);
5323 n->renameType = OBJECT_ROLE;
5324 n->subname = $3;
5325 n->newname = $6;
5326 $$ = (Node *)n;
5327 }
5328 | ALTER TABLESPACE name RENAME TO name
5329 {
5330 RenameStmt *n = makeNode(RenameStmt);
5331 n->renameType = OBJECT_TABLESPACE;
5332 n->subname = $3;
5333 n->newname = $6;
5334 $$ = (Node *)n;
5335 }
5336 | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name
5337 {
5338 RenameStmt *n = makeNode(RenameStmt);
5339 n->renameType = OBJECT_TSPARSER;
5340 n->object = $5;
5341 n->newname = $8;
5342 $$ = (Node *)n;
5343 }
5344 | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name
5345 {
5346 RenameStmt *n = makeNode(RenameStmt);
5347 n->renameType = OBJECT_TSDICTIONARY;
5348 n->object = $5;
5349 n->newname = $8;
5350 $$ = (Node *)n;
5351 }
5352 | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name
5353 {
5354 RenameStmt *n = makeNode(RenameStmt);
5355 n->renameType = OBJECT_TSTEMPLATE;
5356 n->object = $5;
5357 n->newname = $8;
5358 $$ = (Node *)n;
5359 }
5360 | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name
5361 {
5362 RenameStmt *n = makeNode(RenameStmt);
5363 n->renameType = OBJECT_TSCONFIGURATION;
5364 n->object = $5;
5365 n->newname = $8;
5366 $$ = (Node *)n;
5367 }
5368 | ALTER TYPE_P any_name RENAME TO name
5369 {
5370 RenameStmt *n = makeNode(RenameStmt);
5371 n->renameType = OBJECT_TYPE;
5372 n->object = $3;
5373 n->newname = $6;
5374 $$ = (Node *)n;
5375 }
5376 ;
5377
5378 opt_column: COLUMN { $$ = COLUMN; }
5379 | /*EMPTY*/ { $$ = 0; }
5380 ;
5381
5382 opt_set_data: SET DATA_P { $$ = 1; }
5383 | /*EMPTY*/ { $$ = 0; }
5384 ;
5385
5386 /*****************************************************************************
5387 *
5388 * ALTER THING name SET SCHEMA name
5389 *
5390 *****************************************************************************/
5391
5392 AlterObjectSchemaStmt:
5393 ALTER AGGREGATE func_name aggr_args SET SCHEMA name
5394 {
5395 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5396 n->objectType = OBJECT_AGGREGATE;
5397 n->object = $3;
5398 n->objarg = $4;
5399 n->newschema = $7;
5400 $$ = (Node *)n;
5401 }
5402 | ALTER DOMAIN_P any_name SET SCHEMA name
5403 {
5404 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5405 n->objectType = OBJECT_DOMAIN;
5406 n->object = $3;
5407 n->newschema = $6;
5408 $$ = (Node *)n;
5409 }
5410 | ALTER FUNCTION function_with_argtypes SET SCHEMA name
5411 {
5412 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5413 n->objectType = OBJECT_FUNCTION;
5414 n->object = $3->funcname;
5415 n->objarg = $3->funcargs;
5416 n->newschema = $6;
5417 $$ = (Node *)n;
5418 }
5419 | ALTER TABLE relation_expr SET SCHEMA name
5420 {
5421 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5422 n->objectType = OBJECT_TABLE;
5423 n->relation = $3;
5424 n->newschema = $6;
5425 $$ = (Node *)n;
5426 }
5427 | ALTER SEQUENCE qualified_name SET SCHEMA name
5428 {
5429 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5430 n->objectType = OBJECT_SEQUENCE;
5431 n->relation = $3;
5432 n->newschema = $6;
5433 $$ = (Node *)n;
5434 }
5435 | ALTER VIEW qualified_name SET SCHEMA name
5436 {
5437 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5438 n->objectType = OBJECT_VIEW;
5439 n->relation = $3;
5440 n->newschema = $6;
5441 $$ = (Node *)n;
5442 }
5443 | ALTER TYPE_P any_name SET SCHEMA name
5444 {
5445 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
5446 n->objectType = OBJECT_TYPE;
5447 n->object = $3;
5448 n->newschema = $6;
5449 $$ = (Node *)n;
5450 }
5451 ;
5452
5453 /*****************************************************************************
5454 *
5455 * ALTER THING name OWNER TO newname
5456 *
5457 *****************************************************************************/
5458
5459 AlterOwnerStmt: ALTER AGGREGATE func_name aggr_args OWNER TO RoleId
5460 {
5461 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5462 n->objectType = OBJECT_AGGREGATE;
5463 n->object = $3;
5464 n->objarg = $4;
5465 n->newowner = $7;
5466 $$ = (Node *)n;
5467 }
5468 | ALTER CONVERSION_P any_name OWNER TO RoleId
5469 {
5470 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5471 n->objectType = OBJECT_CONVERSION;
5472 n->object = $3;
5473 n->newowner = $6;
5474 $$ = (Node *)n;
5475 }
5476 | ALTER DATABASE database_name OWNER TO RoleId
5477 {
5478 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5479 n->objectType = OBJECT_DATABASE;
5480 n->object = list_make1(makeString($3));
5481 n->newowner = $6;
5482 $$ = (Node *)n;
5483 }
5484 | ALTER DOMAIN_P any_name OWNER TO RoleId
5485 {
5486 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5487 n->objectType = OBJECT_DOMAIN;
5488 n->object = $3;
5489 n->newowner = $6;
5490 $$ = (Node *)n;
5491 }
5492 | ALTER FUNCTION function_with_argtypes OWNER TO RoleId
5493 {
5494 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5495 n->objectType = OBJECT_FUNCTION;
5496 n->object = $3->funcname;
5497 n->objarg = $3->funcargs;
5498 n->newowner = $6;
5499 $$ = (Node *)n;
5500 }
5501 | ALTER opt_procedural LANGUAGE name OWNER TO RoleId
5502 {
5503 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5504 n->objectType = OBJECT_LANGUAGE;
5505 n->object = list_make1(makeString($4));
5506 n->newowner = $7;
5507 $$ = (Node *)n;
5508 }
5509 | ALTER OPERATOR any_operator oper_argtypes OWNER TO RoleId
5510 {
5511 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5512 n->objectType = OBJECT_OPERATOR;
5513 n->object = $3;
5514 n->objarg = $4;
5515 n->newowner = $7;
5516 $$ = (Node *)n;
5517 }
5518 | ALTER OPERATOR CLASS any_name USING access_method OWNER TO RoleId
5519 {
5520 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5521 n->objectType = OBJECT_OPCLASS;
5522 n->object = $4;
5523 n->addname = $6;
5524 n->newowner = $9;
5525 $$ = (Node *)n;
5526 }
5527 | ALTER OPERATOR FAMILY any_name USING access_method OWNER TO RoleId
5528 {
5529 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5530 n->objectType = OBJECT_OPFAMILY;
5531 n->object = $4;
5532 n->addname = $6;
5533 n->newowner = $9;
5534 $$ = (Node *)n;
5535 }
5536 | ALTER SCHEMA name OWNER TO RoleId
5537 {
5538 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5539 n->objectType = OBJECT_SCHEMA;
5540 n->object = list_make1(makeString($3));
5541 n->newowner = $6;
5542 $$ = (Node *)n;
5543 }
5544 | ALTER TYPE_P any_name OWNER TO RoleId
5545 {
5546 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5547 n->objectType = OBJECT_TYPE;
5548 n->object = $3;
5549 n->newowner = $6;
5550 $$ = (Node *)n;
5551 }
5552 | ALTER TABLESPACE name OWNER TO RoleId
5553 {
5554 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5555 n->objectType = OBJECT_TABLESPACE;
5556 n->object = list_make1(makeString($3));
5557 n->newowner = $6;
5558 $$ = (Node *)n;
5559 }
5560 | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO RoleId
5561 {
5562 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5563 n->objectType = OBJECT_TSDICTIONARY;
5564 n->object = $5;
5565 n->newowner = $8;
5566 $$ = (Node *)n;
5567 }
5568 | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO RoleId
5569 {
5570 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5571 n->objectType = OBJECT_TSCONFIGURATION;
5572 n->object = $5;
5573 n->newowner = $8;
5574 $$ = (Node *)n;
5575 }
5576 | ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleId
5577 {
5578 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5579 n->objectType = OBJECT_FDW;
5580 n->object = list_make1(makeString($5));
5581 n->newowner = $8;
5582 $$ = (Node *)n;
5583 }
5584 | ALTER SERVER name OWNER TO RoleId
5585 {
5586 AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
5587 n->objectType = OBJECT_FOREIGN_SERVER;
5588 n->object = list_make1(makeString($3));
5589 n->newowner = $6;
5590 $$ = (Node *)n;
5591 }
5592 ;
5593
5594
5595 /*****************************************************************************
5596 *
5597 * QUERY: Define Rewrite Rule
5598 *
5599 *****************************************************************************/
5600
5601 RuleStmt: CREATE opt_or_replace RULE name AS
5602 { QueryIsRule=TRUE; }
5603 ON event TO qualified_name where_clause
5604 DO opt_instead RuleActionList
5605 {
5606 RuleStmt *n = makeNode(RuleStmt);
5607 n->replace = $2;
5608 n->relation = $10;
5609 n->rulename = $4;
5610 n->whereClause = $11;
5611 n->event = $8;
5612 n->instead = $13;
5613 n->actions = $14;
5614 $$ = (Node *)n;
5615 QueryIsRule=FALSE;
5616 }
5617 ;
5618
5619 RuleActionList:
5620 NOTHING { $$ = NIL; }
5621 | RuleActionStmt { $$ = list_make1($1); }
5622 | '(' RuleActionMulti ')' { $$ = $2; }
5623 ;
5624
5625 /* the thrashing around here is to discard "empty" statements... */
5626 RuleActionMulti:
5627 RuleActionMulti ';' RuleActionStmtOrEmpty
5628 { if ($3 != NULL)
5629 $$ = lappend($1, $3);
5630 else
5631 $$ = $1;
5632 }
5633 | RuleActionStmtOrEmpty
5634 { if ($1 != NULL)
5635 $$ = list_make1($1);
5636 else
5637 $$ = NIL;
5638 }
5639 ;
5640
5641 RuleActionStmt:
5642 SelectStmt
5643 | InsertStmt
5644 | UpdateStmt
5645 | DeleteStmt
5646 | NotifyStmt
5647 ;
5648
5649 RuleActionStmtOrEmpty:
5650 RuleActionStmt { $$ = $1; }
5651 | /*EMPTY*/ { $$ = NULL; }
5652 ;
5653
5654 event: SELECT { $$ = CMD_SELECT; }
5655 | UPDATE { $$ = CMD_UPDATE; }
5656 | DELETE_P { $$ = CMD_DELETE; }
5657 | INSERT { $$ = CMD_INSERT; }
5658 ;
5659
5660 opt_instead:
5661 INSTEAD { $$ = TRUE; }
5662 | ALSO { $$ = FALSE; }
5663 | /*EMPTY*/ { $$ = FALSE; }
5664 ;
5665
5666
5667 DropRuleStmt:
5668 DROP RULE name ON qualified_name opt_drop_behavior
5669 {
5670 DropPropertyStmt *n = makeNode(DropPropertyStmt);
5671 n->relation = $5;
5672 n->property = $3;
5673 n->behavior = $6;
5674 n->removeType = OBJECT_RULE;
5675 n->missing_ok = false;
5676 $$ = (Node *) n;
5677 }
5678 | DROP RULE IF_P EXISTS name ON qualified_name opt_drop_behavior
5679 {
5680 DropPropertyStmt *n = makeNode(DropPropertyStmt);
5681 n->relation = $7;
5682 n->property = $5;
5683 n->behavior = $8;
5684 n->removeType = OBJECT_RULE;
5685 n->missing_ok = true;
5686 $$ = (Node *) n;
5687 }
5688 ;
5689
5690
5691 /*****************************************************************************
5692 *
5693 * QUERY:
5694 * NOTIFY <identifier> can appear both in rule bodies and
5695 * as a query-level command
5696 *
5697 *****************************************************************************/
5698
5699 NotifyStmt: NOTIFY ColId
5700 {
5701 NotifyStmt *n = makeNode(NotifyStmt);
5702 n->conditionname = $2;
5703 $$ = (Node *)n;
5704 }
5705 ;
5706
5707 ListenStmt: LISTEN ColId
5708 {
5709 ListenStmt *n = makeNode(ListenStmt);
5710 n->conditionname = $2;
5711 $$ = (Node *)n;
5712 }
5713 ;
5714
5715 UnlistenStmt:
5716 UNLISTEN ColId
5717 {
5718 UnlistenStmt *n = makeNode(UnlistenStmt);
5719 n->conditionname = $2;
5720 $$ = (Node *)n;
5721 }
5722 | UNLISTEN '*'
5723 {
5724 UnlistenStmt *n = makeNode(UnlistenStmt);
5725 n->conditionname = NULL;
5726 $$ = (Node *)n;
5727 }
5728 ;
5729
5730
5731 /*****************************************************************************
5732 *
5733 * Transactions:
5734 *
5735 * BEGIN / COMMIT / ROLLBACK
5736 * (also older versions END / ABORT)
5737 *
5738 *****************************************************************************/
5739
5740 TransactionStmt:
5741 ABORT_P opt_transaction
5742 {
5743 TransactionStmt *n = makeNode(TransactionStmt);
5744 n->kind = TRANS_STMT_ROLLBACK;
5745 n->options = NIL;
5746 $$ = (Node *)n;
5747 }
5748 | BEGIN_P opt_transaction transaction_mode_list_or_empty
5749 {
5750 TransactionStmt *n = makeNode(TransactionStmt);
5751 n->kind = TRANS_STMT_BEGIN;
5752 n->options = $3;
5753 $$ = (Node *)n;
5754 }
5755 | START TRANSACTION transaction_mode_list_or_empty
5756 {
5757 TransactionStmt *n = makeNode(TransactionStmt);
5758 n->kind = TRANS_STMT_START;
5759 n->options = $3;
5760 $$ = (Node *)n;
5761 }
5762 | COMMIT opt_transaction
5763 {
5764 TransactionStmt *n = makeNode(TransactionStmt);
5765 n->kind = TRANS_STMT_COMMIT;
5766 n->options = NIL;
5767 $$ = (Node *)n;
5768 }
5769 | END_P opt_transaction
5770 {
5771 TransactionStmt *n = makeNode(TransactionStmt);
5772 n->kind = TRANS_STMT_COMMIT;
5773 n->options = NIL;
5774 $$ = (Node *)n;
5775 }
5776 | ROLLBACK opt_transaction
5777 {
5778 TransactionStmt *n = makeNode(TransactionStmt);
5779 n->kind = TRANS_STMT_ROLLBACK;
5780 n->options = NIL;
5781 $$ = (Node *)n;
5782 }
5783 | SAVEPOINT ColId
5784 {
5785 TransactionStmt *n = makeNode(TransactionStmt);
5786 n->kind = TRANS_STMT_SAVEPOINT;
5787 n->options = list_make1(makeDefElem("savepoint_name",
5788 (Node *)makeString($2)));
5789 $$ = (Node *)n;
5790 }
5791 | RELEASE SAVEPOINT ColId
5792 {
5793 TransactionStmt *n = makeNode(TransactionStmt);
5794 n->kind = TRANS_STMT_RELEASE;
5795 n->options = list_make1(makeDefElem("savepoint_name",
5796 (Node *)makeString($3)));
5797 $$ = (Node *)n;
5798 }
5799 | RELEASE ColId
5800 {
5801 TransactionStmt *n = makeNode(TransactionStmt);
5802 n->kind = TRANS_STMT_RELEASE;
5803 n->options = list_make1(makeDefElem("savepoint_name",
5804 (Node *)makeString($2)));
5805 $$ = (Node *)n;
5806 }
5807 | ROLLBACK opt_transaction TO SAVEPOINT ColId
5808 {
5809 TransactionStmt *n = makeNode(TransactionStmt);
5810 n->kind = TRANS_STMT_ROLLBACK_TO;
5811 n->options = list_make1(makeDefElem("savepoint_name",
5812 (Node *)makeString($5)));
5813 $$ = (Node *)n;
5814 }
5815 | ROLLBACK opt_transaction TO ColId
5816 {
5817 TransactionStmt *n = makeNode(TransactionStmt);
5818 n->kind = TRANS_STMT_ROLLBACK_TO;
5819 n->options = list_make1(makeDefElem("savepoint_name",
5820 (Node *)makeString($4)));
5821 $$ = (Node *)n;
5822 }
5823 | PREPARE TRANSACTION Sconst
5824 {
5825 TransactionStmt *n = makeNode(TransactionStmt);
5826 n->kind = TRANS_STMT_PREPARE;
5827 n->gid = $3;
5828 $$ = (Node *)n;
5829 }
5830 | COMMIT PREPARED Sconst
5831 {
5832 TransactionStmt *n = makeNode(TransactionStmt);
5833 n->kind = TRANS_STMT_COMMIT_PREPARED;
5834 n->gid = $3;
5835 $$ = (Node *)n;
5836 }
5837 | ROLLBACK PREPARED Sconst
5838 {
5839 TransactionStmt *n = makeNode(TransactionStmt);
5840 n->kind = TRANS_STMT_ROLLBACK_PREPARED;
5841 n->gid = $3;
5842 $$ = (Node *)n;
5843 }
5844 ;
5845
5846 opt_transaction: WORK {}
5847 | TRANSACTION {}
5848 | /*EMPTY*/ {}
5849 ;
5850
5851 transaction_mode_item:
5852 ISOLATION LEVEL iso_level
5853 { $$ = makeDefElem("transaction_isolation",
5854 makeStringConst($3, @3)); }
5855 | READ ONLY
5856 { $$ = makeDefElem("transaction_read_only",
5857 makeIntConst(TRUE, @1)); }
5858 | READ WRITE
5859 { $$ = makeDefElem("transaction_read_only",
5860 makeIntConst(FALSE, @1)); }
5861 ;
5862
5863 /* Syntax with commas is SQL-spec, without commas is Postgres historical */
5864 transaction_mode_list:
5865 transaction_mode_item
5866 { $$ = list_make1($1); }
5867 | transaction_mode_list ',' transaction_mode_item
5868 { $$ = lappend($1, $3); }
5869 | transaction_mode_list transaction_mode_item
5870 { $$ = lappend($1, $2); }
5871 ;
5872
5873 transaction_mode_list_or_empty:
5874 transaction_mode_list
5875 | /* EMPTY */
5876 { $$ = NIL; }
5877 ;
5878
5879
5880 /*****************************************************************************
5881 *
5882 * QUERY:
5883 * CREATE [ OR REPLACE ] [ TEMP ] VIEW <viewname> '('target-list ')'
5884 * AS <query> [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
5885 *
5886 *****************************************************************************/
5887
5888 ViewStmt: CREATE OptTemp VIEW qualified_name opt_column_list
5889 AS SelectStmt opt_check_option
5890 {
5891 ViewStmt *n = makeNode(ViewStmt);
5892 n->view = $4;
5893 n->view->istemp = $2;
5894 n->aliases = $5;
5895 n->query = $7;
5896 n->replace = false;
5897 $$ = (Node *) n;
5898 }
5899 | CREATE OR REPLACE OptTemp VIEW qualified_name opt_column_list
5900 AS SelectStmt opt_check_option
5901 {
5902 ViewStmt *n = makeNode(ViewStmt);
5903 n->view = $6;
5904 n->view->istemp = $4;
5905 n->aliases = $7;
5906 n->query = $9;
5907 n->replace = true;
5908 $$ = (Node *) n;
5909 }
5910 ;
5911
5912 opt_check_option:
5913 WITH CHECK OPTION
5914 {
5915 ereport(ERROR,
5916 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
5917 errmsg("WITH CHECK OPTION is not implemented")));
5918 }
5919 | WITH CASCADED CHECK OPTION
5920 {
5921 ereport(ERROR,
5922 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
5923 errmsg("WITH CHECK OPTION is not implemented")));
5924 }
5925 | WITH LOCAL CHECK OPTION
5926 {
5927 ereport(ERROR,
5928 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
5929 errmsg("WITH CHECK OPTION is not implemented")));
5930 }
5931 | /* EMPTY */ { $$ = NIL; }
5932 ;
5933
5934 /*****************************************************************************
5935 *
5936 * QUERY:
5937 * LOAD "filename"
5938 *
5939 *****************************************************************************/
5940
5941 LoadStmt: LOAD file_name
5942 {
5943 LoadStmt *n = makeNode(LoadStmt);
5944 n->filename = $2;
5945 $$ = (Node *)n;
5946 }
5947 ;
5948
5949
5950 /*****************************************************************************
5951 *
5952 * CREATE DATABASE
5953 *
5954 *****************************************************************************/
5955
5956 CreatedbStmt:
5957 CREATE DATABASE database_name opt_with createdb_opt_list
5958 {
5959 CreatedbStmt *n = makeNode(CreatedbStmt);
5960 n->dbname = $3;
5961 n->options = $5;
5962 $$ = (Node *)n;
5963 }
5964 ;
5965
5966 createdb_opt_list:
5967 createdb_opt_list createdb_opt_item { $$ = lappend($1, $2); }
5968 | /* EMPTY */ { $$ = NIL; }
5969 ;
5970
5971 createdb_opt_item:
5972 TABLESPACE opt_equal name
5973 {
5974 $$ = makeDefElem("tablespace", (Node *)makeString($3));
5975 }
5976 | TABLESPACE opt_equal DEFAULT
5977 {
5978 $$ = makeDefElem("tablespace", NULL);
5979 }
5980 | LOCATION opt_equal Sconst
5981 {
5982 $$ = makeDefElem("location", (Node *)makeString($3));
5983 }
5984 | LOCATION opt_equal DEFAULT
5985 {
5986 $$ = makeDefElem("location", NULL);
5987 }
5988 | TEMPLATE opt_equal name
5989 {
5990 $$ = makeDefElem("template", (Node *)makeString($3));
5991 }
5992 | TEMPLATE opt_equal DEFAULT
5993 {
5994 $$ = makeDefElem("template", NULL);
5995 }
5996 | ENCODING opt_equal Sconst
5997 {
5998 $$ = makeDefElem("encoding", (Node *)makeString($3));
5999 }
6000 | ENCODING opt_equal Iconst
6001 {
6002 $$ = makeDefElem("encoding", (Node *)makeInteger($3));
6003 }
6004 | ENCODING opt_equal DEFAULT
6005 {
6006 $$ = makeDefElem("encoding", NULL);
6007 }
6008 | LC_COLLATE_P opt_equal Sconst
6009 {
6010 $$ = makeDefElem("lc_collate", (Node *)makeString($3));
6011 }
6012 | LC_COLLATE_P opt_equal DEFAULT
6013 {
6014 $$ = makeDefElem("lc_collate", NULL);
6015 }
6016 | LC_CTYPE_P opt_equal Sconst
6017 {
6018 $$ = makeDefElem("lc_ctype", (Node *)makeString($3));
6019 }
6020 | LC_CTYPE_P opt_equal DEFAULT
6021 {
6022 $$ = makeDefElem("lc_ctype", NULL);
6023 }
6024 | CONNECTION LIMIT opt_equal SignedIconst
6025 {
6026 $$ = makeDefElem("connectionlimit", (Node *)makeInteger($4));
6027 }
6028 | OWNER opt_equal name
6029 {
6030 $$ = makeDefElem("owner", (Node *)makeString($3));
6031 }
6032 | OWNER opt_equal DEFAULT
6033 {
6034 $$ = makeDefElem("owner", NULL);
6035 }
6036 ;
6037
6038 /*
6039 * Though the equals sign doesn't match other WITH options, pg_dump uses
6040 * equals for backward compatibility, and it doesn't seem worth removing it.
6041 */
6042 opt_equal: '=' {}
6043 | /*EMPTY*/ {}
6044 ;
6045
6046
6047 /*****************************************************************************
6048 *
6049 * ALTER DATABASE
6050 *
6051 *****************************************************************************/
6052
6053 AlterDatabaseStmt:
6054 ALTER DATABASE database_name opt_with alterdb_opt_list
6055 {
6056 AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
6057 n->dbname = $3;
6058 n->options = $5;
6059 $$ = (Node *)n;
6060 }
6061 | ALTER DATABASE database_name SET TABLESPACE name
6062 {
6063 AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt);
6064 n->dbname = $3;
6065 n->options = list_make1(makeDefElem("tablespace",
6066 (Node *)makeString($6)));
6067 $$ = (Node *)n;
6068 }
6069 ;
6070
6071 AlterDatabaseSetStmt:
6072 ALTER DATABASE database_name SetResetClause
6073 {
6074 AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
6075 n->dbname = $3;
6076 n->setstmt = $4;
6077 $$ = (Node *)n;
6078 }
6079 ;
6080
6081
6082 alterdb_opt_list:
6083 alterdb_opt_list alterdb_opt_item { $$ = lappend($1, $2); }
6084 | /* EMPTY */ { $$ = NIL; }
6085 ;
6086
6087 alterdb_opt_item:
6088 CONNECTION LIMIT opt_equal SignedIconst
6089 {
6090 $$ = makeDefElem("connectionlimit", (Node *)makeInteger($4));
6091 }
6092 ;
6093
6094
6095 /*****************************************************************************
6096 *
6097 * DROP DATABASE [ IF EXISTS ]
6098 *
6099 * This is implicitly CASCADE, no need for drop behavior
6100 *****************************************************************************/
6101
6102 DropdbStmt: DROP DATABASE database_name
6103 {
6104 DropdbStmt *n = makeNode(DropdbStmt);
6105 n->dbname = $3;
6106 n->missing_ok = FALSE;
6107 $$ = (Node *)n;
6108 }
6109 | DROP DATABASE IF_P EXISTS database_name
6110 {
6111 DropdbStmt *n = makeNode(DropdbStmt);
6112 n->dbname = $5;
6113 n->missing_ok = TRUE;
6114 $$ = (Node *)n;
6115 }
6116 ;
6117
6118
6119 /*****************************************************************************
6120 *
6121 * Manipulate a domain
6122 *
6123 *****************************************************************************/
6124
6125 CreateDomainStmt:
6126 CREATE DOMAIN_P any_name opt_as Typename ColQualList
6127 {
6128 CreateDomainStmt *n = makeNode(CreateDomainStmt);
6129 n->domainname = $3;
6130 n->typename = $5;
6131 n->constraints = $6;
6132 $$ = (Node *)n;
6133 }
6134 ;
6135
6136 AlterDomainStmt:
6137 /* ALTER DOMAIN <domain> {SET DEFAULT <expr>|DROP DEFAULT} */
6138 ALTER DOMAIN_P any_name alter_column_default
6139 {
6140 AlterDomainStmt *n = makeNode(AlterDomainStmt);
6141 n->subtype = 'T';
6142 n->typename = $3;
6143 n->def = $4;
6144 $$ = (Node *)n;
6145 }
6146 /* ALTER DOMAIN <domain> DROP NOT NULL */
6147 | ALTER DOMAIN_P any_name DROP NOT NULL_P
6148 {
6149 AlterDomainStmt *n = makeNode(AlterDomainStmt);
6150 n->subtype = 'N';
6151 n->typename = $3;
6152 $$ = (Node *)n;
6153 }
6154 /* ALTER DOMAIN <domain> SET NOT NULL */
6155 | ALTER DOMAIN_P any_name SET NOT NULL_P
6156 {
6157 AlterDomainStmt *n = makeNode(AlterDomainStmt);
6158 n->subtype = 'O';
6159 n->typename = $3;
6160 $$ = (Node *)n;
6161 }
6162 /* ALTER DOMAIN <domain> ADD CONSTRAINT ... */
6163 | ALTER DOMAIN_P any_name ADD_P TableConstraint
6164 {
6165 AlterDomainStmt *n = makeNode(AlterDomainStmt);
6166 n->subtype = 'C';
6167 n->typename = $3;
6168 n->def = $5;
6169 $$ = (Node *)n;
6170 }
6171 /* ALTER DOMAIN <domain> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
6172 | ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
6173 {
6174 AlterDomainStmt *n = makeNode(AlterDomainStmt);
6175 n->subtype = 'X';
6176 n->typename = $3;
6177 n->name = $6;
6178 n->behavior = $7;
6179 $$ = (Node *)n;
6180 }
6181 ;
6182
6183 opt_as: AS {}
6184 | /* EMPTY */ {}
6185 ;
6186
6187
6188 /*****************************************************************************
6189 *
6190 * Manipulate a text search dictionary or configuration
6191 *
6192 *****************************************************************************/
6193
6194 AlterTSDictionaryStmt:
6195 ALTER TEXT_P SEARCH DICTIONARY any_name definition
6196 {
6197 AlterTSDictionaryStmt *n = makeNode(AlterTSDictionaryStmt);
6198 n->dictname = $5;
6199 n->options = $6;
6200 $$ = (Node *)n;
6201 }
6202 ;
6203
6204 AlterTSConfigurationStmt:
6205 ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list WITH any_name_list
6206 {
6207 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6208 n->cfgname = $5;
6209 n->tokentype = $9;
6210 n->dicts = $11;
6211 n->override = false;
6212 n->replace = false;
6213 $$ = (Node*)n;
6214 }
6215 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list WITH any_name_list
6216 {
6217 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6218 n->cfgname = $5;
6219 n->tokentype = $9;
6220 n->dicts = $11;
6221 n->override = true;
6222 n->replace = false;
6223 $$ = (Node*)n;
6224 }
6225 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name WITH any_name
6226 {
6227 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6228 n->cfgname = $5;
6229 n->tokentype = NIL;
6230 n->dicts = list_make2($9,$11);
6231 n->override = false;
6232 n->replace = true;
6233 $$ = (Node*)n;
6234 }
6235 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name WITH any_name
6236 {
6237 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6238 n->cfgname = $5;
6239 n->tokentype = $9;
6240 n->dicts = list_make2($11,$13);
6241 n->override = false;
6242 n->replace = true;
6243 $$ = (Node*)n;
6244 }
6245 | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
6246 {
6247 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6248 n->cfgname = $5;
6249 n->tokentype = $9;
6250 n->missing_ok = false;
6251 $$ = (Node*)n;
6252 }
6253 | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
6254 {
6255 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
6256 n->cfgname = $5;
6257 n->tokentype = $11;
6258 n->missing_ok = true;
6259 $$ = (Node*)n;
6260 }
6261 ;
6262
6263
6264 /*****************************************************************************
6265 *
6266 * Manipulate a conversion
6267 *
6268 * CREATE [DEFAULT] CONVERSION <conversion_name>
6269 * FOR <encoding_name> TO <encoding_name> FROM <func_name>
6270 *
6271 *****************************************************************************/
6272
6273 CreateConversionStmt:
6274 CREATE opt_default CONVERSION_P any_name FOR Sconst
6275 TO Sconst FROM any_name
6276 {
6277 CreateConversionStmt *n = makeNode(CreateConversionStmt);
6278 n->conversion_name = $4;
6279 n->for_encoding_name = $6;
6280 n->to_encoding_name = $8;
6281 n->func_name = $10;
6282 n->def = $2;
6283 $$ = (Node *)n;
6284 }
6285 ;
6286
6287 /*****************************************************************************
6288 *
6289 * QUERY:
6290 * CLUSTER [VERBOSE] <qualified_name> [ USING <index_name> ]
6291 * CLUSTER [VERBOSE]
6292 * CLUSTER [VERBOSE] <index_name> ON <qualified_name> (for pre-8.3)
6293 *
6294 *****************************************************************************/
6295
6296 ClusterStmt:
6297 CLUSTER opt_verbose qualified_name cluster_index_specification
6298 {
6299 ClusterStmt *n = makeNode(ClusterStmt);
6300 n->relation = $3;
6301 n->indexname = $4;
6302 n->verbose = $2;
6303 $$ = (Node*)n;
6304 }
6305 | CLUSTER opt_verbose
6306 {
6307 ClusterStmt *n = makeNode(ClusterStmt);
6308 n->relation = NULL;
6309 n->indexname = NULL;
6310 n->verbose = $2;
6311 $$ = (Node*)n;
6312 }
6313 /* kept for pre-8.3 compatibility */
6314 | CLUSTER opt_verbose index_name ON qualified_name
6315 {
6316 ClusterStmt *n = makeNode(ClusterStmt);
6317 n->relation = $5;
6318 n->indexname = $3;
6319 n->verbose = $2;
6320 $$ = (Node*)n;
6321 }
6322 ;
6323
6324 cluster_index_specification:
6325 USING index_name { $$ = $2; }
6326 | /*EMPTY*/ { $$ = NULL; }
6327 ;
6328
6329
6330 /*****************************************************************************
6331 *
6332 * QUERY:
6333 * VACUUM
6334 * ANALYZE
6335 *
6336 *****************************************************************************/
6337
6338 VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
6339 {
6340 VacuumStmt *n = makeNode(VacuumStmt);
6341 n->vacuum = true;
6342 n->analyze = false;
6343 n->full = $2;
6344 n->freeze_min_age = $3 ? 0 : -1;
6345 n->freeze_table_age = $3 ? 0 : -1;
6346 n->verbose = $4;
6347 n->relation = NULL;
6348 n->va_cols = NIL;
6349 $$ = (Node *)n;
6350 }
6351 | VACUUM opt_full opt_freeze opt_verbose qualified_name
6352 {
6353 VacuumStmt *n = makeNode(VacuumStmt);
6354 n->vacuum = true;
6355 n->analyze = false;
6356 n->full = $2;
6357 n->freeze_min_age = $3 ? 0 : -1;
6358 n->freeze_table_age = $3 ? 0 : -1;
6359 n->verbose = $4;
6360 n->relation = $5;
6361 n->va_cols = NIL;
6362 $$ = (Node *)n;
6363 }
6364 | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
6365 {
6366 VacuumStmt *n = (VacuumStmt *) $5;
6367 n->vacuum = true;
6368 n->full = $2;
6369 n->freeze_min_age = $3 ? 0 : -1;
6370 n->freeze_table_age = $3 ? 0 : -1;
6371 n->verbose |= $4;
6372 $$ = (Node *)n;
6373 }
6374 ;
6375
6376 AnalyzeStmt:
6377 analyze_keyword opt_verbose
6378 {
6379 VacuumStmt *n = makeNode(VacuumStmt);
6380 n->vacuum = false;
6381 n->analyze = true;
6382 n->full = false;
6383 n->freeze_min_age = -1;
6384 n->freeze_table_age = -1;
6385 n->verbose = $2;
6386 n->relation = NULL;
6387 n->va_cols = NIL;
6388 $$ = (Node *)n;
6389 }
6390 | analyze_keyword opt_verbose qualified_name opt_name_list
6391 {
6392 VacuumStmt *n = makeNode(VacuumStmt);
6393 n->vacuum = false;
6394 n->analyze = true;
6395 n->full = false;
6396 n->freeze_min_age = -1;
6397 n->freeze_table_age = -1;
6398 n->verbose = $2;
6399 n->relation = $3;
6400 n->va_cols = $4;
6401 $$ = (Node *)n;
6402 }
6403 ;
6404
6405 analyze_keyword:
6406 ANALYZE {}
6407 | ANALYSE /* British */ {}
6408 ;
6409
6410 opt_verbose:
6411 VERBOSE { $$ = TRUE; }
6412 | /*EMPTY*/ { $$ = FALSE; }
6413 ;
6414
6415 opt_full: FULL { $$ = TRUE; }
6416 | /*EMPTY*/ { $$ = FALSE; }
6417 ;
6418
6419 opt_freeze: FREEZE { $$ = TRUE; }
6420 | /*EMPTY*/ { $$ = FALSE; }
6421 ;
6422
6423 opt_name_list:
6424 '(' name_list ')' { $$ = $2; }
6425 | /*EMPTY*/ { $$ = NIL; }
6426 ;
6427
6428
6429 /*****************************************************************************
6430 *
6431 * QUERY:
6432 * EXPLAIN [ANALYZE] [VERBOSE] query
6433 *
6434 *****************************************************************************/
6435
6436 ExplainStmt: EXPLAIN opt_analyze opt_verbose ExplainableStmt
6437 {
6438 ExplainStmt *n = makeNode(ExplainStmt);
6439 n->analyze = $2;
6440 n->verbose = $3;
6441 n->query = $4;
6442 $$ = (Node *)n;
6443 }
6444 ;
6445
6446 ExplainableStmt:
6447 SelectStmt
6448 | InsertStmt
6449 | UpdateStmt
6450 | DeleteStmt
6451 | DeclareCursorStmt
6452 | CreateAsStmt
6453 | ExecuteStmt /* by default all are $$=$1 */
6454 ;
6455
6456 opt_analyze:
6457 analyze_keyword { $$ = TRUE; }
6458 | /* EMPTY */ { $$ = FALSE; }
6459 ;
6460
6461 /*****************************************************************************
6462 *
6463 * QUERY:
6464 * PREPARE <plan_name> [(args, ...)] AS <query>
6465 *
6466 *****************************************************************************/
6467
6468 PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt
6469 {
6470 PrepareStmt *n = makeNode(PrepareStmt);
6471 n->name = $2;
6472 n->argtypes = $3;
6473 n->query = $5;
6474 $$ = (Node *) n;
6475 }
6476 ;
6477
6478 prep_type_clause: '(' type_list ')' { $$ = $2; }
6479 | /* EMPTY */ { $$ = NIL; }
6480 ;
6481
6482 PreparableStmt:
6483 SelectStmt
6484 | InsertStmt
6485 | UpdateStmt
6486 | DeleteStmt /* by default all are $$=$1 */
6487 ;
6488
6489 /*****************************************************************************
6490 *
6491 * EXECUTE <plan_name> [(params, ...)]
6492 * CREATE TABLE <name> AS EXECUTE <plan_name> [(params, ...)]
6493 *
6494 *****************************************************************************/
6495
6496 ExecuteStmt: EXECUTE name execute_param_clause
6497 {
6498 ExecuteStmt *n = makeNode(ExecuteStmt);
6499 n->name = $2;
6500 n->params = $3;
6501 n->into = NULL;
6502 $$ = (Node *) n;
6503 }
6504 | CREATE OptTemp TABLE create_as_target AS
6505 EXECUTE name execute_param_clause
6506 {
6507 ExecuteStmt *n = makeNode(ExecuteStmt);
6508 n->name = $7;
6509 n->params = $8;
6510 $4->rel->istemp = $2;
6511 n->into = $4;
6512 if ($4->colNames)
6513 ereport(ERROR,
6514 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
6515 errmsg("column name list not allowed in CREATE TABLE / AS EXECUTE")));
6516 /* ... because it's not implemented, but it could be */
6517 $$ = (Node *) n;
6518 }
6519 ;
6520
6521 execute_param_clause: '(' expr_list ')' { $$ = $2; }
6522 | /* EMPTY */ { $$ = NIL; }
6523 ;
6524
6525 /*****************************************************************************
6526 *
6527 * QUERY:
6528 * DEALLOCATE [PREPARE] <plan_name>
6529 *
6530 *****************************************************************************/
6531
6532 DeallocateStmt: DEALLOCATE name
6533 {
6534 DeallocateStmt *n = makeNode(DeallocateStmt);
6535 n->name = $2;
6536 $$ = (Node *) n;
6537 }
6538 | DEALLOCATE PREPARE name
6539 {
6540 DeallocateStmt *n = makeNode(DeallocateStmt);
6541 n->name = $3;
6542 $$ = (Node *) n;
6543 }
6544 | DEALLOCATE ALL
6545 {
6546 DeallocateStmt *n = makeNode(DeallocateStmt);
6547 n->name = NULL;
6548 $$ = (Node *) n;
6549 }
6550 | DEALLOCATE PREPARE ALL
6551 {
6552 DeallocateStmt *n = makeNode(DeallocateStmt);
6553 n->name = NULL;
6554 $$ = (Node *) n;
6555 }
6556 ;
6557
6558 /*****************************************************************************
6559 *
6560 * QUERY:
6561 * INSERT STATEMENTS
6562 *
6563 *****************************************************************************/
6564
6565 InsertStmt:
6566 INSERT INTO qualified_name insert_rest returning_clause
6567 {
6568 $4->relation = $3;
6569 $4->returningList = $5;
6570 $$ = (Node *) $4;
6571 }
6572 ;
6573
6574 insert_rest:
6575 SelectStmt
6576 {
6577 $$ = makeNode(InsertStmt);
6578 $$->cols = NIL;
6579 $$->selectStmt = $1;
6580 }
6581 | '(' insert_column_list ')' SelectStmt
6582 {
6583 $$ = makeNode(InsertStmt);
6584 $$->cols = $2;
6585 $$->selectStmt = $4;
6586 }
6587 | DEFAULT VALUES
6588 {
6589 $$ = makeNode(InsertStmt);
6590 $$->cols = NIL;
6591 $$->selectStmt = NULL;
6592 }
6593 ;
6594
6595 insert_column_list:
6596 insert_column_item
6597 { $$ = list_make1($1); }
6598 | insert_column_list ',' insert_column_item
6599 { $$ = lappend($1, $3); }
6600 ;
6601
6602 insert_column_item:
6603 ColId opt_indirection
6604 {
6605 $$ = makeNode(ResTarget);
6606 $$->name = $1;
6607 $$->indirection = check_indirection($2);
6608 $$->val = NULL;
6609 $$->location = @1;
6610 }
6611 ;
6612
6613 returning_clause:
6614 RETURNING target_list { $$ = $2; }
6615 | /* EMPTY */ { $$ = NIL; }
6616 ;
6617
6618
6619 /*****************************************************************************
6620 *
6621 * QUERY:
6622 * DELETE STATEMENTS
6623 *
6624 *****************************************************************************/
6625
6626 DeleteStmt: DELETE_P FROM relation_expr_opt_alias
6627 using_clause where_or_current_clause returning_clause
6628 {
6629 DeleteStmt *n = makeNode(DeleteStmt);
6630 n->relation = $3;
6631 n->usingClause = $4;
6632 n->whereClause = $5;
6633 n->returningList = $6;
6634 $$ = (Node *)n;
6635 }
6636 ;
6637
6638 using_clause:
6639 USING from_list { $$ = $2; }
6640 | /*EMPTY*/ { $$ = NIL; }
6641 ;
6642
6643
6644 /*****************************************************************************
6645 *
6646 * QUERY:
6647 * LOCK TABLE
6648 *
6649 *****************************************************************************/
6650
6651 LockStmt: LOCK_P opt_table relation_expr_list opt_lock opt_nowait
6652 {
6653 LockStmt *n = makeNode(LockStmt);
6654
6655 n->relations = $3;
6656 n->mode = $4;
6657 n->nowait = $5;
6658 $$ = (Node *)n;
6659 }
6660 ;
6661
6662 opt_lock: IN_P lock_type MODE { $$ = $2; }
6663 | /*EMPTY*/ { $$ = AccessExclusiveLock; }
6664 ;
6665
6666 lock_type: ACCESS SHARE { $$ = AccessShareLock; }
6667 | ROW SHARE { $$ = RowShareLock; }
6668 | ROW EXCLUSIVE { $$ = RowExclusiveLock; }
6669 | SHARE UPDATE EXCLUSIVE { $$ = ShareUpdateExclusiveLock; }
6670 | SHARE { $$ = ShareLock; }
6671 | SHARE ROW EXCLUSIVE { $$ = ShareRowExclusiveLock; }
6672 | EXCLUSIVE { $$ = ExclusiveLock; }
6673 | ACCESS EXCLUSIVE { $$ = AccessExclusiveLock; }
6674 ;
6675
6676 opt_nowait: NOWAIT { $$ = TRUE; }
6677 | /*EMPTY*/ { $$ = FALSE; }
6678 ;
6679
6680
6681 /*****************************************************************************
6682 *
6683 * QUERY:
6684 * UpdateStmt (UPDATE)
6685 *
6686 *****************************************************************************/
6687
6688 UpdateStmt: UPDATE relation_expr_opt_alias
6689 SET set_clause_list
6690 from_clause
6691 where_or_current_clause
6692 returning_clause
6693 {
6694 UpdateStmt *n = makeNode(UpdateStmt);
6695 n->relation = $2;
6696 n->targetList = $4;
6697 n->fromClause = $5;
6698 n->whereClause = $6;
6699 n->returningList = $7;
6700 $$ = (Node *)n;
6701 }
6702 ;
6703
6704 set_clause_list:
6705 set_clause { $$ = $1; }
6706 | set_clause_list ',' set_clause { $$ = list_concat($1,$3); }
6707 ;
6708
6709 set_clause:
6710 single_set_clause { $$ = list_make1($1); }
6711 | multiple_set_clause { $$ = $1; }
6712 ;
6713
6714 single_set_clause:
6715 set_target '=' ctext_expr
6716 {
6717 $$ = $1;
6718 $$->val = (Node *) $3;
6719 }
6720 ;
6721
6722 multiple_set_clause:
6723 '(' set_target_list ')' '=' ctext_row
6724 {
6725 ListCell *col_cell;
6726 ListCell *val_cell;
6727
6728 /*
6729 * Break the ctext_row apart, merge individual expressions
6730 * into the destination ResTargets. XXX this approach
6731 * cannot work for general row expressions as sources.
6732 */
6733 if (list_length($2) != list_length($5))
6734 ereport(ERROR,
6735 (errcode(ERRCODE_SYNTAX_ERROR),
6736 errmsg("number of columns does not match number of values"),
6737 scanner_errposition(@1)));
6738 forboth(col_cell, $2, val_cell, $5)
6739 {
6740 ResTarget *res_col = (ResTarget *) lfirst(col_cell);
6741 Node *res_val = (Node *) lfirst(val_cell);
6742
6743 res_col->val = res_val;
6744 }
6745
6746 $$ = $2;
6747 }
6748 ;
6749
6750 set_target:
6751 ColId opt_indirection
6752 {
6753 $$ = makeNode(ResTarget);
6754 $$->name = $1;
6755 $$->indirection = check_indirection($2);
6756 $$->val = NULL; /* upper production sets this */
6757 $$->location = @1;
6758 }
6759 ;
6760
6761 set_target_list:
6762 set_target { $$ = list_make1($1); }
6763 | set_target_list ',' set_target { $$ = lappend($1,$3); }
6764 ;
6765
6766
6767 /*****************************************************************************
6768 *
6769 * QUERY:
6770 * CURSOR STATEMENTS
6771 *
6772 *****************************************************************************/
6773 DeclareCursorStmt: DECLARE name cursor_options CURSOR opt_hold FOR SelectStmt
6774 {
6775 DeclareCursorStmt *n = makeNode(DeclareCursorStmt);
6776 n->portalname = $2;
6777 /* currently we always set FAST_PLAN option */
6778 n->options = $3 | $5 | CURSOR_OPT_FAST_PLAN;
6779 n->query = $7;
6780 $$ = (Node *)n;
6781 }
6782 ;
6783
6784 cursor_options: /*EMPTY*/ { $$ = 0; }
6785 | cursor_options NO SCROLL { $$ = $1 | CURSOR_OPT_NO_SCROLL; }
6786 | cursor_options SCROLL { $$ = $1 | CURSOR_OPT_SCROLL; }
6787 | cursor_options BINARY { $$ = $1 | CURSOR_OPT_BINARY; }
6788 | cursor_options INSENSITIVE { $$ = $1 | CURSOR_OPT_INSENSITIVE; }
6789 ;
6790
6791 opt_hold: /* EMPTY */ { $$ = 0; }
6792 | WITH HOLD { $$ = CURSOR_OPT_HOLD; }
6793 | WITHOUT HOLD { $$ = 0; }
6794 ;
6795
6796 /*****************************************************************************
6797 *
6798 * QUERY:
6799 * SELECT STATEMENTS
6800 *
6801 *****************************************************************************/
6802
6803 /* A complete SELECT statement looks like this.
6804 *
6805 * The rule returns either a single SelectStmt node or a tree of them,
6806 * representing a set-operation tree.
6807 *
6808 * There is an ambiguity when a sub-SELECT is within an a_expr and there
6809 * are excess parentheses: do the parentheses belong to the sub-SELECT or
6810 * to the surrounding a_expr? We don't really care, but yacc wants to know.
6811 * To resolve the ambiguity, we are careful to define the grammar so that
6812 * the decision is staved off as long as possible: as long as we can keep
6813 * absorbing parentheses into the sub-SELECT, we will do so, and only when
6814 * it's no longer possible to do that will we decide that parens belong to
6815 * the expression. For example, in "SELECT (((SELECT 2)) + 3)" the extra
6816 * parentheses are treated as part of the sub-select. The necessity of doing
6817 * it that way is shown by "SELECT (((SELECT 2)) UNION SELECT 2)". Had we
6818 * parsed "((SELECT 2))" as an a_expr, it'd be too late to go back to the
6819 * SELECT viewpoint when we see the UNION.
6820 *
6821 * This approach is implemented by defining a nonterminal select_with_parens,
6822 * which represents a SELECT with at least one outer layer of parentheses,
6823 * and being careful to use select_with_parens, never '(' SelectStmt ')',
6824 * in the expression grammar. We will then have shift-reduce conflicts
6825 * which we can resolve in favor of always treating '(' <select> ')' as
6826 * a select_with_parens. To resolve the conflicts, the productions that
6827 * conflict with the select_with_parens productions are manually given
6828 * precedences lower than the precedence of ')', thereby ensuring that we
6829 * shift ')' (and then reduce to select_with_parens) rather than trying to
6830 * reduce the inner <select> nonterminal to something else. We use UMINUS
6831 * precedence for this, which is a fairly arbitrary choice.
6832 *
6833 * To be able to define select_with_parens itself without ambiguity, we need
6834 * a nonterminal select_no_parens that represents a SELECT structure with no
6835 * outermost parentheses. This is a little bit tedious, but it works.
6836 *
6837 * In non-expression contexts, we use SelectStmt which can represent a SELECT
6838 * with or without outer parentheses.
6839 */
6840
6841 SelectStmt: select_no_parens %prec UMINUS
6842 | select_with_parens %prec UMINUS
6843 ;
6844
6845 select_with_parens:
6846 '(' select_no_parens ')' { $$ = $2; }
6847 | '(' select_with_parens ')' { $$ = $2; }
6848 ;
6849
6850 /*
6851 * This rule parses the equivalent of the standard's <query expression>.
6852 * The duplicative productions are annoying, but hard to get rid of without
6853 * creating shift/reduce conflicts.
6854 *
6855 * FOR UPDATE/SHARE may be before or after LIMIT/OFFSET.
6856 * In <=7.2.X, LIMIT/OFFSET had to be after FOR UPDATE
6857 * We now support both orderings, but prefer LIMIT/OFFSET before FOR UPDATE/SHARE
6858 * 2002-08-28 bjm
6859 */
6860 select_no_parens:
6861 simple_select { $$ = $1; }
6862 | select_clause sort_clause
6863 {
6864 insertSelectOptions((SelectStmt *) $1, $2, NIL,
6865 NULL, NULL, NULL);
6866 $$ = $1;
6867 }
6868 | select_clause opt_sort_clause for_locking_clause opt_select_limit
6869 {
6870 insertSelectOptions((SelectStmt *) $1, $2, $3,
6871 list_nth($4, 0), list_nth($4, 1),
6872 NULL);
6873 $$ = $1;
6874 }
6875 | select_clause opt_sort_clause select_limit opt_for_locking_clause
6876 {
6877 insertSelectOptions((SelectStmt *) $1, $2, $4,
6878 list_nth($3, 0), list_nth($3, 1),
6879 NULL);
6880 $$ = $1;
6881 }
6882 | with_clause simple_select
6883 {
6884 insertSelectOptions((SelectStmt *) $2, NULL, NIL,
6885 NULL, NULL,
6886 $1);
6887 $$ = $2;
6888 }
6889 | with_clause select_clause sort_clause
6890 {
6891 insertSelectOptions((SelectStmt *) $2, $3, NIL,
6892 NULL, NULL,
6893 $1);
6894 $$ = $2;
6895 }
6896 | with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit
6897 {
6898 insertSelectOptions((SelectStmt *) $2, $3, $4,
6899 list_nth($5, 0), list_nth($5, 1),
6900 $1);
6901 $$ = $2;
6902 }
6903 | with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause
6904 {
6905 insertSelectOptions((SelectStmt *) $2, $3, $5,
6906 list_nth($4, 0), list_nth($4, 1),
6907 $1);
6908 $$ = $2;
6909 }
6910 ;
6911
6912 select_clause:
6913 simple_select { $$ = $1; }
6914 | select_with_parens { $$ = $1; }
6915 ;
6916
6917 /*
6918 * This rule parses SELECT statements that can appear within set operations,
6919 * including UNION, INTERSECT and EXCEPT. '(' and ')' can be used to specify
6920 * the ordering of the set operations. Without '(' and ')' we want the
6921 * operations to be ordered per the precedence specs at the head of this file.
6922 *
6923 * As with select_no_parens, simple_select cannot have outer parentheses,
6924 * but can have parenthesized subclauses.
6925 *
6926 * Note that sort clauses cannot be included at this level --- SQL92 requires
6927 * SELECT foo UNION SELECT bar ORDER BY baz
6928 * to be parsed as
6929 * (SELECT foo UNION SELECT bar) ORDER BY baz
6930 * not
6931 * SELECT foo UNION (SELECT bar ORDER BY baz)
6932 * Likewise for WITH, FOR UPDATE and LIMIT. Therefore, those clauses are
6933 * described as part of the select_no_parens production, not simple_select.
6934 * This does not limit functionality, because you can reintroduce these
6935 * clauses inside parentheses.
6936 *
6937 * NOTE: only the leftmost component SelectStmt should have INTO.
6938 * However, this is not checked by the grammar; parse analysis must check it.
6939 */
6940 simple_select:
6941 SELECT opt_distinct target_list
6942 into_clause from_clause where_clause
6943 group_clause having_clause window_clause
6944 {
6945 SelectStmt *n = makeNode(SelectStmt);
6946 n->distinctClause = $2;
6947 n->targetList = $3;
6948 n->intoClause = $4;
6949 n->fromClause = $5;
6950 n->whereClause = $6;
6951 n->groupClause = $7;
6952 n->havingClause = $8;
6953 n->windowClause = $9;
6954 $$ = (Node *)n;
6955 }
6956 | values_clause { $$ = $1; }
6957 | TABLE relation_expr
6958 {
6959 /* same as SELECT * FROM relation_expr */
6960 ColumnRef *cr = makeNode(ColumnRef);
6961 ResTarget *rt = makeNode(ResTarget);
6962 SelectStmt *n = makeNode(SelectStmt);
6963
6964 cr->fields = list_make1(makeNode(A_Star));
6965 cr->location = -1;
6966
6967 rt->name = NULL;
6968 rt->indirection = NIL;
6969 rt->val = (Node *)cr;
6970 rt->location = -1;
6971
6972 n->targetList = list_make1(rt);
6973 n->fromClause = list_make1($2);
6974 $$ = (Node *)n;
6975 }
6976 | select_clause UNION opt_all select_clause
6977 {
6978 $$ = makeSetOp(SETOP_UNION, $3, $1, $4);
6979 }
6980 | select_clause INTERSECT opt_all select_clause
6981 {
6982 $$ = makeSetOp(SETOP_INTERSECT, $3, $1, $4);
6983 }
6984 | select_clause EXCEPT opt_all select_clause
6985 {
6986 $$ = makeSetOp(SETOP_EXCEPT, $3, $1, $4);
6987 }
6988 ;
6989
6990 /*
6991 * SQL standard WITH clause looks like:
6992 *
6993 * WITH [ RECURSIVE ] <query name> [ (<column>,...) ]
6994 * AS (query) [ SEARCH or CYCLE clause ]
6995 *
6996 * We don't currently support the SEARCH or CYCLE clause.
6997 */
6998 with_clause:
6999 WITH cte_list
7000 {
7001 $$ = makeNode(WithClause);
7002 $$->ctes = $2;
7003 $$->recursive = false;
7004 $$->location = @1;
7005 }
7006 | WITH RECURSIVE cte_list
7007 {
7008 $$ = makeNode(WithClause);
7009 $$->ctes = $3;
7010 $$->recursive = true;
7011 $$->location = @1;
7012 }
7013 ;
7014
7015 cte_list:
7016 common_table_expr { $$ = list_make1($1); }
7017 | cte_list ',' common_table_expr { $$ = lappend($1, $3); }
7018 ;
7019
7020 common_table_expr: name opt_name_list AS select_with_parens
7021 {
7022 CommonTableExpr *n = makeNode(CommonTableExpr);
7023 n->ctename = $1;
7024 n->aliascolnames = $2;
7025 n->ctequery = $4;
7026 n->location = @1;
7027 $$ = (Node *) n;
7028 }
7029 ;
7030
7031 into_clause:
7032 INTO OptTempTableName
7033 {
7034 $$ = makeNode(IntoClause);
7035 $$->rel = $2;
7036 $$->colNames = NIL;
7037 $$->options = NIL;
7038 $$->onCommit = ONCOMMIT_NOOP;
7039 $$->tableSpaceName = NULL;
7040 }
7041 | /*EMPTY*/
7042 { $$ = NULL; }
7043 ;
7044
7045 /*
7046 * Redundancy here is needed to avoid shift/reduce conflicts,
7047 * since TEMP is not a reserved word. See also OptTemp.
7048 */
7049 OptTempTableName:
7050 TEMPORARY opt_table qualified_name
7051 {
7052 $$ = $3;
7053 $$->istemp = true;
7054 }
7055 | TEMP opt_table qualified_name
7056 {
7057 $$ = $3;
7058 $$->istemp = true;
7059 }
7060 | LOCAL TEMPORARY opt_table qualified_name
7061 {
7062 $$ = $4;
7063 $$->istemp = true;
7064 }
7065 | LOCAL TEMP opt_table qualified_name
7066 {
7067 $$ = $4;
7068 $$->istemp = true;
7069 }
7070 | GLOBAL TEMPORARY opt_table qualified_name
7071 {
7072 $$ = $4;
7073 $$->istemp = true;
7074 }
7075 | GLOBAL TEMP opt_table qualified_name
7076 {
7077 $$ = $4;
7078 $$->istemp = true;
7079 }
7080 | TABLE qualified_name
7081 {
7082 $$ = $2;
7083 $$->istemp = false;
7084 }
7085 | qualified_name
7086 {
7087 $$ = $1;
7088 $$->istemp = false;
7089 }
7090 ;
7091
7092 opt_table: TABLE {}
7093 | /*EMPTY*/ {}
7094 ;
7095
7096 opt_all: ALL { $$ = TRUE; }
7097 | DISTINCT { $$ = FALSE; }
7098 | /*EMPTY*/ { $$ = FALSE; }
7099 ;
7100
7101 /* We use (NIL) as a placeholder to indicate that all target expressions
7102 * should be placed in the DISTINCT list during parsetree analysis.
7103 */
7104 opt_distinct:
7105 DISTINCT { $$ = list_make1(NIL); }
7106 | DISTINCT ON '(' expr_list ')' { $$ = $4; }
7107 | ALL { $$ = NIL; }
7108 | /*EMPTY*/ { $$ = NIL; }
7109 ;
7110
7111 opt_sort_clause:
7112 sort_clause { $$ = $1;}
7113 | /*EMPTY*/ { $$ = NIL; }
7114 ;
7115
7116 sort_clause:
7117 ORDER BY sortby_list { $$ = $3; }
7118 ;
7119
7120 sortby_list:
7121 sortby { $$ = list_make1($1); }
7122 | sortby_list ',' sortby { $$ = lappend($1, $3); }
7123 ;
7124
7125 sortby: a_expr USING qual_all_Op opt_nulls_order
7126 {
7127 $$ = makeNode(SortBy);
7128 $$->node = $1;
7129 $$->sortby_dir = SORTBY_USING;
7130 $$->sortby_nulls = $4;
7131 $$->useOp = $3;
7132 $$->location = @3;
7133 }
7134 | a_expr opt_asc_desc opt_nulls_order
7135 {
7136 $$ = makeNode(SortBy);
7137 $$->node = $1;
7138 $$->sortby_dir = $2;
7139 $$->sortby_nulls = $3;
7140 $$->useOp = NIL;
7141 $$->location = -1; /* no operator */
7142 }
7143 ;
7144
7145
7146 select_limit:
7147 LIMIT select_limit_value OFFSET select_offset_value
7148 { $$ = list_make2($4, $2); }
7149 | OFFSET select_offset_value LIMIT select_limit_value
7150 { $$ = list_make2($2, $4); }
7151 | LIMIT select_limit_value
7152 { $$ = list_make2(NULL, $2); }
7153 | OFFSET select_offset_value
7154 { $$ = list_make2($2, NULL); }
7155 | LIMIT select_limit_value ',' select_offset_value
7156 {
7157 /* Disabled because it was too confusing, bjm 2002-02-18 */
7158 ereport(ERROR,
7159 (errcode(ERRCODE_SYNTAX_ERROR),
7160 errmsg("LIMIT #,# syntax is not supported"),
7161 errhint("Use separate LIMIT and OFFSET clauses."),
7162 scanner_errposition(@1)));
7163 }
7164 /* SQL:2008 syntax variants */
7165 | OFFSET select_offset_value2 row_or_rows
7166 { $$ = list_make2($2, NULL); }
7167 | FETCH first_or_next opt_select_fetch_first_value row_or_rows ONLY
7168 { $$ = list_make2(NULL, $3); }
7169 | OFFSET select_offset_value2 row_or_rows FETCH first_or_next opt_select_fetch_first_value row_or_rows ONLY
7170 { $$ = list_make2($2, $6); }
7171 ;
7172
7173 opt_select_limit:
7174 select_limit { $$ = $1; }
7175 | /* EMPTY */
7176 { $$ = list_make2(NULL,NULL); }
7177 ;
7178
7179 select_limit_value:
7180 a_expr { $$ = $1; }
7181 | ALL
7182 {
7183 /* LIMIT ALL is represented as a NULL constant */
7184 $$ = makeNullAConst(@1);
7185 }
7186 ;
7187
7188 /*
7189 * Allowing full expressions without parentheses causes various parsing
7190 * problems with the trailing ROW/ROWS key words. SQL only calls for
7191 * constants, so we allow the rest only with parentheses.
7192 */
7193 opt_select_fetch_first_value:
7194 SignedIconst { $$ = makeIntConst($1, @1); }
7195 | '(' a_expr ')' { $$ = $2; }
7196 | /*EMPTY*/ { $$ = makeIntConst(1, -1); }
7197 ;
7198
7199 select_offset_value:
7200 a_expr { $$ = $1; }
7201 ;
7202
7203 /*
7204 * Again, the trailing ROW/ROWS in this case prevent the full expression
7205 * syntax. c_expr is the best we can do.
7206 */
7207 select_offset_value2:
7208 c_expr { $$ = $1; }
7209 ;
7210
7211 /* noise words */
7212 row_or_rows:
7213 ROW { $$ = 0; }
7214 | ROWS { $$ = 0; }
7215 ;
7216
7217 /* noise words */
7218 first_or_next:
7219 FIRST_P { $$ = 0; }
7220 | NEXT { $$ = 0; }
7221 ;
7222
7223 group_clause:
7224 GROUP_P BY expr_list { $$ = $3; }
7225 | /*EMPTY*/ { $$ = NIL; }
7226 ;
7227
7228 having_clause:
7229 HAVING a_expr { $$ = $2; }
7230 | /*EMPTY*/ { $$ = NULL; }
7231 ;
7232
7233 for_locking_clause:
7234 for_locking_items { $$ = $1; }
7235 | FOR READ ONLY { $$ = NIL; }
7236 ;
7237
7238 opt_for_locking_clause:
7239 for_locking_clause { $$ = $1; }
7240 | /* EMPTY */ { $$ = NIL; }
7241 ;
7242
7243 for_locking_items:
7244 for_locking_item { $$ = list_make1($1); }
7245 | for_locking_items for_locking_item { $$ = lappend($1, $2); }
7246 ;
7247
7248 for_locking_item:
7249 FOR UPDATE locked_rels_list opt_nowait
7250 {
7251 LockingClause *n = makeNode(LockingClause);
7252 n->lockedRels = $3;
7253 n->forUpdate = TRUE;
7254 n->noWait = $4;
7255 $$ = (Node *) n;
7256 }
7257 | FOR SHARE locked_rels_list opt_nowait
7258 {
7259 LockingClause *n = makeNode(LockingClause);
7260 n->lockedRels = $3;
7261 n->forUpdate = FALSE;
7262 n->noWait = $4;
7263 $$ = (Node *) n;
7264 }
7265 ;
7266
7267 locked_rels_list:
7268 OF qualified_name_list { $$ = $2; }
7269 | /* EMPTY */ { $$ = NIL; }
7270 ;
7271
7272
7273 values_clause:
7274 VALUES ctext_row
7275 {
7276 SelectStmt *n = makeNode(SelectStmt);
7277 n->valuesLists = list_make1($2);
7278 $$ = (Node *) n;
7279 }
7280 | values_clause ',' ctext_row
7281 {
7282 SelectStmt *n = (SelectStmt *) $1;
7283 n->valuesLists = lappend(n->valuesLists, $3);
7284 $$ = (Node *) n;
7285 }
7286 ;
7287
7288
7289 /*****************************************************************************
7290 *
7291 * clauses common to all Optimizable Stmts:
7292 * from_clause - allow list of both JOIN expressions and table names
7293 * where_clause - qualifications for joins or restrictions
7294 *
7295 *****************************************************************************/
7296
7297 from_clause:
7298 FROM from_list { $$ = $2; }
7299 | /*EMPTY*/ { $$ = NIL; }
7300 ;
7301
7302 from_list:
7303 table_ref { $$ = list_make1($1); }
7304 | from_list ',' table_ref { $$ = lappend($1, $3); }
7305 ;
7306
7307 /*
7308 * table_ref is where an alias clause can be attached. Note we cannot make
7309 * alias_clause have an empty production because that causes parse conflicts
7310 * between table_ref := '(' joined_table ')' alias_clause
7311 * and joined_table := '(' joined_table ')'. So, we must have the
7312 * redundant-looking productions here instead.
7313 */
7314 table_ref: relation_expr
7315 {
7316 $$ = (Node *) $1;
7317 }
7318 | relation_expr alias_clause
7319 {
7320 $1->alias = $2;
7321 $$ = (Node *) $1;
7322 }
7323 | func_table
7324 {
7325 RangeFunction *n = makeNode(RangeFunction);
7326 n->funccallnode = $1;
7327 n->coldeflist = NIL;
7328 $$ = (Node *) n;
7329 }
7330 | func_table alias_clause
7331 {
7332 RangeFunction *n = makeNode(RangeFunction);
7333 n->funccallnode = $1;
7334 n->alias = $2;
7335 n->coldeflist = NIL;
7336 $$ = (Node *) n;
7337 }
7338 | func_table AS '(' TableFuncElementList ')'
7339 {
7340 RangeFunction *n = makeNode(RangeFunction);
7341 n->funccallnode = $1;
7342 n->coldeflist = $4;
7343 $$ = (Node *) n;
7344 }
7345 | func_table AS ColId '(' TableFuncElementList ')'
7346 {
7347 RangeFunction *n = makeNode(RangeFunction);
7348 Alias *a = makeNode(Alias);
7349 n->funccallnode = $1;
7350 a->aliasname = $3;
7351 n->alias = a;
7352 n->coldeflist = $5;
7353 $$ = (Node *) n;
7354 }
7355 | func_table ColId '(' TableFuncElementList ')'
7356 {
7357 RangeFunction *n = makeNode(RangeFunction);
7358 Alias *a = makeNode(Alias);
7359 n->funccallnode = $1;
7360 a->aliasname = $2;
7361 n->alias = a;
7362 n->coldeflist = $4;
7363 $$ = (Node *) n;
7364 }
7365 | select_with_parens
7366 {
7367 /*
7368 * The SQL spec does not permit a subselect
7369 * (<derived_table>) without an alias clause,
7370 * so we don't either. This avoids the problem
7371 * of needing to invent a unique refname for it.
7372 * That could be surmounted if there's sufficient
7373 * popular demand, but for now let's just implement
7374 * the spec and see if anyone complains.
7375 * However, it does seem like a good idea to emit
7376 * an error message that's better than "syntax error".
7377 */
7378 if (IsA($1, SelectStmt) &&
7379 ((SelectStmt *) $1)->valuesLists)
7380 ereport(ERROR,
7381 (errcode(ERRCODE_SYNTAX_ERROR),
7382 errmsg("VALUES in FROM must have an alias"),
7383 errhint("For example, FROM (VALUES ...) [AS] foo."),
7384 scanner_errposition(@1)));
7385 else
7386 ereport(ERROR,
7387 (errcode(ERRCODE_SYNTAX_ERROR),
7388 errmsg("subquery in FROM must have an alias"),
7389 errhint("For example, FROM (SELECT ...) [AS] foo."),
7390 scanner_errposition(@1)));
7391 $$ = NULL;
7392 }
7393 | select_with_parens alias_clause
7394 {
7395 RangeSubselect *n = makeNode(RangeSubselect);
7396 n->subquery = $1;
7397 n->alias = $2;
7398 $$ = (Node *) n;
7399 }
7400 | joined_table
7401 {
7402 $$ = (Node *) $1;
7403 }
7404 | '(' joined_table ')' alias_clause
7405 {
7406 $2->alias = $4;
7407 $$ = (Node *) $2;
7408 }
7409 ;
7410
7411
7412 /*
7413 * It may seem silly to separate joined_table from table_ref, but there is
7414 * method in SQL92's madness: if you don't do it this way you get reduce-
7415 * reduce conflicts, because it's not clear to the parser generator whether
7416 * to expect alias_clause after ')' or not. For the same reason we must
7417 * treat 'JOIN' and 'join_type JOIN' separately, rather than allowing
7418 * join_type to expand to empty; if we try it, the parser generator can't
7419 * figure out when to reduce an empty join_type right after table_ref.
7420 *
7421 * Note that a CROSS JOIN is the same as an unqualified
7422 * INNER JOIN, and an INNER JOIN/ON has the same shape
7423 * but a qualification expression to limit membership.
7424 * A NATURAL JOIN implicitly matches column names between
7425 * tables and the shape is determined by which columns are
7426 * in common. We'll collect columns during the later transformations.
7427 */
7428
7429 joined_table:
7430 '(' joined_table ')'
7431 {
7432 $$ = $2;
7433 }
7434 | table_ref CROSS JOIN table_ref
7435 {
7436 /* CROSS JOIN is same as unqualified inner join */
7437 JoinExpr *n = makeNode(JoinExpr);
7438 n->jointype = JOIN_INNER;
7439 n->isNatural = FALSE;
7440 n->larg = $1;
7441 n->rarg = $4;
7442 n->using = NIL;
7443 n->quals = NULL;
7444 $$ = n;
7445 }
7446 | table_ref join_type JOIN table_ref join_qual
7447 {
7448 JoinExpr *n = makeNode(JoinExpr);
7449 n->jointype = $2;
7450 n->isNatural = FALSE;
7451 n->larg = $1;
7452 n->rarg = $4;
7453 if ($5 != NULL && IsA($5, List))
7454 n->using = (List *) $5; /* USING clause */
7455 else
7456 n->quals = $5; /* ON clause */
7457 $$ = n;
7458 }
7459 | table_ref JOIN table_ref join_qual
7460 {
7461 /* letting join_type reduce to empty doesn't work */
7462 JoinExpr *n = makeNode(JoinExpr);
7463 n->jointype = JOIN_INNER;
7464 n->isNatural = FALSE;
7465 n->larg = $1;
7466 n->rarg = $3;
7467 if ($4 != NULL && IsA($4, List))
7468 n->using = (List *) $4; /* USING clause */
7469 else
7470 n->quals = $4; /* ON clause */
7471 $$ = n;
7472 }
7473 | table_ref NATURAL join_type JOIN table_ref
7474 {
7475 JoinExpr *n = makeNode(JoinExpr);
7476 n->jointype = $3;
7477 n->isNatural = TRUE;
7478 n->larg = $1;
7479 n->rarg = $5;
7480 n->using = NIL; /* figure out which columns later... */
7481 n->quals = NULL; /* fill later */
7482 $$ = n;
7483 }
7484 | table_ref NATURAL JOIN table_ref
7485 {
7486 /* letting join_type reduce to empty doesn't work */
7487 JoinExpr *n = makeNode(JoinExpr);
7488 n->jointype = JOIN_INNER;
7489 n->isNatural = TRUE;
7490 n->larg = $1;
7491 n->rarg = $4;
7492 n->using = NIL; /* figure out which columns later... */
7493 n->quals = NULL; /* fill later */
7494 $$ = n;
7495 }
7496 ;
7497
7498 alias_clause:
7499 AS ColId '(' name_list ')'
7500 {
7501 $$ = makeNode(Alias);
7502 $$->aliasname = $2;
7503 $$->colnames = $4;
7504 }
7505 | AS ColId
7506 {
7507 $$ = makeNode(Alias);
7508 $$->aliasname = $2;
7509 }
7510 | ColId '(' name_list ')'
7511 {
7512 $$ = makeNode(Alias);
7513 $$->aliasname = $1;
7514 $$->colnames = $3;
7515 }
7516 | ColId
7517 {
7518 $$ = makeNode(Alias);
7519 $$->aliasname = $1;
7520 }
7521 ;
7522
7523 join_type: FULL join_outer { $$ = JOIN_FULL; }
7524 | LEFT join_outer { $$ = JOIN_LEFT; }
7525 | RIGHT join_outer { $$ = JOIN_RIGHT; }
7526 | INNER_P { $$ = JOIN_INNER; }
7527 ;
7528
7529 /* OUTER is just noise... */
7530 join_outer: OUTER_P { $$ = NULL; }
7531 | /*EMPTY*/ { $$ = NULL; }
7532 ;
7533
7534 /* JOIN qualification clauses
7535 * Possibilities are:
7536 * USING ( column list ) allows only unqualified column names,
7537 * which must match between tables.
7538 * ON expr allows more general qualifications.
7539 *
7540 * We return USING as a List node, while an ON-expr will not be a List.
7541 */
7542
7543 join_qual: USING '(' name_list ')' { $$ = (Node *) $3; }
7544 | ON a_expr { $$ = $2; }
7545 ;
7546
7547
7548 relation_expr:
7549 qualified_name
7550 {
7551 /* default inheritance */
7552 $$ = $1;
7553 $$->inhOpt = INH_DEFAULT;
7554 $$->alias = NULL;
7555 }
7556 | qualified_name '*'
7557 {
7558 /* inheritance query */
7559 $$ = $1;
7560 $$->inhOpt = INH_YES;
7561 $$->alias = NULL;
7562 }
7563 | ONLY qualified_name
7564 {
7565 /* no inheritance */
7566 $$ = $2;
7567 $$->inhOpt = INH_NO;
7568 $$->alias = NULL;
7569 }
7570 | ONLY '(' qualified_name ')'
7571 {
7572 /* no inheritance, SQL99-style syntax */
7573 $$ = $3;
7574 $$->inhOpt = INH_NO;
7575 $$->alias = NULL;
7576 }
7577 ;
7578
7579
7580 relation_expr_list:
7581 relation_expr { $$ = list_make1($1); }
7582 | relation_expr_list ',' relation_expr { $$ = lappend($1, $3); }
7583 ;
7584
7585
7586 /*
7587 * Given "UPDATE foo set set ...", we have to decide without looking any
7588 * further ahead whether the first "set" is an alias or the UPDATE's SET
7589 * keyword. Since "set" is allowed as a column name both interpretations
7590 * are feasible. We resolve the shift/reduce conflict by giving the first
7591 * relation_expr_opt_alias production a higher precedence than the SET token
7592 * has, causing the parser to prefer to reduce, in effect assuming that the
7593 * SET is not an alias.
7594 */
7595 relation_expr_opt_alias: relation_expr %prec UMINUS
7596 {
7597 $$ = $1;
7598 }
7599 | relation_expr ColId
7600 {
7601 Alias *alias = makeNode(Alias);
7602 alias->aliasname = $2;
7603 $1->alias = alias;
7604 $$ = $1;
7605 }
7606 | relation_expr AS ColId
7607 {
7608 Alias *alias = makeNode(Alias);
7609 alias->aliasname = $3;
7610 $1->alias = alias;
7611 $$ = $1;
7612 }
7613 ;
7614
7615
7616 func_table: func_expr { $$ = $1; }
7617 ;
7618
7619
7620 where_clause:
7621 WHERE a_expr { $$ = $2; }
7622 | /*EMPTY*/ { $$ = NULL; }
7623 ;
7624
7625 /* variant for UPDATE and DELETE */
7626 where_or_current_clause:
7627 WHERE a_expr { $$ = $2; }
7628 | WHERE CURRENT_P OF name
7629 {
7630 CurrentOfExpr *n = makeNode(CurrentOfExpr);
7631 /* cvarno is filled in by parse analysis */
7632 n->cursor_name = $4;
7633 n->cursor_param = 0;
7634 $$ = (Node *) n;
7635 }
7636 | WHERE CURRENT_P OF PARAM
7637 {
7638 CurrentOfExpr *n = makeNode(CurrentOfExpr);
7639 /* cvarno is filled in by parse analysis */
7640 n->cursor_name = NULL;
7641 n->cursor_param = $4;
7642 $$ = (Node *) n;
7643 }
7644 | /*EMPTY*/ { $$ = NULL; }
7645 ;
7646
7647
7648 TableFuncElementList:
7649 TableFuncElement
7650 {
7651 $$ = list_make1($1);
7652 }
7653 | TableFuncElementList ',' TableFuncElement
7654 {
7655 $$ = lappend($1, $3);
7656 }
7657 ;
7658
7659 TableFuncElement: ColId Typename
7660 {
7661 ColumnDef *n = makeNode(ColumnDef);
7662 n->colname = $1;
7663 n->typename = $2;
7664 n->constraints = NIL;
7665 n->is_local = true;
7666 $$ = (Node *)n;
7667 }
7668 ;
7669
7670 /*****************************************************************************
7671 *
7672 * Type syntax
7673 * SQL92 introduces a large amount of type-specific syntax.
7674 * Define individual clauses to handle these cases, and use
7675 * the generic case to handle regular type-extensible Postgres syntax.
7676 * - thomas 1997-10-10
7677 *
7678 *****************************************************************************/
7679
7680 Typename: SimpleTypename opt_array_bounds
7681 {
7682 $$ = $1;
7683 $$->arrayBounds = $2;
7684 }
7685 | SETOF SimpleTypename opt_array_bounds
7686 {
7687 $$ = $2;
7688 $$->arrayBounds = $3;
7689 $$->setof = TRUE;
7690 }
7691 /* SQL standard syntax, currently only one-dimensional */
7692 | SimpleTypename ARRAY '[' Iconst ']'
7693 {
7694 $$ = $1;
7695 $$->arrayBounds = list_make1(makeInteger($4));
7696 }
7697 | SETOF SimpleTypename ARRAY '[' Iconst ']'
7698 {
7699 $$ = $2;
7700 $$->arrayBounds = list_make1(makeInteger($5));
7701 $$->setof = TRUE;
7702 }
7703 | SimpleTypename ARRAY
7704 {
7705 $$ = $1;
7706 $$->arrayBounds = list_make1(makeInteger(-1));
7707 }
7708 | SETOF SimpleTypename ARRAY
7709 {
7710 $$ = $2;
7711 $$->arrayBounds = list_make1(makeInteger(-1));
7712 $$->setof = TRUE;
7713 }
7714 ;
7715
7716 opt_array_bounds:
7717 opt_array_bounds '[' ']'
7718 { $$ = lappend($1, makeInteger(-1)); }
7719 | opt_array_bounds '[' Iconst ']'
7720 { $$ = lappend($1, makeInteger($3)); }
7721 | /*EMPTY*/
7722 { $$ = NIL; }
7723 ;
7724
7725 SimpleTypename:
7726 GenericType { $$ = $1; }
7727 | Numeric { $$ = $1; }
7728 | Bit { $$ = $1; }
7729 | Character { $$ = $1; }
7730 | ConstDatetime { $$ = $1; }
7731 | ConstInterval opt_interval
7732 {
7733 $$ = $1;
7734 $$->typmods = $2;
7735 }
7736 | ConstInterval '(' Iconst ')' opt_interval
7737 {
7738 $$ = $1;
7739 if ($5 != NIL)
7740 {
7741 if (list_length($5) != 1)
7742 ereport(ERROR,
7743 (errcode(ERRCODE_SYNTAX_ERROR),
7744 errmsg("interval precision specified twice"),
7745 scanner_errposition(@1)));
7746 $$->typmods = lappend($5, makeIntConst($3, @3));
7747 }
7748 else
7749 $$->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
7750 makeIntConst($3, @3));
7751 }
7752 ;
7753
7754 /* We have a separate ConstTypename to allow defaulting fixed-length
7755 * types such as CHAR() and BIT() to an unspecified length.
7756 * SQL9x requires that these default to a length of one, but this
7757 * makes no sense for constructs like CHAR 'hi' and BIT '0101',
7758 * where there is an obvious better choice to make.
7759 * Note that ConstInterval is not included here since it must
7760 * be pushed up higher in the rules to accomodate the postfix
7761 * options (e.g. INTERVAL '1' YEAR). Likewise, we have to handle
7762 * the generic-type-name case in AExprConst to avoid premature
7763 * reduce/reduce conflicts against function names.
7764 */
7765 ConstTypename:
7766 Numeric { $$ = $1; }
7767 | ConstBit { $$ = $1; }
7768 | ConstCharacter { $$ = $1; }
7769 | ConstDatetime { $$ = $1; }
7770 ;
7771
7772 /*
7773 * GenericType covers all type names that don't have special syntax mandated
7774 * by the standard, including qualified names. We also allow type modifiers.
7775 * To avoid parsing conflicts against function invocations, the modifiers
7776 * have to be shown as expr_list here, but parse analysis will only accept
7777 * constants for them.
7778 */
7779 GenericType:
7780 type_function_name opt_type_modifiers
7781 {
7782 $$ = makeTypeName($1);
7783 $$->typmods = $2;
7784 $$->location = @1;
7785 }
7786 | type_function_name attrs opt_type_modifiers
7787 {
7788 $$ = makeTypeNameFromNameList(lcons(makeString($1), $2));
7789 $$->typmods = $3;
7790 $$->location = @1;
7791 }
7792 ;
7793
7794 opt_type_modifiers: '(' expr_list ')' { $$ = $2; }
7795 | /* EMPTY */ { $$ = NIL; }
7796 ;
7797
7798 /*
7799 * SQL92 numeric data types
7800 */
7801 Numeric: INT_P
7802 {
7803 $$ = SystemTypeName("int4");
7804 $$->location = @1;
7805 }
7806 | INTEGER
7807 {
7808 $$ = SystemTypeName("int4");
7809 $$->location = @1;
7810 }
7811 | SMALLINT
7812 {
7813 $$ = SystemTypeName("int2");
7814 $$->location = @1;
7815 }
7816 | BIGINT
7817 {
7818 $$ = SystemTypeName("int8");
7819 $$->location = @1;
7820 }
7821 | REAL
7822 {
7823 $$ = SystemTypeName("float4");
7824 $$->location = @1;
7825 }
7826 | FLOAT_P opt_float
7827 {
7828 $$ = $2;
7829 $$->location = @1;
7830 }
7831 | DOUBLE_P PRECISION
7832 {
7833 $$ = SystemTypeName("float8");
7834 $$->location = @1;
7835 }
7836 | DECIMAL_P opt_type_modifiers
7837 {
7838 $$ = SystemTypeName("numeric");
7839 $$->typmods = $2;
7840 $$->location = @1;
7841 }
7842 | DEC opt_type_modifiers
7843 {
7844 $$ = SystemTypeName("numeric");
7845 $$->typmods = $2;
7846 $$->location = @1;
7847 }
7848 | NUMERIC opt_type_modifiers
7849 {
7850 $$ = SystemTypeName("numeric");
7851 $$->typmods = $2;
7852 $$->location = @1;
7853 }
7854 | BOOLEAN_P
7855 {
7856 $$ = SystemTypeName("bool");
7857 $$->location = @1;
7858 }
7859 ;
7860
7861 opt_float: '(' Iconst ')'
7862 {
7863 /*
7864 * Check FLOAT() precision limits assuming IEEE floating
7865 * types - thomas 1997-09-18
7866 */
7867 if ($2 < 1)
7868 ereport(ERROR,
7869 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7870 errmsg("precision for type float must be at least 1 bit"),
7871 scanner_errposition(@2)));
7872 else if ($2 <= 24)
7873 $$ = SystemTypeName("float4");
7874 else if ($2 <= 53)
7875 $$ = SystemTypeName("float8");
7876 else
7877 ereport(ERROR,
7878 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7879 errmsg("precision for type float must be less than 54 bits"),
7880 scanner_errposition(@2)));
7881 }
7882 | /*EMPTY*/
7883 {
7884 $$ = SystemTypeName("float8");
7885 }
7886 ;
7887
7888 /*
7889 * SQL92 bit-field data types
7890 * The following implements BIT() and BIT VARYING().
7891 */
7892 Bit: BitWithLength
7893 {
7894 $$ = $1;
7895 }
7896 | BitWithoutLength
7897 {
7898 $$ = $1;
7899 }
7900 ;
7901
7902 /* ConstBit is like Bit except "BIT" defaults to unspecified length */
7903 /* See notes for ConstCharacter, which addresses same issue for "CHAR" */
7904 ConstBit: BitWithLength
7905 {
7906 $$ = $1;
7907 }
7908 | BitWithoutLength
7909 {
7910 $$ = $1;
7911 $$->typmods = NIL;
7912 }
7913 ;
7914
7915 BitWithLength:
7916 BIT opt_varying '(' expr_list ')'
7917 {
7918 char *typname;
7919
7920 typname = $2 ? "varbit" : "bit";
7921 $$ = SystemTypeName(typname);
7922 $$->typmods = $4;
7923 $$->location = @1;
7924 }
7925 ;
7926
7927 BitWithoutLength:
7928 BIT opt_varying
7929 {
7930 /* bit defaults to bit(1), varbit to no limit */
7931 if ($2)
7932 {
7933 $$ = SystemTypeName("varbit");
7934 }
7935 else
7936 {
7937 $$ = SystemTypeName("bit");
7938 $$->typmods = list_make1(makeIntConst(1, -1));
7939 }
7940 $$->location = @1;
7941 }
7942 ;
7943
7944
7945 /*
7946 * SQL92 character data types
7947 * The following implements CHAR() and VARCHAR().
7948 */
7949 Character: CharacterWithLength
7950 {
7951 $$ = $1;
7952 }
7953 | CharacterWithoutLength
7954 {
7955 $$ = $1;
7956 }
7957 ;
7958
7959 ConstCharacter: CharacterWithLength
7960 {
7961 $$ = $1;
7962 }
7963 | CharacterWithoutLength
7964 {
7965 /* Length was not specified so allow to be unrestricted.
7966 * This handles problems with fixed-length (bpchar) strings
7967 * which in column definitions must default to a length
7968 * of one, but should not be constrained if the length
7969 * was not specified.
7970 */
7971 $$ = $1;
7972 $$->typmods = NIL;
7973 }
7974 ;
7975
7976 CharacterWithLength: character '(' Iconst ')' opt_charset
7977 {
7978 if (($5 != NULL) && (strcmp($5, "sql_text") != 0))
7979 {
7980 char *type;
7981
7982 type = palloc(strlen($1) + 1 + strlen($5) + 1);
7983 strcpy(type, $1);
7984 strcat(type, "_");
7985 strcat(type, $5);
7986 $1 = type;
7987 }
7988
7989 $$ = SystemTypeName($1);
7990 $$->typmods = list_make1(makeIntConst($3, @3));
7991 $$->location = @1;
7992 }
7993 ;
7994
7995 CharacterWithoutLength: character opt_charset
7996 {
7997 if (($2 != NULL) && (strcmp($2, "sql_text") != 0))
7998 {
7999 char *type;
8000
8001 type = palloc(strlen($1) + 1 + strlen($2) + 1);
8002 strcpy(type, $1);
8003 strcat(type, "_");
8004 strcat(type, $2);
8005 $1 = type;
8006 }
8007
8008 $$ = SystemTypeName($1);
8009
8010 /* char defaults to char(1), varchar to no limit */
8011 if (strcmp($1, "bpchar") == 0)
8012 $$->typmods = list_make1(makeIntConst(1, -1));
8013
8014 $$->location = @1;
8015 }
8016 ;
8017
8018 character: CHARACTER opt_varying
8019 { $$ = $2 ? "varchar": "bpchar"; }
8020 | CHAR_P opt_varying
8021 { $$ = $2 ? "varchar": "bpchar"; }
8022 | VARCHAR
8023 { $$ = "varchar"; }
8024 | NATIONAL CHARACTER opt_varying
8025 { $$ = $3 ? "varchar": "bpchar"; }
8026 | NATIONAL CHAR_P opt_varying
8027 { $$ = $3 ? "varchar": "bpchar"; }
8028 | NCHAR opt_varying
8029 { $$ = $2 ? "varchar": "bpchar"; }
8030 ;
8031
8032 opt_varying:
8033 VARYING { $$ = TRUE; }
8034 | /*EMPTY*/ { $$ = FALSE; }
8035 ;
8036
8037 opt_charset:
8038 CHARACTER SET ColId { $$ = $3; }
8039 | /*EMPTY*/ { $$ = NULL; }
8040 ;
8041
8042 /*
8043 * SQL92 date/time types
8044 */
8045 ConstDatetime:
8046 TIMESTAMP '(' Iconst ')' opt_timezone
8047 {
8048 if ($5)
8049 $$ = SystemTypeName("timestamptz");
8050 else
8051 $$ = SystemTypeName("timestamp");
8052 $$->typmods = list_make1(makeIntConst($3, @3));
8053 $$->location = @1;
8054 }
8055 | TIMESTAMP opt_timezone
8056 {
8057 if ($2)
8058 $$ = SystemTypeName("timestamptz");
8059 else
8060 $$ = SystemTypeName("timestamp");
8061 $$->location = @1;
8062 }
8063 | TIME '(' Iconst ')' opt_timezone
8064 {
8065 if ($5)
8066 $$ = SystemTypeName("timetz");
8067 else
8068 $$ = SystemTypeName("time");
8069 $$->typmods = list_make1(makeIntConst($3, @3));
8070 $$->location = @1;
8071 }
8072 | TIME opt_timezone
8073 {
8074 if ($2)
8075 $$ = SystemTypeName("timetz");
8076 else
8077 $$ = SystemTypeName("time");
8078 $$->location = @1;
8079 }
8080 ;
8081
8082 ConstInterval:
8083 INTERVAL
8084 {
8085 $$ = SystemTypeName("interval");
8086 $$->location = @1;
8087 }
8088 ;
8089
8090 opt_timezone:
8091 WITH_TIME ZONE { $$ = TRUE; }
8092 | WITHOUT TIME ZONE { $$ = FALSE; }
8093 | /*EMPTY*/ { $$ = FALSE; }
8094 ;
8095
8096 opt_interval:
8097 YEAR_P
8098 { $$ = list_make1(makeIntConst(INTERVAL_MASK(YEAR), @1)); }
8099 | MONTH_P
8100 { $$ = list_make1(makeIntConst(INTERVAL_MASK(MONTH), @1)); }
8101 | DAY_P
8102 { $$ = list_make1(makeIntConst(INTERVAL_MASK(DAY), @1)); }
8103 | HOUR_P
8104 { $$ = list_make1(makeIntConst(INTERVAL_MASK(HOUR), @1)); }
8105 | MINUTE_P
8106 { $$ = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), @1)); }
8107 | interval_second
8108 { $$ = $1; }
8109 | YEAR_P TO MONTH_P
8110 {
8111 $$ = list_make1(makeIntConst(INTERVAL_MASK(YEAR) |
8112 INTERVAL_MASK(MONTH), @1));
8113 }
8114 | DAY_P TO HOUR_P
8115 {
8116 $$ = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
8117 INTERVAL_MASK(HOUR), @1));
8118 }
8119 | DAY_P TO MINUTE_P
8120 {
8121 $$ = list_make1(makeIntConst(INTERVAL_MASK(DAY) |
8122 INTERVAL_MASK(HOUR) |
8123 INTERVAL_MASK(MINUTE), @1));
8124 }
8125 | DAY_P TO interval_second
8126 {
8127 $$ = $3;
8128 linitial($$) = makeIntConst(INTERVAL_MASK(DAY) |
8129 INTERVAL_MASK(HOUR) |
8130 INTERVAL_MASK(MINUTE) |
8131 INTERVAL_MASK(SECOND), @1);
8132 }
8133 | HOUR_P TO MINUTE_P
8134 {
8135 $$ = list_make1(makeIntConst(INTERVAL_MASK(HOUR) |
8136 INTERVAL_MASK(MINUTE), @1));
8137 }
8138 | HOUR_P TO interval_second
8139 {
8140 $$ = $3;
8141 linitial($$) = makeIntConst(INTERVAL_MASK(HOUR) |
8142 INTERVAL_MASK(MINUTE) |
8143 INTERVAL_MASK(SECOND), @1);
8144 }
8145 | MINUTE_P TO interval_second
8146 {
8147 $$ = $3;
8148 linitial($$) = makeIntConst(INTERVAL_MASK(MINUTE) |
8149 INTERVAL_MASK(SECOND), @1);
8150 }
8151 | /*EMPTY*/
8152 { $$ = NIL; }
8153 ;
8154
8155 interval_second:
8156 SECOND_P
8157 {
8158 $$ = list_make1(makeIntConst(INTERVAL_MASK(SECOND), @1));
8159 }
8160 | SECOND_P '(' Iconst ')'
8161 {
8162 $$ = list_make2(makeIntConst(INTERVAL_MASK(SECOND), @1),
8163 makeIntConst($3, @3));
8164 }
8165 ;
8166
8167
8168 /*****************************************************************************
8169 *
8170 * expression grammar
8171 *
8172 *****************************************************************************/
8173
8174 /*
8175 * General expressions
8176 * This is the heart of the expression syntax.
8177 *
8178 * We have two expression types: a_expr is the unrestricted kind, and
8179 * b_expr is a subset that must be used in some places to avoid shift/reduce
8180 * conflicts. For example, we can't do BETWEEN as "BETWEEN a_expr AND a_expr"
8181 * because that use of AND conflicts with AND as a boolean operator. So,
8182 * b_expr is used in BETWEEN and we remove boolean keywords from b_expr.
8183 *
8184 * Note that '(' a_expr ')' is a b_expr, so an unrestricted expression can
8185 * always be used by surrounding it with parens.
8186 *
8187 * c_expr is all the productions that are common to a_expr and b_expr;
8188 * it's factored out just to eliminate redundant coding.
8189 */
8190 a_expr: c_expr { $$ = $1; }
8191 | a_expr TYPECAST Typename
8192 { $$ = makeTypeCast($1, $3, @2); }
8193 | a_expr AT TIME ZONE a_expr
8194 {
8195 FuncCall *n = makeNode(FuncCall);
8196 n->funcname = SystemFuncName("timezone");
8197 n->args = list_make2($5, $1);
8198 n->agg_star = FALSE;
8199 n->agg_distinct = FALSE;
8200 n->func_variadic = FALSE;
8201 n->over = NULL;
8202 n->location = @2;
8203 $$ = (Node *) n;
8204 }
8205 /*
8206 * These operators must be called out explicitly in order to make use
8207 * of yacc/bison's automatic operator-precedence handling. All other
8208 * operator names are handled by the generic productions using "Op",
8209 * below; and all those operators will have the same precedence.
8210 *
8211 * If you add more explicitly-known operators, be sure to add them
8212 * also to b_expr and to the MathOp list above.
8213 */
8214 | '+' a_expr %prec UMINUS
8215 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2, @1); }
8216 | '-' a_expr %prec UMINUS
8217 { $$ = doNegate($2, @1); }
8218 | a_expr '+' a_expr
8219 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3, @2); }
8220 | a_expr '-' a_expr
8221 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3, @2); }
8222 | a_expr '*' a_expr
8223 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3, @2); }
8224 | a_expr '/' a_expr
8225 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3, @2); }
8226 | a_expr '%' a_expr
8227 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3, @2); }
8228 | a_expr '^' a_expr
8229 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3, @2); }
8230 | a_expr '<' a_expr
8231 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3, @2); }
8232 | a_expr '>' a_expr
8233 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3, @2); }
8234 | a_expr '=' a_expr
8235 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3, @2); }
8236
8237 | a_expr qual_Op a_expr %prec Op
8238 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3, @2); }
8239 | qual_Op a_expr %prec Op
8240 { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2, @1); }
8241 | a_expr qual_Op %prec POSTFIXOP
8242 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL, @2); }
8243
8244 | a_expr AND a_expr
8245 { $$ = (Node *) makeA_Expr(AEXPR_AND, NIL, $1, $3, @2); }
8246 | a_expr OR a_expr
8247 { $$ = (Node *) makeA_Expr(AEXPR_OR, NIL, $1, $3, @2); }
8248 | NOT a_expr
8249 { $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, $2, @1); }
8250
8251 | a_expr LIKE a_expr
8252 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, $3, @2); }
8253 | a_expr LIKE a_expr ESCAPE a_expr
8254 {
8255 FuncCall *n = makeNode(FuncCall);
8256 n->funcname = SystemFuncName("like_escape");
8257 n->args = list_make2($3, $5);
8258 n->agg_star = FALSE;
8259 n->agg_distinct = FALSE;
8260 n->func_variadic = FALSE;
8261 n->over = NULL;
8262 n->location = @4;
8263 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, (Node *) n, @2);
8264 }
8265 | a_expr NOT LIKE a_expr
8266 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, $4, @2); }
8267 | a_expr NOT LIKE a_expr ESCAPE a_expr
8268 {
8269 FuncCall *n = makeNode(FuncCall);
8270 n->funcname = SystemFuncName("like_escape");
8271 n->args = list_make2($4, $6);
8272 n->agg_star = FALSE;
8273 n->agg_distinct = FALSE;
8274 n->func_variadic = FALSE;
8275 n->over = NULL;
8276 n->location = @5;
8277 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, (Node *) n, @2);
8278 }
8279 | a_expr ILIKE a_expr
8280 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, $3, @2); }
8281 | a_expr ILIKE a_expr ESCAPE a_expr
8282 {
8283 FuncCall *n = makeNode(FuncCall);
8284 n->funcname = SystemFuncName("like_escape");
8285 n->args = list_make2($3, $5);
8286 n->agg_star = FALSE;
8287 n->agg_distinct = FALSE;
8288 n->func_variadic = FALSE;
8289 n->over = NULL;
8290 n->location = @4;
8291 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, (Node *) n, @2);
8292 }
8293 | a_expr NOT ILIKE a_expr
8294 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, $4, @2); }
8295 | a_expr NOT ILIKE a_expr ESCAPE a_expr
8296 {
8297 FuncCall *n = makeNode(FuncCall);
8298 n->funcname = SystemFuncName("like_escape");
8299 n->args = list_make2($4, $6);
8300 n->agg_star = FALSE;
8301 n->agg_distinct = FALSE;
8302 n->func_variadic = FALSE;
8303 n->over = NULL;
8304 n->location = @5;
8305 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, (Node *) n, @2);
8306 }
8307
8308 | a_expr SIMILAR TO a_expr %prec SIMILAR
8309 {
8310 FuncCall *n = makeNode(FuncCall);
8311 n->funcname = SystemFuncName("similar_escape");
8312 n->args = list_make2($4, makeNullAConst(-1));
8313 n->agg_star = FALSE;
8314 n->agg_distinct = FALSE;
8315 n->func_variadic = FALSE;
8316 n->over = NULL;
8317 n->location = @2;
8318 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n, @2);
8319 }
8320 | a_expr SIMILAR TO a_expr ESCAPE a_expr
8321 {
8322 FuncCall *n = makeNode(FuncCall);
8323 n->funcname = SystemFuncName("similar_escape");
8324 n->args = list_make2($4, $6);
8325 n->agg_star = FALSE;
8326 n->agg_distinct = FALSE;
8327 n->func_variadic = FALSE;
8328 n->over = NULL;
8329 n->location = @5;
8330 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n, @2);
8331 }
8332 | a_expr NOT SIMILAR TO a_expr %prec SIMILAR
8333 {
8334 FuncCall *n = makeNode(FuncCall);
8335 n->funcname = SystemFuncName("similar_escape");
8336 n->args = list_make2($5, makeNullAConst(-1));
8337 n->agg_star = FALSE;
8338 n->agg_distinct = FALSE;
8339 n->func_variadic = FALSE;
8340 n->over = NULL;
8341 n->location = @5;
8342 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n, @2);
8343 }
8344 | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
8345 {
8346 FuncCall *n = makeNode(FuncCall);
8347 n->funcname = SystemFuncName("similar_escape");
8348 n->args = list_make2($5, $7);
8349 n->agg_star = FALSE;
8350 n->agg_distinct = FALSE;
8351 n->func_variadic = FALSE;
8352 n->over = NULL;
8353 n->location = @6;
8354 $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n, @2);
8355 }
8356
8357 /* NullTest clause
8358 * Define SQL92-style Null test clause.
8359 * Allow two forms described in the standard:
8360 * a IS NULL
8361 * a IS NOT NULL
8362 * Allow two SQL extensions
8363 * a ISNULL
8364 * a NOTNULL
8365 */
8366 | a_expr IS NULL_P
8367 {
8368 NullTest *n = makeNode(NullTest);
8369 n->arg = (Expr *) $1;
8370 n->nulltesttype = IS_NULL;
8371 $$ = (Node *)n;
8372 }
8373 | a_expr ISNULL
8374 {
8375 NullTest *n = makeNode(NullTest);
8376 n->arg = (Expr *) $1;
8377 n->nulltesttype = IS_NULL;
8378 $$ = (Node *)n;
8379 }
8380 | a_expr IS NOT NULL_P
8381 {
8382 NullTest *n = makeNode(NullTest);
8383 n->arg = (Expr *) $1;
8384 n->nulltesttype = IS_NOT_NULL;
8385 $$ = (Node *)n;
8386 }
8387 | a_expr NOTNULL
8388 {
8389 NullTest *n = makeNode(NullTest);
8390 n->arg = (Expr *) $1;
8391 n->nulltesttype = IS_NOT_NULL;
8392 $$ = (Node *)n;
8393 }
8394 | row OVERLAPS row
8395 {
8396 $$ = (Node *)makeOverlaps($1, $3, @2);
8397 }
8398 | a_expr IS TRUE_P
8399 {
8400 BooleanTest *b = makeNode(BooleanTest);
8401 b->arg = (Expr *) $1;
8402 b->booltesttype = IS_TRUE;
8403 $$ = (Node *)b;
8404 }
8405 | a_expr IS NOT TRUE_P
8406 {
8407 BooleanTest *b = makeNode(BooleanTest);
8408 b->arg = (Expr *) $1;
8409 b->booltesttype = IS_NOT_TRUE;
8410 $$ = (Node *)b;
8411 }
8412 | a_expr IS FALSE_P
8413 {
8414 BooleanTest *b = makeNode(BooleanTest);
8415 b->arg = (Expr *) $1;
8416 b->booltesttype = IS_FALSE;
8417 $$ = (Node *)b;
8418 }
8419 | a_expr IS NOT FALSE_P
8420 {
8421 BooleanTest *b = makeNode(BooleanTest);
8422 b->arg = (Expr *) $1;
8423 b->booltesttype = IS_NOT_FALSE;
8424 $$ = (Node *)b;
8425 }
8426 | a_expr IS UNKNOWN
8427 {
8428 BooleanTest *b = makeNode(BooleanTest);
8429 b->arg = (Expr *) $1;
8430 b->booltesttype = IS_UNKNOWN;
8431 $$ = (Node *)b;
8432 }
8433 | a_expr IS NOT UNKNOWN
8434 {
8435 BooleanTest *b = makeNode(BooleanTest);
8436 b->arg = (Expr *) $1;
8437 b->booltesttype = IS_NOT_UNKNOWN;
8438 $$ = (Node *)b;
8439 }
8440 | a_expr IS DISTINCT FROM a_expr %prec IS
8441 {
8442 $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5, @2);
8443 }
8444 | a_expr IS NOT DISTINCT FROM a_expr %prec IS
8445 {
8446 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL,
8447 (Node *) makeSimpleA_Expr(AEXPR_DISTINCT,
8448 "=", $1, $6, @2),
8449 @2);
8450
8451 }
8452 | a_expr IS OF '(' type_list ')' %prec IS
8453 {
8454 $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5, @2);
8455 }
8456 | a_expr IS NOT OF '(' type_list ')' %prec IS
8457 {
8458 $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "<>", $1, (Node *) $6, @2);
8459 }
8460 /*
8461 * Ideally we would not use hard-wired operators below but instead use
8462 * opclasses. However, mixed data types and other issues make this
8463 * difficult: http://archives.postgresql.org/pgsql-hackers/2008-08/msg01142.php
8464 */
8465 | a_expr BETWEEN opt_asymmetric b_expr AND b_expr %prec BETWEEN
8466 {
8467 $$ = (Node *) makeA_Expr(AEXPR_AND, NIL,
8468 (Node *) makeSimpleA_Expr(AEXPR_OP, ">=", $1, $4, @2),
8469 (Node *) makeSimpleA_Expr(AEXPR_OP, "<=", $1, $6, @2),
8470 @2);
8471 }
8472 | a_expr NOT BETWEEN opt_asymmetric b_expr AND b_expr %prec BETWEEN
8473 {
8474 $$ = (Node *) makeA_Expr(AEXPR_OR, NIL,
8475 (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $5, @2),
8476 (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $7, @2),
8477 @2);
8478 }
8479 | a_expr BETWEEN SYMMETRIC b_expr AND b_expr %prec BETWEEN
8480 {
8481 $$ = (Node *) makeA_Expr(AEXPR_OR, NIL,
8482 (Node *) makeA_Expr(AEXPR_AND, NIL,
8483 (Node *) makeSimpleA_Expr(AEXPR_OP, ">=", $1, $4, @2),
8484 (Node *) makeSimpleA_Expr(AEXPR_OP, "<=", $1, $6, @2),
8485 @2),
8486 (Node *) makeA_Expr(AEXPR_AND, NIL,
8487 (Node *) makeSimpleA_Expr(AEXPR_OP, ">=", $1, $6, @2),
8488 (Node *) makeSimpleA_Expr(AEXPR_OP, "<=", $1, $4, @2),
8489 @2),
8490 @2);
8491 }
8492 | a_expr NOT BETWEEN SYMMETRIC b_expr AND b_expr %prec BETWEEN
8493 {
8494 $$ = (Node *) makeA_Expr(AEXPR_AND, NIL,
8495 (Node *) makeA_Expr(AEXPR_OR, NIL,
8496 (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $5, @2),
8497 (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $7, @2),
8498 @2),
8499 (Node *) makeA_Expr(AEXPR_OR, NIL,
8500 (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $7, @2),
8501 (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $5, @2),
8502 @2),
8503 @2);
8504 }
8505 | a_expr IN_P in_expr
8506 {
8507 /* in_expr returns a SubLink or a list of a_exprs */
8508 if (IsA($3, SubLink))
8509 {
8510 /* generate foo = ANY (subquery) */
8511 SubLink *n = (SubLink *) $3;
8512 n->subLinkType = ANY_SUBLINK;
8513 n->testexpr = $1;
8514 n->operName = list_make1(makeString("="));
8515 n->location = @2;
8516 $$ = (Node *)n;
8517 }
8518 else
8519 {
8520 /* generate scalar IN expression */
8521 $$ = (Node *) makeSimpleA_Expr(AEXPR_IN, "=", $1, $3, @2);
8522 }
8523 }
8524 | a_expr NOT IN_P in_expr
8525 {
8526 /* in_expr returns a SubLink or a list of a_exprs */
8527 if (IsA($4, SubLink))
8528 {
8529 /* generate NOT (foo = ANY (subquery)) */
8530 /* Make an = ANY node */
8531 SubLink *n = (SubLink *) $4;
8532 n->subLinkType = ANY_SUBLINK;
8533 n->testexpr = $1;
8534 n->operName = list_make1(makeString("="));
8535 n->location = @3;
8536 /* Stick a NOT on top */
8537 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (Node *) n, @2);
8538 }
8539 else
8540 {
8541 /* generate scalar NOT IN expression */
8542 $$ = (Node *) makeSimpleA_Expr(AEXPR_IN, "<>", $1, $4, @2);
8543 }
8544 }
8545 | a_expr subquery_Op sub_type select_with_parens %prec Op
8546 {
8547 SubLink *n = makeNode(SubLink);
8548 n->subLinkType = $3;
8549 n->testexpr = $1;
8550 n->operName = $2;
8551 n->subselect = $4;
8552 n->location = @2;
8553 $$ = (Node *)n;
8554 }
8555 | a_expr subquery_Op sub_type '(' a_expr ')' %prec Op
8556 {
8557 if ($3 == ANY_SUBLINK)
8558 $$ = (Node *) makeA_Expr(AEXPR_OP_ANY, $2, $1, $5, @2);
8559 else
8560 $$ = (Node *) makeA_Expr(AEXPR_OP_ALL, $2, $1, $5, @2);
8561 }
8562 | UNIQUE select_with_parens
8563 {
8564 /* Not sure how to get rid of the parentheses
8565 * but there are lots of shift/reduce errors without them.
8566 *
8567 * Should be able to implement this by plopping the entire
8568 * select into a node, then transforming the target expressions
8569 * from whatever they are into count(*), and testing the
8570 * entire result equal to one.
8571 * But, will probably implement a separate node in the executor.
8572 */
8573 ereport(ERROR,
8574 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
8575 errmsg("UNIQUE predicate is not yet implemented"),
8576 scanner_errposition(@1)));
8577 }
8578 | a_expr IS DOCUMENT_P %prec IS
8579 {
8580 $$ = makeXmlExpr(IS_DOCUMENT, NULL, NIL,
8581 list_make1($1), @2);
8582 }
8583 | a_expr IS NOT DOCUMENT_P %prec IS
8584 {
8585 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL,
8586 makeXmlExpr(IS_DOCUMENT, NULL, NIL,
8587 list_make1($1), @2),
8588 @2);
8589 }
8590 ;
8591
8592 /*
8593 * Restricted expressions
8594 *
8595 * b_expr is a subset of the complete expression syntax defined by a_expr.
8596 *
8597 * Presently, AND, NOT, IS, and IN are the a_expr keywords that would
8598 * cause trouble in the places where b_expr is used. For simplicity, we
8599 * just eliminate all the boolean-keyword-operator productions from b_expr.
8600 */
8601 b_expr: c_expr
8602 { $$ = $1; }
8603 | b_expr TYPECAST Typename
8604 { $$ = makeTypeCast($1, $3, @2); }
8605 | '+' b_expr %prec UMINUS
8606 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2, @1); }
8607 | '-' b_expr %prec UMINUS
8608 { $$ = doNegate($2, @1); }
8609 | b_expr '+' b_expr
8610 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3, @2); }
8611 | b_expr '-' b_expr
8612 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3, @2); }
8613 | b_expr '*' b_expr
8614 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3, @2); }
8615 | b_expr '/' b_expr
8616 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3, @2); }
8617 | b_expr '%' b_expr
8618 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3, @2); }
8619 | b_expr '^' b_expr
8620 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3, @2); }
8621 | b_expr '<' b_expr
8622 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3, @2); }
8623 | b_expr '>' b_expr
8624 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3, @2); }
8625 | b_expr '=' b_expr
8626 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3, @2); }
8627 | b_expr qual_Op b_expr %prec Op
8628 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3, @2); }
8629 | qual_Op b_expr %prec Op
8630 { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2, @1); }
8631 | b_expr qual_Op %prec POSTFIXOP
8632 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL, @2); }
8633 | b_expr IS DISTINCT FROM b_expr %prec IS
8634 {
8635 $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5, @2);
8636 }
8637 | b_expr IS NOT DISTINCT FROM b_expr %prec IS
8638 {
8639 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL,
8640 NULL, (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $6, @2), @2);
8641 }
8642 | b_expr IS OF '(' type_list ')' %prec IS
8643 {
8644 $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5, @2);
8645 }
8646 | b_expr IS NOT OF '(' type_list ')' %prec IS
8647 {
8648 $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "<>", $1, (Node *) $6, @2);
8649 }
8650 | b_expr IS DOCUMENT_P %prec IS
8651 {
8652 $$ = makeXmlExpr(IS_DOCUMENT, NULL, NIL,
8653 list_make1($1), @2);
8654 }
8655 | b_expr IS NOT DOCUMENT_P %prec IS
8656 {
8657 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL,
8658 makeXmlExpr(IS_DOCUMENT, NULL, NIL,
8659 list_make1($1), @2),
8660 @2);
8661 }
8662 ;
8663
8664 /*
8665 * Productions that can be used in both a_expr and b_expr.
8666 *
8667 * Note: productions that refer recursively to a_expr or b_expr mostly
8668 * cannot appear here. However, it's OK to refer to a_exprs that occur
8669 * inside parentheses, such as function arguments; that cannot introduce
8670 * ambiguity to the b_expr syntax.
8671 */
8672 c_expr: columnref { $$ = $1; }
8673 | AexprConst { $$ = $1; }
8674 | PARAM opt_indirection
8675 {
8676 ParamRef *p = makeNode(ParamRef);
8677 p->number = $1;
8678 p->location = @1;
8679 if ($2)
8680 {
8681 A_Indirection *n = makeNode(A_Indirection);
8682 n->arg = (Node *) p;
8683 n->indirection = check_indirection($2);
8684 $$ = (Node *) n;
8685 }
8686 else
8687 $$ = (Node *) p;
8688 }
8689 | '(' a_expr ')' opt_indirection
8690 {
8691 if ($4)
8692 {
8693 A_Indirection *n = makeNode(A_Indirection);
8694 n->arg = $2;
8695 n->indirection = check_indirection($4);
8696 $$ = (Node *)n;
8697 }
8698 else
8699 $$ = $2;
8700 }
8701 | case_expr
8702 { $$ = $1; }
8703 | func_expr
8704 { $$ = $1; }
8705 | select_with_parens %prec UMINUS
8706 {
8707 SubLink *n = makeNode(SubLink);
8708 n->subLinkType = EXPR_SUBLINK;
8709 n->testexpr = NULL;
8710 n->operName = NIL;
8711 n->subselect = $1;
8712 n->location = @1;
8713 $$ = (Node *)n;
8714 }
8715 | EXISTS select_with_parens
8716 {
8717 SubLink *n = makeNode(SubLink);
8718 n->subLinkType = EXISTS_SUBLINK;
8719 n->testexpr = NULL;
8720 n->operName = NIL;
8721 n->subselect = $2;
8722 n->location = @1;
8723 $$ = (Node *)n;
8724 }
8725 | ARRAY select_with_parens
8726 {
8727 SubLink *n = makeNode(SubLink);
8728 n->subLinkType = ARRAY_SUBLINK;
8729 n->testexpr = NULL;
8730 n->operName = NIL;
8731 n->subselect = $2;
8732 n->location = @1;
8733 $$ = (Node *)n;
8734 }
8735 | ARRAY array_expr
8736 {
8737 A_ArrayExpr *n = (A_ArrayExpr *) $2;
8738 Assert(IsA(n, A_ArrayExpr));
8739 /* point outermost A_ArrayExpr to the ARRAY keyword */
8740 n->location = @1;
8741 $$ = (Node *)n;
8742 }
8743 | row
8744 {
8745 RowExpr *r = makeNode(RowExpr);
8746 r->args = $1;
8747 r->row_typeid = InvalidOid; /* not analyzed yet */
8748 r->location = @1;
8749 $$ = (Node *)r;
8750 }
8751 ;
8752
8753 /*
8754 * func_expr is split out from c_expr just so that we have a classification
8755 * for "everything that is a function call or looks like one". This isn't
8756 * very important, but it saves us having to document which variants are
8757 * legal in the backwards-compatible functional-index syntax for CREATE INDEX.
8758 * (Note that many of the special SQL functions wouldn't actually make any
8759 * sense as functional index entries, but we ignore that consideration here.)
8760 */
8761 func_expr: func_name '(' ')' over_clause
8762 {
8763 FuncCall *n = makeNode(FuncCall);
8764 n->funcname = $1;
8765 n->args = NIL;
8766 n->agg_star = FALSE;
8767 n->agg_distinct = FALSE;
8768 n->func_variadic = FALSE;
8769 n->over = $4;
8770 n->location = @1;
8771 $$ = (Node *)n;
8772 }
8773 | func_name '(' expr_list ')' over_clause
8774 {
8775 FuncCall *n = makeNode(FuncCall);
8776 n->funcname = $1;
8777 n->args = $3;
8778 n->agg_star = FALSE;
8779 n->agg_distinct = FALSE;
8780 n->func_variadic = FALSE;
8781 n->over = $5;
8782 n->location = @1;
8783 $$ = (Node *)n;
8784 }
8785 | func_name '(' VARIADIC a_expr ')' over_clause
8786 {
8787 FuncCall *n = makeNode(FuncCall);
8788 n->funcname = $1;
8789 n->args = list_make1($4);
8790 n->agg_star = FALSE;
8791 n->agg_distinct = FALSE;
8792 n->func_variadic = TRUE;
8793 n->over = $6;
8794 n->location = @1;
8795 $$ = (Node *)n;
8796 }
8797 | func_name '(' expr_list ',' VARIADIC a_expr ')' over_clause
8798 {
8799 FuncCall *n = makeNode(FuncCall);
8800 n->funcname = $1;
8801 n->args = lappend($3, $6);
8802 n->agg_star = FALSE;
8803 n->agg_distinct = FALSE;
8804 n->func_variadic = TRUE;
8805 n->over = $8;
8806 n->location = @1;
8807 $$ = (Node *)n;
8808 }
8809 | func_name '(' ALL expr_list ')' over_clause
8810 {
8811 FuncCall *n = makeNode(FuncCall);
8812 n->funcname = $1;
8813 n->args = $4;
8814 n->agg_star = FALSE;
8815 n->agg_distinct = FALSE;
8816 /* Ideally we'd mark the FuncCall node to indicate
8817 * "must be an aggregate", but there's no provision
8818 * for that in FuncCall at the moment.
8819 */
8820 n->func_variadic = FALSE;
8821 n->over = $6;
8822 n->location = @1;
8823 $$ = (Node *)n;
8824 }
8825 | func_name '(' DISTINCT expr_list ')' over_clause
8826 {
8827 FuncCall *n = makeNode(FuncCall);
8828 n->funcname = $1;
8829 n->args = $4;
8830 n->agg_star = FALSE;
8831 n->agg_distinct = TRUE;
8832 n->func_variadic = FALSE;
8833 n->over = $6;
8834 n->location = @1;
8835 $$ = (Node *)n;
8836 }
8837 | func_name '(' '*' ')' over_clause
8838 {
8839 /*
8840 * We consider AGGREGATE(*) to invoke a parameterless
8841 * aggregate. This does the right thing for COUNT(*),
8842 * and there are no other aggregates in SQL92 that accept
8843 * '*' as parameter.
8844 *
8845 * The FuncCall node is also marked agg_star = true,
8846 * so that later processing can detect what the argument
8847 * really was.
8848 */
8849 FuncCall *n = makeNode(FuncCall);
8850 n->funcname = $1;
8851 n->args = NIL;
8852 n->agg_star = TRUE;
8853 n->agg_distinct = FALSE;
8854 n->func_variadic = FALSE;
8855 n->over = $5;
8856 n->location = @1;
8857 $$ = (Node *)n;
8858 }
8859 | CURRENT_DATE
8860 {
8861 /*
8862 * Translate as "'now'::text::date".
8863 *
8864 * We cannot use "'now'::date" because coerce_type() will
8865 * immediately reduce that to a constant representing
8866 * today's date. We need to delay the conversion until
8867 * runtime, else the wrong things will happen when
8868 * CURRENT_DATE is used in a column default value or rule.
8869 *
8870 * This could be simplified if we had a way to generate
8871 * an expression tree representing runtime application
8872 * of type-input conversion functions. (As of PG 7.3
8873 * that is actually possible, but not clear that we want
8874 * to rely on it.)
8875 */
8876 Node *n;
8877 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8878 $$ = makeTypeCast(n, SystemTypeName("date"), -1);
8879 }
8880 | CURRENT_TIME
8881 {
8882 /*
8883 * Translate as "'now'::text::timetz".
8884 * See comments for CURRENT_DATE.
8885 */
8886 Node *n;
8887 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8888 $$ = makeTypeCast(n, SystemTypeName("timetz"), -1);
8889 }
8890 | CURRENT_TIME '(' Iconst ')'
8891 {
8892 /*
8893 * Translate as "'now'::text::timetz(n)".
8894 * See comments for CURRENT_DATE.
8895 */
8896 Node *n;
8897 TypeName *d;
8898 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8899 d = SystemTypeName("timetz");
8900 d->typmods = list_make1(makeIntConst($3, @3));
8901 $$ = makeTypeCast(n, d, -1);
8902 }
8903 | CURRENT_TIMESTAMP
8904 {
8905 /*
8906 * Translate as "now()", since we have a function that
8907 * does exactly what is needed.
8908 */
8909 FuncCall *n = makeNode(FuncCall);
8910 n->funcname = SystemFuncName("now");
8911 n->args = NIL;
8912 n->agg_star = FALSE;
8913 n->agg_distinct = FALSE;
8914 n->func_variadic = FALSE;
8915 n->over = NULL;
8916 n->location = @1;
8917 $$ = (Node *)n;
8918 }
8919 | CURRENT_TIMESTAMP '(' Iconst ')'
8920 {
8921 /*
8922 * Translate as "'now'::text::timestamptz(n)".
8923 * See comments for CURRENT_DATE.
8924 */
8925 Node *n;
8926 TypeName *d;
8927 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8928 d = SystemTypeName("timestamptz");
8929 d->typmods = list_make1(makeIntConst($3, @3));
8930 $$ = makeTypeCast(n, d, -1);
8931 }
8932 | LOCALTIME
8933 {
8934 /*
8935 * Translate as "'now'::text::time".
8936 * See comments for CURRENT_DATE.
8937 */
8938 Node *n;
8939 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8940 $$ = makeTypeCast((Node *)n, SystemTypeName("time"), -1);
8941 }
8942 | LOCALTIME '(' Iconst ')'
8943 {
8944 /*
8945 * Translate as "'now'::text::time(n)".
8946 * See comments for CURRENT_DATE.
8947 */
8948 Node *n;
8949 TypeName *d;
8950 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8951 d = SystemTypeName("time");
8952 d->typmods = list_make1(makeIntConst($3, @3));
8953 $$ = makeTypeCast((Node *)n, d, -1);
8954 }
8955 | LOCALTIMESTAMP
8956 {
8957 /*
8958 * Translate as "'now'::text::timestamp".
8959 * See comments for CURRENT_DATE.
8960 */
8961 Node *n;
8962 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8963 $$ = makeTypeCast(n, SystemTypeName("timestamp"), -1);
8964 }
8965 | LOCALTIMESTAMP '(' Iconst ')'
8966 {
8967 /*
8968 * Translate as "'now'::text::timestamp(n)".
8969 * See comments for CURRENT_DATE.
8970 */
8971 Node *n;
8972 TypeName *d;
8973 n = makeStringConstCast("now", @1, SystemTypeName("text"));
8974 d = SystemTypeName("timestamp");
8975 d->typmods = list_make1(makeIntConst($3, @3));
8976 $$ = makeTypeCast(n, d, -1);
8977 }
8978 | CURRENT_ROLE
8979 {
8980 FuncCall *n = makeNode(FuncCall);
8981 n->funcname = SystemFuncName("current_user");
8982 n->args = NIL;
8983 n->agg_star = FALSE;
8984 n->agg_distinct = FALSE;
8985 n->func_variadic = FALSE;
8986 n->over = NULL;
8987 n->location = @1;
8988 $$ = (Node *)n;
8989 }
8990 | CURRENT_USER
8991 {
8992 FuncCall *n = makeNode(FuncCall);
8993 n->funcname = SystemFuncName("current_user");
8994 n->args = NIL;
8995 n->agg_star = FALSE;
8996 n->agg_distinct = FALSE;
8997 n->func_variadic = FALSE;
8998 n->over = NULL;
8999 n->location = @1;
9000 $$ = (Node *)n;
9001 }
9002 | SESSION_USER
9003 {
9004 FuncCall *n = makeNode(FuncCall);
9005 n->funcname = SystemFuncName("session_user");
9006 n->args = NIL;
9007 n->agg_star = FALSE;
9008 n->agg_distinct = FALSE;
9009 n->func_variadic = FALSE;
9010 n->over = NULL;
9011 n->location = @1;
9012 $$ = (Node *)n;
9013 }
9014 | USER
9015 {
9016 FuncCall *n = makeNode(FuncCall);
9017 n->funcname = SystemFuncName("current_user");
9018 n->args = NIL;
9019 n->agg_star = FALSE;
9020 n->agg_distinct = FALSE;
9021 n->func_variadic = FALSE;
9022 n->over = NULL;
9023 n->location = @1;
9024 $$ = (Node *)n;
9025 }
9026 | CURRENT_CATALOG
9027 {
9028 FuncCall *n = makeNode(FuncCall);
9029 n->funcname = SystemFuncName("current_database");
9030 n->args = NIL;
9031 n->agg_star = FALSE;
9032 n->agg_distinct = FALSE;
9033 n->func_variadic = FALSE;
9034 n->over = NULL;
9035 n->location = @1;
9036 $$ = (Node *)n;
9037 }
9038 | CURRENT_SCHEMA
9039 {
9040 FuncCall *n = makeNode(FuncCall);
9041 n->funcname = SystemFuncName("current_schema");
9042 n->args = NIL;
9043 n->agg_star = FALSE;
9044 n->agg_distinct = FALSE;
9045 n->func_variadic = FALSE;
9046 n->over = NULL;
9047 n->location = @1;
9048 $$ = (Node *)n;
9049 }
9050 | CAST '(' a_expr AS Typename ')'
9051 { $$ = makeTypeCast($3, $5, @1); }
9052 | EXTRACT '(' extract_list ')'
9053 {
9054 FuncCall *n = makeNode(FuncCall);
9055 n->funcname = SystemFuncName("date_part");
9056 n->args = $3;
9057 n->agg_star = FALSE;
9058 n->agg_distinct = FALSE;
9059 n->func_variadic = FALSE;
9060 n->over = NULL;
9061 n->location = @1;
9062 $$ = (Node *)n;
9063 }
9064 | OVERLAY '(' overlay_list ')'
9065 {
9066 /* overlay(A PLACING B FROM C FOR D) is converted to
9067 * substring(A, 1, C-1) || B || substring(A, C+1, C+D)
9068 * overlay(A PLACING B FROM C) is converted to
9069 * substring(A, 1, C-1) || B || substring(A, C+1, C+char_length(B))
9070 */
9071 FuncCall *n = makeNode(FuncCall);
9072 n->funcname = SystemFuncName("overlay");
9073 n->args = $3;
9074 n->agg_star = FALSE;
9075 n->agg_distinct = FALSE;
9076 n->func_variadic = FALSE;
9077 n->over = NULL;
9078 n->location = @1;
9079 $$ = (Node *)n;
9080 }
9081 | POSITION '(' position_list ')'
9082 {
9083 /* position(A in B) is converted to position(B, A) */
9084 FuncCall *n = makeNode(FuncCall);
9085 n->funcname = SystemFuncName("position");
9086 n->args = $3;
9087 n->agg_star = FALSE;
9088 n->agg_distinct = FALSE;
9089 n->func_variadic = FALSE;
9090 n->over = NULL;
9091 n->location = @1;
9092 $$ = (Node *)n;
9093 }
9094 | SUBSTRING '(' substr_list ')'
9095 {
9096 /* substring(A from B for C) is converted to
9097 * substring(A, B, C) - thomas 2000-11-28
9098 */
9099 FuncCall *n = makeNode(FuncCall);
9100 n->funcname = SystemFuncName("substring");
9101 n->args = $3;
9102 n->agg_star = FALSE;
9103 n->agg_distinct = FALSE;
9104 n->func_variadic = FALSE;
9105 n->over = NULL;
9106 n->location = @1;
9107 $$ = (Node *)n;
9108 }
9109 | TREAT '(' a_expr AS Typename ')'
9110 {
9111 /* TREAT(expr AS target) converts expr of a particular type to target,
9112 * which is defined to be a subtype of the original expression.
9113 * In SQL99, this is intended for use with structured UDTs,
9114 * but let's make this a generally useful form allowing stronger
9115 * coercions than are handled by implicit casting.
9116 */
9117 FuncCall *n = makeNode(FuncCall);
9118 /* Convert SystemTypeName() to SystemFuncName() even though
9119 * at the moment they result in the same thing.
9120 */
9121 n->funcname = SystemFuncName(((Value *)llast($5->names))->val.str);
9122 n->args = list_make1($3);
9123 n->agg_star = FALSE;
9124 n->agg_distinct = FALSE;
9125 n->func_variadic = FALSE;
9126 n->over = NULL;
9127 n->location = @1;
9128 $$ = (Node *)n;
9129 }
9130 | TRIM '(' BOTH trim_list ')'
9131 {
9132 /* various trim expressions are defined in SQL92
9133 * - thomas 1997-07-19
9134 */
9135 FuncCall *n = makeNode(FuncCall);
9136 n->funcname = SystemFuncName("btrim");
9137 n->args = $4;
9138 n->agg_star = FALSE;
9139 n->agg_distinct = FALSE;
9140 n->func_variadic = FALSE;
9141 n->over = NULL;
9142 n->location = @1;
9143 $$ = (Node *)n;
9144 }
9145 | TRIM '(' LEADING trim_list ')'
9146 {
9147 FuncCall *n = makeNode(FuncCall);
9148 n->funcname = SystemFuncName("ltrim");
9149 n->args = $4;
9150 n->agg_star = FALSE;
9151 n->agg_distinct = FALSE;
9152 n->func_variadic = FALSE;
9153 n->over = NULL;
9154 n->location = @1;
9155 $$ = (Node *)n;
9156 }
9157 | TRIM '(' TRAILING trim_list ')'
9158 {
9159 FuncCall *n = makeNode(FuncCall);
9160 n->funcname = SystemFuncName("rtrim");
9161 n->args = $4;
9162 n->agg_star = FALSE;
9163 n->agg_distinct = FALSE;
9164 n->func_variadic = FALSE;
9165 n->over = NULL;
9166 n->location = @1;
9167 $$ = (Node *)n;
9168 }
9169 | TRIM '(' trim_list ')'
9170 {
9171 FuncCall *n = makeNode(FuncCall);
9172 n->funcname = SystemFuncName("btrim");
9173 n->args = $3;
9174 n->agg_star = FALSE;
9175 n->agg_distinct = FALSE;
9176 n->func_variadic = FALSE;
9177 n->over = NULL;
9178 n->location = @1;
9179 $$ = (Node *)n;
9180 }
9181 | NULLIF '(' a_expr ',' a_expr ')'
9182 {
9183 $$ = (Node *) makeSimpleA_Expr(AEXPR_NULLIF, "=", $3, $5, @1);
9184 }
9185 | COALESCE '(' expr_list ')'
9186 {
9187 CoalesceExpr *c = makeNode(CoalesceExpr);
9188 c->args = $3;
9189 c->location = @1;
9190 $$ = (Node *)c;
9191 }
9192 | GREATEST '(' expr_list ')'
9193 {
9194 MinMaxExpr *v = makeNode(MinMaxExpr);
9195 v->args = $3;
9196 v->op = IS_GREATEST;
9197 v->location = @1;
9198 $$ = (Node *)v;
9199 }
9200 | LEAST '(' expr_list ')'
9201 {
9202 MinMaxExpr *v = makeNode(MinMaxExpr);
9203 v->args = $3;
9204 v->op = IS_LEAST;
9205 v->location = @1;
9206 $$ = (Node *)v;
9207 }
9208 | XMLCONCAT '(' expr_list ')'
9209 {
9210 $$ = makeXmlExpr(IS_XMLCONCAT, NULL, NIL, $3, @1);
9211 }
9212 | XMLELEMENT '(' NAME_P ColLabel ')'
9213 {
9214 $$ = makeXmlExpr(IS_XMLELEMENT, $4, NIL, NIL, @1);
9215 }
9216 | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ')'
9217 {
9218 $$ = makeXmlExpr(IS_XMLELEMENT, $4, $6, NIL, @1);
9219 }
9220 | XMLELEMENT '(' NAME_P ColLabel ',' expr_list ')'
9221 {
9222 $$ = makeXmlExpr(IS_XMLELEMENT, $4, NIL, $6, @1);
9223 }
9224 | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
9225 {
9226 $$ = makeXmlExpr(IS_XMLELEMENT, $4, $6, $8, @1);
9227 }
9228 | XMLFOREST '(' xml_attribute_list ')'
9229 {
9230 $$ = makeXmlExpr(IS_XMLFOREST, NULL, $3, NIL, @1);
9231 }
9232 | XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
9233 {
9234 XmlExpr *x = (XmlExpr *)
9235 makeXmlExpr(IS_XMLPARSE, NULL, NIL,
9236 list_make2($4, makeBoolAConst($5, -1)),
9237 @1);
9238 x->xmloption = $3;
9239 $$ = (Node *)x;
9240 }
9241 | XMLPI '(' NAME_P ColLabel ')'
9242 {
9243 $$ = makeXmlExpr(IS_XMLPI, $4, NULL, NIL, @1);
9244 }
9245 | XMLPI '(' NAME_P ColLabel ',' a_expr ')'
9246 {
9247 $$ = makeXmlExpr(IS_XMLPI, $4, NULL, list_make1($6), @1);
9248 }
9249 | XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
9250 {
9251 $$ = makeXmlExpr(IS_XMLROOT, NULL, NIL,
9252 list_make3($3, $5, $6), @1);
9253 }
9254 | XMLSERIALIZE '(' document_or_content a_expr AS SimpleTypename ')'
9255 {
9256 XmlSerialize *n = makeNode(XmlSerialize);
9257 n->xmloption = $3;
9258 n->expr = $4;
9259 n->typename = $6;
9260 n->location = @1;
9261 $$ = (Node *)n;
9262 }
9263 ;
9264
9265 /*
9266 * SQL/XML support
9267 */
9268 xml_root_version: VERSION_P a_expr
9269 { $$ = $2; }
9270 | VERSION_P NO VALUE_P
9271 { $$ = makeNullAConst(-1); }
9272 ;
9273
9274 opt_xml_root_standalone: ',' STANDALONE_P YES_P
9275 { $$ = makeIntConst(XML_STANDALONE_YES, -1); }
9276 | ',' STANDALONE_P NO
9277 { $$ = makeIntConst(XML_STANDALONE_NO, -1); }
9278 | ',' STANDALONE_P NO VALUE_P
9279 { $$ = makeIntConst(XML_STANDALONE_NO_VALUE, -1); }
9280 | /*EMPTY*/
9281 { $$ = makeIntConst(XML_STANDALONE_OMITTED, -1); }
9282 ;
9283
9284 xml_attributes: XMLATTRIBUTES '(' xml_attribute_list ')' { $$ = $3; }
9285 ;
9286
9287 xml_attribute_list: xml_attribute_el { $$ = list_make1($1); }
9288 | xml_attribute_list ',' xml_attribute_el { $$ = lappend($1, $3); }
9289 ;
9290
9291 xml_attribute_el: a_expr AS ColLabel
9292 {
9293 $$ = makeNode(ResTarget);
9294 $$->name = $3;
9295 $$->indirection = NIL;
9296 $$->val = (Node *) $1;
9297 $$->location = @1;
9298 }
9299 | a_expr
9300 {
9301 $$ = makeNode(ResTarget);
9302 $$->name = NULL;
9303 $$->indirection = NIL;
9304 $$->val = (Node *) $1;
9305 $$->location = @1;
9306 }
9307 ;
9308
9309 document_or_content: DOCUMENT_P { $$ = XMLOPTION_DOCUMENT; }
9310 | CONTENT_P { $$ = XMLOPTION_CONTENT; }
9311 ;
9312
9313 xml_whitespace_option: PRESERVE WHITESPACE_P { $$ = TRUE; }
9314 | STRIP_P WHITESPACE_P { $$ = FALSE; }
9315 | /*EMPTY*/ { $$ = FALSE; }
9316 ;
9317
9318 /*
9319 * Window Definitions
9320 */
9321 window_clause:
9322 WINDOW window_definition_list { $$ = $2; }
9323 | /*EMPTY*/ { $$ = NIL; }
9324 ;
9325
9326 window_definition_list:
9327 window_definition { $$ = list_make1($1); }
9328 | window_definition_list ',' window_definition
9329 { $$ = lappend($1, $3); }
9330 ;
9331
9332 window_definition:
9333 ColId AS window_specification
9334 {
9335 WindowDef *n = $3;
9336 n->name = $1;
9337 $$ = n;
9338 }
9339 ;
9340
9341 over_clause: OVER window_specification
9342 { $$ = $2; }
9343 | OVER ColId
9344 {
9345 WindowDef *n = makeNode(WindowDef);
9346 n->name = $2;
9347 n->refname = NULL;
9348 n->partitionClause = NIL;
9349 n->orderClause = NIL;
9350 n->frameOptions = FRAMEOPTION_DEFAULTS;
9351 n->location = @2;
9352 $$ = n;
9353 }
9354 | /*EMPTY*/
9355 { $$ = NULL; }
9356 ;
9357
9358 window_specification: '(' opt_existing_window_name opt_partition_clause
9359 opt_sort_clause opt_frame_clause ')'
9360 {
9361 WindowDef *n = makeNode(WindowDef);
9362 n->name = NULL;
9363 n->refname = $2;
9364 n->partitionClause = $3;
9365 n->orderClause = $4;
9366 n->frameOptions = $5;
9367 n->location = @1;
9368 $$ = n;
9369 }
9370 ;
9371
9372 /*
9373 * If we see PARTITION, RANGE, or ROWS as the first token after the '('
9374 * of a window_specification, we want the assumption to be that there is
9375 * no existing_window_name; but those keywords are unreserved and so could
9376 * be ColIds. We fix this by making them have the same precedence as IDENT
9377 * and giving the empty production here a slightly higher precedence, so
9378 * that the shift/reduce conflict is resolved in favor of reducing the rule.
9379 * These keywords are thus precluded from being an existing_window_name but
9380 * are not reserved for any other purpose.
9381 */
9382 opt_existing_window_name: ColId { $$ = $1; }
9383 | /*EMPTY*/ %prec Op { $$ = NULL; }
9384 ;
9385
9386 opt_partition_clause: PARTITION BY expr_list { $$ = $3; }
9387 | /*EMPTY*/ { $$ = NIL; }
9388 ;
9389
9390 /*
9391 * This is only a subset of the full SQL:2008 frame_clause grammar.
9392 * We don't support <expression> PRECEDING, <expression> FOLLOWING,
9393 * nor <window frame exclusion> yet.
9394 */
9395 opt_frame_clause:
9396 RANGE frame_extent
9397 {
9398 $$ = FRAMEOPTION_NONDEFAULT | FRAMEOPTION_RANGE | $2;
9399 }
9400 | ROWS frame_extent
9401 {
9402 $$ = FRAMEOPTION_NONDEFAULT | FRAMEOPTION_ROWS | $2;
9403 }
9404 | /*EMPTY*/
9405 { $$ = FRAMEOPTION_DEFAULTS; }
9406 ;
9407
9408 frame_extent: frame_bound
9409 {
9410 /* reject invalid cases */
9411 if ($1 & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
9412 ereport(ERROR,
9413 (errcode(ERRCODE_WINDOWING_ERROR),
9414 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
9415 scanner_errposition(@1)));
9416 if ($1 & FRAMEOPTION_START_CURRENT_ROW)
9417 ereport(ERROR,
9418 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
9419 errmsg("frame start at CURRENT ROW is not implemented"),
9420 scanner_errposition(@1)));
9421 $$ = $1 | FRAMEOPTION_END_CURRENT_ROW;
9422 }
9423 | BETWEEN frame_bound AND frame_bound
9424 {
9425 /* reject invalid cases */
9426 if ($2 & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
9427 ereport(ERROR,
9428 (errcode(ERRCODE_WINDOWING_ERROR),
9429 errmsg("frame start cannot be UNBOUNDED FOLLOWING"),
9430 scanner_errposition(@2)));
9431 if ($2 & FRAMEOPTION_START_CURRENT_ROW)
9432 ereport(ERROR,
9433 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
9434 errmsg("frame start at CURRENT ROW is not implemented"),
9435 scanner_errposition(@2)));
9436 if ($4 & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
9437 ereport(ERROR,
9438 (errcode(ERRCODE_WINDOWING_ERROR),
9439 errmsg("frame end cannot be UNBOUNDED PRECEDING"),
9440 scanner_errposition(@4)));
9441 /* shift converts START_ options to END_ options */
9442 $$ = FRAMEOPTION_BETWEEN | $2 | ($4 << 1);
9443 }
9444 ;
9445
9446 /*
9447 * This is used for both frame start and frame end, with output set up on
9448 * the assumption it's frame start; the frame_extent productions must reject
9449 * invalid cases.
9450 */
9451 frame_bound:
9452 UNBOUNDED PRECEDING
9453 {
9454 $$ = FRAMEOPTION_START_UNBOUNDED_PRECEDING;
9455 }
9456 | UNBOUNDED FOLLOWING
9457 {
9458 $$ = FRAMEOPTION_START_UNBOUNDED_FOLLOWING;
9459 }
9460 | CURRENT_P ROW
9461 {
9462 $$ = FRAMEOPTION_START_CURRENT_ROW;
9463 }
9464 ;
9465
9466
9467 /*
9468 * Supporting nonterminals for expressions.
9469 */
9470
9471 /* Explicit row production.
9472 *
9473 * SQL99 allows an optional ROW keyword, so we can now do single-element rows
9474 * without conflicting with the parenthesized a_expr production. Without the
9475 * ROW keyword, there must be more than one a_expr inside the parens.
9476 */
9477 row: ROW '(' expr_list ')' { $$ = $3; }
9478 | ROW '(' ')' { $$ = NIL; }
9479 | '(' expr_list ',' a_expr ')' { $$ = lappend($2, $4); }
9480 ;
9481
9482 sub_type: ANY { $$ = ANY_SUBLINK; }
9483 | SOME { $$ = ANY_SUBLINK; }
9484 | ALL { $$ = ALL_SUBLINK; }
9485 ;
9486
9487 all_Op: Op { $$ = $1; }
9488 | MathOp { $$ = $1; }
9489 ;
9490
9491 MathOp: '+' { $$ = "+"; }
9492 | '-' { $$ = "-"; }
9493 | '*' { $$ = "*"; }
9494 | '/' { $$ = "/"; }
9495 | '%' { $$ = "%"; }
9496 | '^' { $$ = "^"; }
9497 | '<' { $$ = "<"; }
9498 | '>' { $$ = ">"; }
9499 | '=' { $$ = "="; }
9500 ;
9501
9502 qual_Op: Op
9503 { $$ = list_make1(makeString($1)); }
9504 | OPERATOR '(' any_operator ')'
9505 { $$ = $3; }
9506 ;
9507
9508 qual_all_Op:
9509 all_Op
9510 { $$ = list_make1(makeString($1)); }
9511 | OPERATOR '(' any_operator ')'
9512 { $$ = $3; }
9513 ;
9514
9515 subquery_Op:
9516 all_Op
9517 { $$ = list_make1(makeString($1)); }
9518 | OPERATOR '(' any_operator ')'
9519 { $$ = $3; }
9520 | LIKE
9521 { $$ = list_make1(makeString("~~")); }
9522 | NOT LIKE
9523 { $$ = list_make1(makeString("!~~")); }
9524 | ILIKE
9525 { $$ = list_make1(makeString("~~*")); }
9526 | NOT ILIKE
9527 { $$ = list_make1(makeString("!~~*")); }
9528 /* cannot put SIMILAR TO here, because SIMILAR TO is a hack.
9529 * the regular expression is preprocessed by a function (similar_escape),
9530 * and the ~ operator for posix regular expressions is used.
9531 * x SIMILAR TO y -> x ~ similar_escape(y)
9532 * this transformation is made on the fly by the parser upwards.
9533 * however the SubLink structure which handles any/some/all stuff
9534 * is not ready for such a thing.
9535 */
9536 ;
9537
9538 expr_list: a_expr
9539 {
9540 $$ = list_make1($1);
9541 }
9542 | expr_list ',' a_expr
9543 {
9544 $$ = lappend($1, $3);
9545 }
9546 ;
9547
9548 type_list: Typename { $$ = list_make1($1); }
9549 | type_list ',' Typename { $$ = lappend($1, $3); }
9550 ;
9551
9552 array_expr: '[' expr_list ']'
9553 {
9554 $$ = makeAArrayExpr($2, @1);
9555 }
9556 | '[' array_expr_list ']'
9557 {
9558 $$ = makeAArrayExpr($2, @1);
9559 }
9560 | '[' ']'
9561 {
9562 $$ = makeAArrayExpr(NIL, @1);
9563 }
9564 ;
9565
9566 array_expr_list: array_expr { $$ = list_make1($1); }
9567 | array_expr_list ',' array_expr { $$ = lappend($1, $3); }
9568 ;
9569
9570
9571 extract_list:
9572 extract_arg FROM a_expr
9573 {
9574 $$ = list_make2(makeStringConst($1, @1), $3);
9575 }
9576 | /*EMPTY*/ { $$ = NIL; }
9577 ;
9578
9579 /* Allow delimited string Sconst in extract_arg as an SQL extension.
9580 * - thomas 2001-04-12
9581 */
9582 extract_arg:
9583 IDENT { $$ = $1; }
9584 | YEAR_P { $$ = "year"; }
9585 | MONTH_P { $$ = "month"; }
9586 | DAY_P { $$ = "day"; }
9587 | HOUR_P { $$ = "hour"; }
9588 | MINUTE_P { $$ = "minute"; }
9589 | SECOND_P { $$ = "second"; }
9590 | Sconst { $$ = $1; }
9591 ;
9592
9593 /* OVERLAY() arguments
9594 * SQL99 defines the OVERLAY() function:
9595 * o overlay(text placing text from int for int)
9596 * o overlay(text placing text from int)
9597 */
9598 overlay_list:
9599 a_expr overlay_placing substr_from substr_for
9600 {
9601 $$ = list_make4($1, $2, $3, $4);
9602 }
9603 | a_expr overlay_placing substr_from
9604 {
9605 $$ = list_make3($1, $2, $3);
9606 }
9607 ;
9608
9609 overlay_placing:
9610 PLACING a_expr
9611 { $$ = $2; }
9612 ;
9613
9614 /* position_list uses b_expr not a_expr to avoid conflict with general IN */
9615
9616 position_list:
9617 b_expr IN_P b_expr { $$ = list_make2($3, $1); }
9618 | /*EMPTY*/ { $$ = NIL; }
9619 ;
9620
9621 /* SUBSTRING() arguments
9622 * SQL9x defines a specific syntax for arguments to SUBSTRING():
9623 * o substring(text from int for int)
9624 * o substring(text from int) get entire string from starting point "int"
9625 * o substring(text for int) get first "int" characters of string
9626 * o substring(text from pattern) get entire string matching pattern
9627 * o substring(text from pattern for escape) same with specified escape char
9628 * We also want to support generic substring functions which accept
9629 * the usual generic list of arguments. So we will accept both styles
9630 * here, and convert the SQL9x style to the generic list for further
9631 * processing. - thomas 2000-11-28
9632 */
9633 substr_list:
9634 a_expr substr_from substr_for
9635 {
9636 $$ = list_make3($1, $2, $3);
9637 }
9638 | a_expr substr_for substr_from
9639 {
9640 /* not legal per SQL99, but might as well allow it */
9641 $$ = list_make3($1, $3, $2);
9642 }
9643 | a_expr substr_from
9644 {
9645 $$ = list_make2($1, $2);
9646 }
9647 | a_expr substr_for
9648 {
9649 /*
9650 * Since there are no cases where this syntax allows
9651 * a textual FOR value, we forcibly cast the argument
9652 * to int4. The possible matches in pg_proc are
9653 * substring(text,int4) and substring(text,text),
9654 * and we don't want the parser to choose the latter,
9655 * which it is likely to do if the second argument
9656 * is unknown or doesn't have an implicit cast to int4.
9657 */
9658 $$ = list_make3($1, makeIntConst(1, -1),
9659 makeTypeCast($2,
9660 SystemTypeName("int4"), -1));
9661 }
9662 | expr_list
9663 {
9664 $$ = $1;
9665 }
9666 | /*EMPTY*/
9667 { $$ = NIL; }
9668 ;
9669
9670 substr_from:
9671 FROM a_expr { $$ = $2; }
9672 ;
9673
9674 substr_for: FOR a_expr { $$ = $2; }
9675 ;
9676
9677 trim_list: a_expr FROM expr_list { $$ = lappend($3, $1); }
9678 | FROM expr_list { $$ = $2; }
9679 | expr_list { $$ = $1; }
9680 ;
9681
9682 in_expr: select_with_parens
9683 {
9684 SubLink *n = makeNode(SubLink);
9685 n->subselect = $1;
9686 /* other fields will be filled later */
9687 $$ = (Node *)n;
9688 }
9689 | '(' expr_list ')' { $$ = (Node *)$2; }
9690 ;
9691
9692 /*
9693 * Define SQL92-style case clause.
9694 * - Full specification
9695 * CASE WHEN a = b THEN c ... ELSE d END
9696 * - Implicit argument
9697 * CASE a WHEN b THEN c ... ELSE d END
9698 */
9699 case_expr: CASE case_arg when_clause_list case_default END_P
9700 {
9701 CaseExpr *c = makeNode(CaseExpr);
9702 c->casetype = InvalidOid; /* not analyzed yet */
9703 c->arg = (Expr *) $2;
9704 c->args = $3;
9705 c->defresult = (Expr *) $4;
9706 c->location = @1;
9707 $$ = (Node *)c;
9708 }
9709 ;
9710
9711 when_clause_list:
9712 /* There must be at least one */
9713 when_clause { $$ = list_make1($1); }
9714 | when_clause_list when_clause { $$ = lappend($1, $2); }
9715 ;
9716
9717 when_clause:
9718 WHEN a_expr THEN a_expr
9719 {
9720 CaseWhen *w = makeNode(CaseWhen);
9721 w->expr = (Expr *) $2;
9722 w->result = (Expr *) $4;
9723 w->location = @1;
9724 $$ = (Node *)w;
9725 }
9726 ;
9727
9728 case_default:
9729 ELSE a_expr { $$ = $2; }
9730 | /*EMPTY*/ { $$ = NULL; }
9731 ;
9732
9733 case_arg: a_expr { $$ = $1; }
9734 | /*EMPTY*/ { $$ = NULL; }
9735 ;
9736
9737 /*
9738 * columnref starts with relation_name not ColId, so that OLD and NEW
9739 * references can be accepted. Note that when there are more than two
9740 * dotted names, the first name is not actually a relation name...
9741 */
9742 columnref: relation_name
9743 {
9744 $$ = makeColumnRef($1, NIL, @1);
9745 }
9746 | relation_name indirection
9747 {
9748 $$ = makeColumnRef($1, $2, @1);
9749 }
9750 ;
9751
9752 indirection_el:
9753 '.' attr_name
9754 {
9755 $$ = (Node *) makeString($2);
9756 }
9757 | '.' '*'
9758 {
9759 $$ = (Node *) makeNode(A_Star);
9760 }
9761 | '[' a_expr ']'
9762 {
9763 A_Indices *ai = makeNode(A_Indices);
9764 ai->lidx = NULL;
9765 ai->uidx = $2;
9766 $$ = (Node *) ai;
9767 }
9768 | '[' a_expr ':' a_expr ']'
9769 {
9770 A_Indices *ai = makeNode(A_Indices);
9771 ai->lidx = $2;
9772 ai->uidx = $4;
9773 $$ = (Node *) ai;
9774 }
9775 ;
9776
9777 indirection:
9778 indirection_el { $$ = list_make1($1); }
9779 | indirection indirection_el { $$ = lappend($1, $2); }
9780 ;
9781
9782 opt_indirection:
9783 /*EMPTY*/ { $$ = NIL; }
9784 | opt_indirection indirection_el { $$ = lappend($1, $2); }
9785 ;
9786
9787 opt_asymmetric: ASYMMETRIC
9788 | /*EMPTY*/
9789 ;
9790
9791 /*
9792 * The SQL spec defines "contextually typed value expressions" and
9793 * "contextually typed row value constructors", which for our purposes
9794 * are the same as "a_expr" and "row" except that DEFAULT can appear at
9795 * the top level.
9796 */
9797
9798 ctext_expr:
9799 a_expr { $$ = (Node *) $1; }
9800 | DEFAULT
9801 {
9802 SetToDefault *n = makeNode(SetToDefault);
9803 n->location = @1;
9804 $$ = (Node *) n;
9805 }
9806 ;
9807
9808 ctext_expr_list:
9809 ctext_expr { $$ = list_make1($1); }
9810 | ctext_expr_list ',' ctext_expr { $$ = lappend($1, $3); }
9811 ;
9812
9813 /*
9814 * We should allow ROW '(' ctext_expr_list ')' too, but that seems to require
9815 * making VALUES a fully reserved word, which will probably break more apps
9816 * than allowing the noise-word is worth.
9817 */
9818 ctext_row: '(' ctext_expr_list ')' { $$ = $2; }
9819 ;
9820
9821
9822 /*****************************************************************************
9823 *
9824 * target list for SELECT
9825 *
9826 *****************************************************************************/
9827
9828 target_list:
9829 target_el { $$ = list_make1($1); }
9830 | target_list ',' target_el { $$ = lappend($1, $3); }
9831 ;
9832
9833 target_el: a_expr AS ColLabel
9834 {
9835 $$ = makeNode(ResTarget);
9836 $$->name = $3;
9837 $$->indirection = NIL;
9838 $$->val = (Node *)$1;
9839 $$->location = @1;
9840 }
9841 /*
9842 * We support omitting AS only for column labels that aren't
9843 * any known keyword. There is an ambiguity against postfix
9844 * operators: is "a ! b" an infix expression, or a postfix
9845 * expression and a column label? We prefer to resolve this
9846 * as an infix expression, which we accomplish by assigning
9847 * IDENT a precedence higher than POSTFIXOP.
9848 */
9849 | a_expr IDENT
9850 {
9851 $$ = makeNode(ResTarget);
9852 $$->name = $2;
9853 $$->indirection = NIL;
9854 $$->val = (Node *)$1;
9855 $$->location = @1;
9856 }
9857 | a_expr
9858 {
9859 $$ = makeNode(ResTarget);
9860 $$->name = NULL;
9861 $$->indirection = NIL;
9862 $$->val = (Node *)$1;
9863 $$->location = @1;
9864 }
9865 | '*'
9866 {
9867 ColumnRef *n = makeNode(ColumnRef);
9868 n->fields = list_make1(makeNode(A_Star));
9869 n->location = @1;
9870
9871 $$ = makeNode(ResTarget);
9872 $$->name = NULL;
9873 $$->indirection = NIL;
9874 $$->val = (Node *)n;
9875 $$->location = @1;
9876 }
9877 ;
9878
9879
9880 /*****************************************************************************
9881 *
9882 * Names and constants
9883 *
9884 *****************************************************************************/
9885
9886 relation_name:
9887 SpecialRuleRelation { $$ = $1; }
9888 | ColId { $$ = $1; }
9889 ;
9890
9891 qualified_name_list:
9892 qualified_name { $$ = list_make1($1); }
9893 | qualified_name_list ',' qualified_name { $$ = lappend($1, $3); }
9894 ;
9895
9896 /*
9897 * The production for a qualified relation name has to exactly match the
9898 * production for a qualified func_name, because in a FROM clause we cannot
9899 * tell which we are parsing until we see what comes after it ('(' for a
9900 * func_name, something else for a relation). Therefore we allow 'indirection'
9901 * which may contain subscripts, and reject that case in the C code.
9902 */
9903 qualified_name:
9904 relation_name
9905 {
9906 $$ = makeNode(RangeVar);
9907 $$->catalogname = NULL;
9908 $$->schemaname = NULL;
9909 $$->relname = $1;
9910 $$->location = @1;
9911 }
9912 | relation_name indirection
9913 {
9914 check_qualified_name($2);
9915 $$ = makeNode(RangeVar);
9916 switch (list_length($2))
9917 {
9918 case 1:
9919 $$->catalogname = NULL;
9920 $$->schemaname = $1;
9921 $$->relname = strVal(linitial($2));
9922 break;
9923 case 2:
9924 $$->catalogname = $1;
9925 $$->schemaname = strVal(linitial($2));
9926 $$->relname = strVal(lsecond($2));
9927 break;
9928 default:
9929 ereport(ERROR,
9930 (errcode(ERRCODE_SYNTAX_ERROR),
9931 errmsg("improper qualified name (too many dotted names): %s",
9932 NameListToString(lcons(makeString($1), $2))),
9933 scanner_errposition(@1)));
9934 break;
9935 }
9936 $$->location = @1;
9937 }
9938 ;
9939
9940 name_list: name
9941 { $$ = list_make1(makeString($1)); }
9942 | name_list ',' name
9943 { $$ = lappend($1, makeString($3)); }
9944 ;
9945
9946
9947 name: ColId { $$ = $1; };
9948
9949 database_name:
9950 ColId { $$ = $1; };
9951
9952 access_method:
9953 ColId { $$ = $1; };
9954
9955 attr_name: ColLabel { $$ = $1; };
9956
9957 index_name: ColId { $$ = $1; };
9958
9959 file_name: Sconst { $$ = $1; };
9960
9961 /*
9962 * The production for a qualified func_name has to exactly match the
9963 * production for a qualified columnref, because we cannot tell which we
9964 * are parsing until we see what comes after it ('(' or Sconst for a func_name,
9965 * anything else for a columnref). Therefore we allow 'indirection' which
9966 * may contain subscripts, and reject that case in the C code. (If we
9967 * ever implement SQL99-like methods, such syntax may actually become legal!)
9968 */
9969 func_name: type_function_name
9970 { $$ = list_make1(makeString($1)); }
9971 | relation_name indirection
9972 { $$ = check_func_name(lcons(makeString($1), $2)); }
9973 ;
9974
9975
9976 /*
9977 * Constants
9978 */
9979 AexprConst: Iconst
9980 {
9981 $$ = makeIntConst($1, @1);
9982 }
9983 | FCONST
9984 {
9985 $$ = makeFloatConst($1, @1);
9986 }
9987 | Sconst
9988 {
9989 $$ = makeStringConst($1, @1);
9990 }
9991 | BCONST
9992 {
9993 $$ = makeBitStringConst($1, @1);
9994 }
9995 | XCONST
9996 {
9997 /* This is a bit constant per SQL99:
9998 * Without Feature F511, "BIT data type",
9999 * a <general literal> shall not be a
10000 * <bit string literal> or a <hex string literal>.
10001 */
10002 $$ = makeBitStringConst($1, @1);
10003 }
10004 | func_name Sconst
10005 {
10006 /* generic type 'literal' syntax */
10007 TypeName *t = makeTypeNameFromNameList($1);
10008 t->location = @1;
10009 $$ = makeStringConstCast($2, @2, t);
10010 }
10011 | func_name '(' expr_list ')' Sconst
10012 {
10013 /* generic syntax with a type modifier */
10014 TypeName *t = makeTypeNameFromNameList($1);
10015 t->typmods = $3;
10016 t->location = @1;
10017 $$ = makeStringConstCast($5, @5, t);
10018 }
10019 | ConstTypename Sconst
10020 {
10021 $$ = makeStringConstCast($2, @2, $1);
10022 }
10023 | ConstInterval Sconst opt_interval
10024 {
10025 TypeName *t = $1;
10026 t->typmods = $3;
10027 $$ = makeStringConstCast($2, @2, t);
10028 }
10029 | ConstInterval '(' Iconst ')' Sconst opt_interval
10030 {
10031 TypeName *t = $1;
10032 if ($6 != NIL)
10033 {
10034 if (list_length($6) != 1)
10035 ereport(ERROR,
10036 (errcode(ERRCODE_SYNTAX_ERROR),
10037 errmsg("interval precision specified twice"),
10038 scanner_errposition(@1)));
10039 t->typmods = lappend($6, makeIntConst($3, @3));
10040 }
10041 else
10042 t->typmods = list_make2(makeIntConst(INTERVAL_FULL_RANGE, -1),
10043 makeIntConst($3, @3));
10044 $$ = makeStringConstCast($5, @5, t);
10045 }
10046 | TRUE_P
10047 {
10048 $$ = makeBoolAConst(TRUE, @1);
10049 }
10050 | FALSE_P
10051 {
10052 $$ = makeBoolAConst(FALSE, @1);
10053 }
10054 | NULL_P
10055 {
10056 $$ = makeNullAConst(@1);
10057 }
10058 ;
10059
10060 Iconst: ICONST { $$ = $1; };
10061 Sconst: SCONST { $$ = $1; };
10062 RoleId: ColId { $$ = $1; };
10063
10064 SignedIconst: Iconst { $$ = $1; }
10065 | '+' Iconst { $$ = + $2; }
10066 | '-' Iconst { $$ = - $2; }
10067 ;
10068
10069 /*
10070 * Name classification hierarchy.
10071 *
10072 * IDENT is the lexeme returned by the lexer for identifiers that match
10073 * no known keyword. In most cases, we can accept certain keywords as
10074 * names, not only IDENTs. We prefer to accept as many such keywords
10075 * as possible to minimize the impact of "reserved words" on programmers.
10076 * So, we divide names into several possible classes. The classification
10077 * is chosen in part to make keywords acceptable as names wherever possible.
10078 */
10079
10080 /* Column identifier --- names that can be column, table, etc names.
10081 */
10082 ColId: IDENT { $$ = $1; }
10083 | unreserved_keyword { $$ = pstrdup($1); }
10084 | col_name_keyword { $$ = pstrdup($1); }
10085 ;
10086
10087 /* Type/function identifier --- names that can be type or function names.
10088 */
10089 type_function_name: IDENT { $$ = $1; }
10090 | unreserved_keyword { $$ = pstrdup($1); }
10091 | type_func_name_keyword { $$ = pstrdup($1); }
10092 ;
10093
10094 /* Column label --- allowed labels in "AS" clauses.
10095 * This presently includes *all* Postgres keywords.
10096 */
10097 ColLabel: IDENT { $$ = $1; }
10098 | unreserved_keyword { $$ = pstrdup($1); }
10099 | col_name_keyword { $$ = pstrdup($1); }
10100 | type_func_name_keyword { $$ = pstrdup($1); }
10101 | reserved_keyword { $$ = pstrdup($1); }
10102 ;
10103
10104
10105 /*
10106 * Keyword category lists. Generally, every keyword present in
10107 * the Postgres grammar should appear in exactly one of these lists.
10108 *
10109 * Put a new keyword into the first list that it can go into without causing
10110 * shift or reduce conflicts. The earlier lists define "less reserved"
10111 * categories of keywords.
10112 *
10113 * Make sure that each keyword's category in keywords.c matches where
10114 * it is listed here. (Someday we may be able to generate these lists and
10115 * keywords.c's table from a common master list.)
10116 */
10117
10118 /* "Unreserved" keywords --- available for use as any kind of name.
10119 */
10120 unreserved_keyword:
10121 ABORT_P
10122 | ABSOLUTE_P
10123 | ACCESS
10124 | ACTION
10125 | ADD_P
10126 | ADMIN
10127 | AFTER
10128 | AGGREGATE
10129 | ALSO
10130 | ALTER
10131 | ALWAYS
10132 | ASSERTION
10133 | ASSIGNMENT
10134 | AT
10135 | BACKWARD
10136 | BEFORE
10137 | BEGIN_P
10138 | BY
10139 | CACHE
10140 | CALLED
10141 | CASCADE
10142 | CASCADED
10143 | CATALOG_P
10144 | CHAIN
10145 | CHARACTERISTICS
10146 | CHECKPOINT
10147 | CLASS
10148 | CLOSE
10149 | CLUSTER
10150 | COMMENT
10151 | COMMIT
10152 | COMMITTED
10153 | CONCURRENTLY
10154 | CONFIGURATION
10155 | CONNECTION
10156 | CONSTRAINTS
10157 | CONTENT_P
10158 | CONTINUE_P
10159 | CONVERSION_P
10160 | COPY
10161 | COST
10162 | CREATEDB
10163 | CREATEROLE
10164 | CREATEUSER
10165 | CSV
10166 | CURRENT_P
10167 | CURSOR
10168 | CYCLE
10169 | DATA_P
10170 | DATABASE
10171 | DAY_P
10172 | DEALLOCATE
10173 | DECLARE
10174 | DEFAULTS
10175 | DEFERRED
10176 | DEFINER
10177 | DELETE_P
10178 | DELIMITER
10179 | DELIMITERS
10180 | DICTIONARY
10181 | DISABLE_P
10182 | DISCARD
10183 | DOCUMENT_P
10184 | DOMAIN_P
10185 | DOUBLE_P
10186 | DROP
10187 | EACH
10188 | ENABLE_P
10189 | ENCODING
10190 | ENCRYPTED
10191 | ENUM_P
10192 | ESCAPE
10193 | EXCLUDING
10194 | EXCLUSIVE
10195 | EXECUTE
10196 | EXPLAIN
10197 | EXTERNAL
10198 | FAMILY
10199 | FIRST_P
10200 | FOLLOWING
10201 | FORCE
10202 | FORWARD
10203 | FUNCTION
10204 | GLOBAL
10205 | GRANTED
10206 | HANDLER
10207 | HEADER_P
10208 | HOLD
10209 | HOUR_P
10210 | IDENTITY_P
10211 | IF_P
10212 | IMMEDIATE
10213 | IMMUTABLE
10214 | IMPLICIT_P
10215 | INCLUDING
10216 | INCREMENT
10217 | INDEX
10218 | INDEXES
10219 | INHERIT
10220 | INHERITS
10221 | INPUT_P
10222 | INSENSITIVE
10223 | INSERT
10224 | INSTEAD
10225 | INVOKER
10226 | ISOLATION
10227 | KEY
10228 | LANCOMPILER
10229 | LANGUAGE
10230 | LARGE_P
10231 | LAST_P
10232 | LC_COLLATE_P
10233 | LC_CTYPE_P
10234 | LEVEL
10235 | LISTEN
10236 | LOAD
10237 | LOCAL
10238 | LOCATION
10239 | LOCK_P
10240 | LOGIN_P
10241 | MAPPING
10242 | MATCH
10243 | MAXVALUE
10244 | MINUTE_P
10245 | MINVALUE
10246 | MODE
10247 | MONTH_P
10248 | MOVE
10249 | NAME_P
10250 | NAMES
10251 | NEXT
10252 | NO
10253 | NOCREATEDB
10254 | NOCREATEROLE
10255 | NOCREATEUSER
10256 | NOINHERIT
10257 | NOLOGIN_P
10258 | NOSUPERUSER
10259 | NOTHING
10260 | NOTIFY
10261 | NOWAIT
10262 | NULLS_P
10263 | OBJECT_P
10264 | OF
10265 | OIDS
10266 | OPERATOR
10267 | OPTION
10268 | OPTIONS
10269 | OWNED
10270 | OWNER
10271 | PARSER
10272 | PARTIAL
10273 | PARTITION
10274 | PASSWORD
10275 | PLANS
10276 | PRECEDING
10277 | PREPARE
10278 | PREPARED
10279 | PRESERVE
10280 | PRIOR
10281 | PRIVILEGES
10282 | PROCEDURAL
10283 | PROCEDURE
10284 | QUOTE
10285 | RANGE
10286 | READ
10287 | REASSIGN
10288 | RECHECK
10289 | RECURSIVE
10290 | REINDEX
10291 | RELATIVE_P
10292 | RELEASE
10293 | RENAME
10294 | REPEATABLE
10295 | REPLACE
10296 | REPLICA
10297 | RESET
10298 | RESTART
10299 | RESTRICT
10300 | RETURNS
10301 | REVOKE
10302 | ROLE
10303 | ROLLBACK
10304 | ROWS
10305 | RULE
10306 | SAVEPOINT
10307 | SCHEMA
10308 | SCROLL
10309 | SEARCH
10310 | SECOND_P
10311 | SECURITY
10312 | SEQUENCE
10313 | SERIALIZABLE
10314 | SERVER
10315 | SESSION
10316 | SET
10317 | SHARE
10318 | SHOW
10319 | SIMPLE
10320 | STABLE
10321 | STANDALONE_P
10322 | START
10323 | STATEMENT
10324 | STATISTICS
10325 | STDIN
10326 | STDOUT
10327 | STORAGE
10328 | STRICT_P
10329 | STRIP_P
10330 | SUPERUSER_P
10331 | SYSID
10332 | SYSTEM_P
10333 | TABLESPACE
10334 | TEMP
10335 | TEMPLATE
10336 | TEMPORARY
10337 | TEXT_P
10338 | TRANSACTION
10339 | TRIGGER
10340 | TRUNCATE
10341 | TRUSTED
10342 | TYPE_P
10343 | UNBOUNDED
10344 | UNCOMMITTED
10345 | UNENCRYPTED
10346 | UNKNOWN
10347 | UNLISTEN
10348 | UNTIL
10349 | UPDATE
10350 | VACUUM
10351 | VALID
10352 | VALIDATOR
10353 | VALUE_P
10354 | VARYING
10355 | VERSION_P
10356 | VIEW
10357 | VOLATILE
10358 | WHITESPACE_P
10359 | WITHOUT
10360 | WORK
10361 | WRAPPER
10362 | WRITE
10363 | XML_P
10364 | YEAR_P
10365 | YES_P
10366 | ZONE
10367 ;
10368
10369 /* Column identifier --- keywords that can be column, table, etc names.
10370 *
10371 * Many of these keywords will in fact be recognized as type or function
10372 * names too; but they have special productions for the purpose, and so
10373 * can't be treated as "generic" type or function names.
10374 *
10375 * The type names appearing here are not usable as function names
10376 * because they can be followed by '(' in typename productions, which
10377 * looks too much like a function call for an LR(1) parser.
10378 */
10379 col_name_keyword:
10380 BIGINT
10381 | BIT
10382 | BOOLEAN_P
10383 | CHAR_P
10384 | CHARACTER
10385 | COALESCE
10386 | DEC
10387 | DECIMAL_P
10388 | EXISTS
10389 | EXTRACT
10390 | FLOAT_P
10391 | GREATEST
10392 | INOUT
10393 | INT_P
10394 | INTEGER
10395 | INTERVAL
10396 | LEAST
10397 | NATIONAL
10398 | NCHAR
10399 | NONE
10400 | NULLIF
10401 | NUMERIC
10402 | OUT_P
10403 | OVERLAY
10404 | POSITION
10405 | PRECISION
10406 | REAL
10407 | ROW
10408 | SETOF
10409 | SMALLINT
10410 | SUBSTRING
10411 | TIME
10412 | TIMESTAMP
10413 | TREAT
10414 | TRIM
10415 | VALUES
10416 | VARCHAR
10417 | XMLATTRIBUTES
10418 | XMLCONCAT
10419 | XMLELEMENT
10420 | XMLFOREST
10421 | XMLPARSE
10422 | XMLPI
10423 | XMLROOT
10424 | XMLSERIALIZE
10425 ;
10426
10427 /* Type/function identifier --- keywords that can be type or function names.
10428 *
10429 * Most of these are keywords that are used as operators in expressions;
10430 * in general such keywords can't be column names because they would be
10431 * ambiguous with variables, but they are unambiguous as function identifiers.
10432 *
10433 * Do not include POSITION, SUBSTRING, etc here since they have explicit
10434 * productions in a_expr to support the goofy SQL9x argument syntax.
10435 * - thomas 2000-11-28
10436 */
10437 type_func_name_keyword:
10438 AUTHORIZATION
10439 | BETWEEN
10440 | BINARY
10441 | CROSS
10442 | CURRENT_SCHEMA
10443 | FREEZE
10444 | FULL
10445 | ILIKE
10446 | INNER_P
10447 | IS
10448 | ISNULL
10449 | JOIN
10450 | LEFT
10451 | LIKE
10452 | NATURAL
10453 | NOTNULL
10454 | OUTER_P
10455 | OVER
10456 | OVERLAPS
10457 | RIGHT
10458 | SIMILAR
10459 | VERBOSE
10460 ;
10461
10462 /* Reserved keyword --- these keywords are usable only as a ColLabel.
10463 *
10464 * Keywords appear here if they could not be distinguished from variable,
10465 * type, or function names in some contexts. Don't put things here unless
10466 * forced to.
10467 */
10468 reserved_keyword:
10469 ALL
10470 | ANALYSE
10471 | ANALYZE
10472 | AND
10473 | ANY
10474 | ARRAY
10475 | AS
10476 | ASC
10477 | ASYMMETRIC
10478 | BOTH
10479 | CASE
10480 | CAST
10481 | CHECK
10482 | COLLATE
10483 | COLUMN
10484 | CONSTRAINT
10485 | CREATE
10486 | CURRENT_CATALOG
10487 | CURRENT_DATE
10488 | CURRENT_ROLE
10489 | CURRENT_TIME
10490 | CURRENT_TIMESTAMP
10491 | CURRENT_USER
10492 | DEFAULT
10493 | DEFERRABLE
10494 | DESC
10495 | DISTINCT
10496 | DO
10497 | ELSE
10498 | END_P
10499 | EXCEPT
10500 | FALSE_P
10501 | FETCH
10502 | FOR
10503 | FOREIGN
10504 | FROM
10505 | GRANT
10506 | GROUP_P
10507 | HAVING
10508 | IN_P
10509 | INITIALLY
10510 | INTERSECT
10511 | INTO
10512 | LEADING
10513 | LIMIT
10514 | LOCALTIME
10515 | LOCALTIMESTAMP
10516 | NEW
10517 | NOT
10518 | NULL_P
10519 | OFF
10520 | OFFSET
10521 | OLD
10522 | ON
10523 | ONLY
10524 | OR
10525 | ORDER
10526 | PLACING
10527 | PRIMARY
10528 | REFERENCES
10529 | RETURNING
10530 | SELECT
10531 | SESSION_USER
10532 | SOME
10533 | SYMMETRIC
10534 | TABLE
10535 | THEN
10536 | TO
10537 | TRAILING
10538 | TRUE_P
10539 | UNION
10540 | UNIQUE
10541 | USER
10542 | USING
10543 | VARIADIC
10544 | WHEN
10545 | WHERE
10546 | WINDOW
10547 | WITH
10548 ;
10549
10550
10551 SpecialRuleRelation:
10552 OLD
10553 {
10554 if (QueryIsRule)
10555 $$ = "*OLD*";
10556 else
10557 ereport(ERROR,
10558 (errcode(ERRCODE_SYNTAX_ERROR),
10559 errmsg("OLD used in query that is not in a rule"),
10560 scanner_errposition(@1)));
10561 }
10562 | NEW
10563 {
10564 if (QueryIsRule)
10565 $$ = "*NEW*";
10566 else
10567 ereport(ERROR,
10568 (errcode(ERRCODE_SYNTAX_ERROR),
10569 errmsg("NEW used in query that is not in a rule"),
10570 scanner_errposition(@1)));
10571 }
10572 ;
10573
10574 %%
10575
10576 static Node *
10577 makeColumnRef(char *colname, List *indirection, int location)
10578 {
10579 /*
10580 * Generate a ColumnRef node, with an A_Indirection node added if there
10581 * is any subscripting in the specified indirection list. However,
10582 * any field selection at the start of the indirection list must be
10583 * transposed into the "fields" part of the ColumnRef node.
10584 */
10585 ColumnRef *c = makeNode(ColumnRef);
10586 int nfields = 0;
10587 ListCell *l;
10588
10589 c->location = location;
10590 foreach(l, indirection)
10591 {
10592 if (IsA(lfirst(l), A_Indices))
10593 {
10594 A_Indirection *i = makeNode(A_Indirection);
10595
10596 if (nfields == 0)
10597 {
10598 /* easy case - all indirection goes to A_Indirection */
10599 c->fields = list_make1(makeString(colname));
10600 i->indirection = check_indirection(indirection);
10601 }
10602 else
10603 {
10604 /* got to split the list in two */
10605 i->indirection = check_indirection(list_copy_tail(indirection,
10606 nfields));
10607 indirection = list_truncate(indirection, nfields);
10608 c->fields = lcons(makeString(colname), indirection);
10609 }
10610 i->arg = (Node *) c;
10611 return (Node *) i;
10612 }
10613 else if (IsA(lfirst(l), A_Star))
10614 {
10615 /* We only allow '*' at the end of a ColumnRef */
10616 if (lnext(l) != NULL)
10617 yyerror("improper use of \"*\"");
10618 }
10619 nfields++;
10620 }
10621 /* No subscripting, so all indirection gets added to field list */
10622 c->fields = lcons(makeString(colname), indirection);
10623 return (Node *) c;
10624 }
10625
10626 static Node *
10627 makeTypeCast(Node *arg, TypeName *typename, int location)
10628 {
10629 TypeCast *n = makeNode(TypeCast);
10630 n->arg = arg;
10631 n->typename = typename;
10632 n->location = location;
10633 return (Node *) n;
10634 }
10635
10636 static Node *
10637 makeStringConst(char *str, int location)
10638 {
10639 A_Const *n = makeNode(A_Const);
10640
10641 n->val.type = T_String;
10642 n->val.val.str = str;
10643 n->location = location;
10644
10645 return (Node *)n;
10646 }
10647
10648 static Node *
10649 makeStringConstCast(char *str, int location, TypeName *typename)
10650 {
10651 Node *s = makeStringConst(str, location);
10652
10653 return makeTypeCast(s, typename, -1);
10654 }
10655
10656 static Node *
10657 makeIntConst(int val, int location)
10658 {
10659 A_Const *n = makeNode(A_Const);
10660
10661 n->val.type = T_Integer;
10662 n->val.val.ival = val;
10663 n->location = location;
10664
10665 return (Node *)n;
10666 }
10667
10668 static Node *
10669 makeFloatConst(char *str, int location)
10670 {
10671 A_Const *n = makeNode(A_Const);
10672
10673 n->val.type = T_Float;
10674 n->val.val.str = str;
10675 n->location = location;
10676
10677 return (Node *)n;
10678 }
10679
10680 static Node *
10681 makeBitStringConst(char *str, int location)
10682 {
10683 A_Const *n = makeNode(A_Const);
10684
10685 n->val.type = T_BitString;
10686 n->val.val.str = str;
10687 n->location = location;
10688
10689 return (Node *)n;
10690 }
10691
10692 static Node *
10693 makeNullAConst(int location)
10694 {
10695 A_Const *n = makeNode(A_Const);
10696
10697 n->val.type = T_Null;
10698 n->location = location;
10699
10700 return (Node *)n;
10701 }
10702
10703 static Node *
10704 makeAConst(Value *v, int location)
10705 {
10706 Node *n;
10707
10708 switch (v->type)
10709 {
10710 case T_Float:
10711 n = makeFloatConst(v->val.str, location);
10712 break;
10713
10714 case T_Integer:
10715 n = makeIntConst(v->val.ival, location);
10716 break;
10717
10718 case T_String:
10719 default:
10720 n = makeStringConst(v->val.str, location);
10721 break;
10722 }
10723
10724 return n;
10725 }
10726
10727 /* makeBoolAConst()
10728 * Create an A_Const string node and put it inside a boolean cast.
10729 */
10730 static Node *
10731 makeBoolAConst(bool state, int location)
10732 {
10733 A_Const *n = makeNode(A_Const);
10734
10735 n->val.type = T_String;
10736 n->val.val.str = (state ? "t" : "f");
10737 n->location = location;
10738
10739 return makeTypeCast((Node *)n, SystemTypeName("bool"), -1);
10740 }
10741
10742 /* makeOverlaps()
10743 * Create and populate a FuncCall node to support the OVERLAPS operator.
10744 */
10745 static FuncCall *
10746 makeOverlaps(List *largs, List *rargs, int location)
10747 {
10748 FuncCall *n = makeNode(FuncCall);
10749
10750 n->funcname = SystemFuncName("overlaps");
10751 if (list_length(largs) == 1)
10752 largs = lappend(largs, largs);
10753 else if (list_length(largs) != 2)
10754 ereport(ERROR,
10755 (errcode(ERRCODE_SYNTAX_ERROR),
10756 errmsg("wrong number of parameters on left side of OVERLAPS expression"),
10757 scanner_errposition(location)));
10758 if (list_length(rargs) == 1)
10759 rargs = lappend(rargs, rargs);
10760 else if (list_length(rargs) != 2)
10761 ereport(ERROR,
10762 (errcode(ERRCODE_SYNTAX_ERROR),
10763 errmsg("wrong number of parameters on right side of OVERLAPS expression"),
10764 scanner_errposition(location)));
10765 n->args = list_concat(largs, rargs);
10766 n->agg_star = FALSE;
10767 n->agg_distinct = FALSE;
10768 n->func_variadic = FALSE;
10769 n->over = NULL;
10770 n->location = location;
10771 return n;
10772 }
10773
10774 /* check_qualified_name --- check the result of qualified_name production
10775 *
10776 * It's easiest to let the grammar production for qualified_name allow
10777 * subscripts and '*', which we then must reject here.
10778 */
10779 static void
10780 check_qualified_name(List *names)
10781 {
10782 ListCell *i;
10783
10784 foreach(i, names)
10785 {
10786 if (!IsA(lfirst(i), String))
10787 yyerror("syntax error");
10788 }
10789 }
10790
10791 /* check_func_name --- check the result of func_name production
10792 *
10793 * It's easiest to let the grammar production for func_name allow subscripts
10794 * and '*', which we then must reject here.
10795 */
10796 static List *
10797 check_func_name(List *names)
10798 {
10799 ListCell *i;
10800
10801 foreach(i, names)
10802 {
10803 if (!IsA(lfirst(i), String))
10804 yyerror("syntax error");
10805 }
10806 return names;
10807 }
10808
10809 /* check_indirection --- check the result of indirection production
10810 *
10811 * We only allow '*' at the end of the list, but it's hard to enforce that
10812 * in the grammar, so do it here.
10813 */
10814 static List *
10815 check_indirection(List *indirection)
10816 {
10817 ListCell *l;
10818
10819 foreach(l, indirection)
10820 {
10821 if (IsA(lfirst(l), A_Star))
10822 {
10823 if (lnext(l) != NULL)
10824 yyerror("improper use of \"*\"");
10825 }
10826 }
10827 return indirection;
10828 }
10829
10830 /* extractArgTypes()
10831 * Given a list of FunctionParameter nodes, extract a list of just the
10832 * argument types (TypeNames) for input parameters only. This is what
10833 * is needed to look up an existing function, which is what is wanted by
10834 * the productions that use this call.
10835 */
10836 static List *
10837 extractArgTypes(List *parameters)
10838 {
10839 List *result = NIL;
10840 ListCell *i;
10841
10842 foreach(i, parameters)
10843 {
10844 FunctionParameter *p = (FunctionParameter *) lfirst(i);
10845
10846 if (p->mode != FUNC_PARAM_OUT && p->mode != FUNC_PARAM_TABLE)
10847 result = lappend(result, p->argType);
10848 }
10849 return result;
10850 }
10851
10852 /* findLeftmostSelect()
10853 * Find the leftmost component SelectStmt in a set-operation parsetree.
10854 */
10855 static SelectStmt *
10856 findLeftmostSelect(SelectStmt *node)
10857 {
10858 while (node && node->op != SETOP_NONE)
10859 node = node->larg;
10860 Assert(node && IsA(node, SelectStmt) && node->larg == NULL);
10861 return node;
10862 }
10863
10864 /* insertSelectOptions()
10865 * Insert ORDER BY, etc into an already-constructed SelectStmt.
10866 *
10867 * This routine is just to avoid duplicating code in SelectStmt productions.
10868 */
10869 static void
10870 insertSelectOptions(SelectStmt *stmt,
10871 List *sortClause, List *lockingClause,
10872 Node *limitOffset, Node *limitCount,
10873 WithClause *withClause)
10874 {
10875 Assert(IsA(stmt, SelectStmt));
10876
10877 /*
10878 * Tests here are to reject constructs like
10879 * (SELECT foo ORDER BY bar) ORDER BY baz
10880 */
10881 if (sortClause)
10882 {
10883 if (stmt->sortClause)
10884 ereport(ERROR,
10885 (errcode(ERRCODE_SYNTAX_ERROR),
10886 errmsg("multiple ORDER BY clauses not allowed"),
10887 scanner_errposition(exprLocation((Node *) sortClause))));
10888 stmt->sortClause = sortClause;
10889 }
10890 /* We can handle multiple locking clauses, though */
10891 stmt->lockingClause = list_concat(stmt->lockingClause, lockingClause);
10892 if (limitOffset)
10893 {
10894 if (stmt->limitOffset)
10895 ereport(ERROR,
10896 (errcode(ERRCODE_SYNTAX_ERROR),
10897 errmsg("multiple OFFSET clauses not allowed"),
10898 scanner_errposition(exprLocation(limitOffset))));
10899 stmt->limitOffset = limitOffset;
10900 }
10901 if (limitCount)
10902 {
10903 if (stmt->limitCount)
10904 ereport(ERROR,
10905 (errcode(ERRCODE_SYNTAX_ERROR),
10906 errmsg("multiple LIMIT clauses not allowed"),
10907 scanner_errposition(exprLocation(limitCount))));
10908 stmt->limitCount = limitCount;
10909 }
10910 if (withClause)
10911 {
10912 if (stmt->withClause)
10913 ereport(ERROR,
10914 (errcode(ERRCODE_SYNTAX_ERROR),
10915 errmsg("multiple WITH clauses not allowed"),
10916 scanner_errposition(exprLocation((Node *) withClause))));
10917 stmt->withClause = withClause;
10918 }
10919 }
10920
10921 static Node *
10922 makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg)
10923 {
10924 SelectStmt *n = makeNode(SelectStmt);
10925
10926 n->op = op;
10927 n->all = all;
10928 n->larg = (SelectStmt *) larg;
10929 n->rarg = (SelectStmt *) rarg;
10930 return (Node *) n;
10931 }
10932
10933 /* SystemFuncName()
10934 * Build a properly-qualified reference to a built-in function.
10935 */
10936 List *
10937 SystemFuncName(char *name)
10938 {
10939 return list_make2(makeString("pg_catalog"), makeString(name));
10940 }
10941
10942 /* SystemTypeName()
10943 * Build a properly-qualified reference to a built-in type.
10944 *
10945 * typmod is defaulted, but may be changed afterwards by caller.
10946 * Likewise for the location.
10947 */
10948 TypeName *
10949 SystemTypeName(char *name)
10950 {
10951 return makeTypeNameFromNameList(list_make2(makeString("pg_catalog"),
10952 makeString(name)));
10953 }
10954
10955 /* doNegate()
10956 * Handle negation of a numeric constant.
10957 *
10958 * Formerly, we did this here because the optimizer couldn't cope with
10959 * indexquals that looked like "var = -4" --- it wants "var = const"
10960 * and a unary minus operator applied to a constant didn't qualify.
10961 * As of Postgres 7.0, that problem doesn't exist anymore because there
10962 * is a constant-subexpression simplifier in the optimizer. However,
10963 * there's still a good reason for doing this here, which is that we can
10964 * postpone committing to a particular internal representation for simple
10965 * negative constants. It's better to leave "-123.456" in string form
10966 * until we know what the desired type is.
10967 */
10968 static Node *
10969 doNegate(Node *n, int location)
10970 {
10971 if (IsA(n, A_Const))
10972 {
10973 A_Const *con = (A_Const *)n;
10974
10975 /* report the constant's location as that of the '-' sign */
10976 con->location = location;
10977
10978 if (con->val.type == T_Integer)
10979 {
10980 con->val.val.ival = -con->val.val.ival;
10981 return n;
10982 }
10983 if (con->val.type == T_Float)
10984 {
10985 doNegateFloat(&con->val);
10986 return n;
10987 }
10988 }
10989
10990 return (Node *) makeSimpleA_Expr(AEXPR_OP, "-", NULL, n, location);
10991 }
10992
10993 static void
10994 doNegateFloat(Value *v)
10995 {
10996 char *oldval = v->val.str;
10997
10998 Assert(IsA(v, Float));
10999 if (*oldval == '+')
11000 oldval++;
11001 if (*oldval == '-')
11002 v->val.str = oldval+1; /* just strip the '-' */
11003 else
11004 {
11005 char *newval = (char *) palloc(strlen(oldval) + 2);
11006
11007 *newval = '-';
11008 strcpy(newval+1, oldval);
11009 v->val.str = newval;
11010 }
11011 }
11012
11013 static Node *
11014 makeAArrayExpr(List *elements, int location)
11015 {
11016 A_ArrayExpr *n = makeNode(A_ArrayExpr);
11017
11018 n->elements = elements;
11019 n->location = location;
11020 return (Node *) n;
11021 }
11022
11023 static Node *
11024 makeXmlExpr(XmlExprOp op, char *name, List *named_args, List *args,
11025 int location)
11026 {
11027 XmlExpr *x = makeNode(XmlExpr);
11028
11029 x->op = op;
11030 x->name = name;
11031 /*
11032 * named_args is a list of ResTarget; it'll be split apart into separate
11033 * expression and name lists in transformXmlExpr().
11034 */
11035 x->named_args = named_args;
11036 x->arg_names = NIL;
11037 x->args = args;
11038 /* xmloption, if relevant, must be filled in by caller */
11039 /* type and typmod will be filled in during parse analysis */
11040 x->location = location;
11041 return (Node *) x;
11042 }
11043
11044 /* parser_init()
11045 * Initialize to parse one query string
11046 */
11047 void
11048 parser_init(void)
11049 {
11050 QueryIsRule = FALSE;
11051 }
11052
11053 /*
11054 * Merge the input and output parameters of a table function.
11055 */
11056 static List *
11057 mergeTableFuncParameters(List *func_args, List *columns)
11058 {
11059 ListCell *lc;
11060
11061 /* Explicit OUT and INOUT parameters shouldn't be used in this syntax */
11062 foreach(lc, func_args)
11063 {
11064 FunctionParameter *p = (FunctionParameter *) lfirst(lc);
11065
11066 if (p->mode != FUNC_PARAM_IN && p->mode != FUNC_PARAM_VARIADIC)
11067 ereport(ERROR,
11068 (errcode(ERRCODE_SYNTAX_ERROR),
11069 errmsg("OUT and INOUT arguments aren't allowed in TABLE functions")));
11070 }
11071
11072 return list_concat(func_args, columns);
11073 }
11074
11075 /*
11076 * Determine return type of a TABLE function. A single result column
11077 * returns setof that column's type; otherwise return setof record.
11078 */
11079 static TypeName *
11080 TableFuncTypeName(List *columns)
11081 {
11082 TypeName *result;
11083
11084 if (list_length(columns) == 1)
11085 {
11086 FunctionParameter *p = (FunctionParameter *) linitial(columns);
11087
11088 result = (TypeName *) copyObject(p->argType);
11089 }
11090 else
11091 result = SystemTypeName("record");
11092
11093 result->setof = true;
11094
11095 return result;
11096 }
11097
11098 /*
11099 * Must undefine base_yylex before including scan.c, since we want it
11100 * to create the function base_yylex not filtered_base_yylex.
11101 */
11102 #undef base_yylex
11103
11104 #include "scan.c"
PostgreSQL from CVS