| blob | d7f9c00c4099bd86c39ce79c997123a2a0ca6782 |
1 %{
3 /*#define YYDEBUG 1*/
4 /*-------------------------------------------------------------------------
5 *
6 * gram.y
7 * POSTGRESQL BISON rules/actions
8 *
9 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
10 * Portions Copyright (c) 1994, Regents of the University of California
11 *
12 *
13 * IDENTIFICATION
14 * src/backend/parser/gram.y
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 *
25 * In general, nothing in this file should initiate database accesses
26 * nor depend on changeable state (such as SET variables). If you do
27 * database accesses, your code will fail when we have aborted the
28 * current transaction and are just parsing commands to find the next
29 * ROLLBACK or COMMIT. If you make use of SET variables, then you
30 * will do the wrong thing in multi-query strings like this:
31 * SET constraint_exclusion TO off; SELECT * FROM foo;
32 * because the entire string is parsed by gram.y before the SET gets
33 * executed. Anything that depends on the database or changeable state
34 * should be handled during parse analysis so that it happens at the
35 * right time not the wrong time.
36 *
37 * WARNINGS
38 * If you use a list, make sure the datum is a node so that the printing
39 * routines work.
40 *
41 * Sometimes we assign constants to makeStrings. Make sure we don't free
42 * those.
43 *
44 *-------------------------------------------------------------------------
45 */
48 #include <ctype.h>
49 #include <limits.h>
65 /*
66 * Location tracking support. Unlike bison's default, we only want
67 * to track the start position not the end position of each nonterminal.
68 * Nonterminals that reduce to empty receive position "-1". Since a
69 * production's leading RHS nonterminal(s) may have reduced to empty,
70 * we have to scan to find the first one that's not -1.
71 */
72 #define YYLLOC_DEFAULT(Current, Rhs, N) \
73 do { \
76 { \
78 { \
80 break; \
81 } \
82 } \
85 /*
86 * Bison doesn't allocate anything that needs to live across parser calls,
87 * so we can easily have it use palloc instead of malloc. This prevents
88 * memory leaks if we error out during parsing.
89 */
90 #define YYMALLOC palloc
91 #define YYFREE pfree
93 /* Private struct for the result of privilege_target production */
94 typedef struct PrivTarget
95 {
96 GrantTargetType targtype;
97 ObjectType objtype;
101 /* Private struct for the result of import_qualification production */
102 typedef struct ImportQual
103 {
104 ImportForeignSchemaType type;
108 /* Private struct for the result of select_limit & limit_clause productions */
109 typedef struct SelectLimit
110 {
119 /* Private struct for the result of group_clause production */
120 typedef struct GroupClause
121 {
126 /* Private structs for the result of key_actions and key_action productions */
127 typedef struct KeyAction
128 {
133 typedef struct KeyActions
134 {
139 /* ConstraintAttributeSpec yields an integer bitmask of these flags: */
140 #define CAS_NOT_DEFERRABLE 0x01
141 #define CAS_DEFERRABLE 0x02
142 #define CAS_INITIALLY_IMMEDIATE 0x04
143 #define CAS_INITIALLY_DEFERRED 0x08
144 #define CAS_NOT_VALID 0x10
145 #define CAS_NO_INHERIT 0x20
146 #define CAS_NOT_ENFORCED 0x40
147 #define CAS_ENFORCED 0x80
150 #define parser_yyerror(msg) scanner_yyerror(msg, yyscanner)
151 #define parser_errposition(pos) scanner_errposition(pos, yyscanner)
175 core_yyscan_t yyscanner);
180 core_yyscan_t yyscanner);
196 core_yyscan_t yyscanner);
199 core_yyscan_t yyscanner);
204 core_yyscan_t yyscanner);
206 core_yyscan_t yyscanner);
209 %}
211 %pure-parser
212 %expect 0
214 %locations
219 %union
220 {
221 core_YYSTYPE core_yystype;
222 /* these fields must match core_YYSTYPE: */
229 JoinType jtype;
230 DropBehavior dbehavior;
231 OnCommitAction oncommit;
234 ObjectType objtype;
237 FunctionParameterMode fun_param_mode;
264 SetQuantifier setquantifier;
266 MergeMatchKind mergematch;
271 ReturningOptionKind retoptionkind;
272 }
275 AlterEventTrigStmt AlterCollationStmt
276 AlterDatabaseStmt AlterDatabaseSetStmt AlterDomainStmt AlterEnumStmt
277 AlterFdwStmt AlterForeignServerStmt AlterGroupStmt
278 AlterObjectDependsStmt AlterObjectSchemaStmt AlterOwnerStmt
279 AlterOperatorStmt AlterTypeStmt AlterSeqStmt AlterSystemStmt AlterTableStmt
280 AlterTblSpcStmt AlterExtensionStmt AlterExtensionContentsStmt
281 AlterCompositeTypeStmt AlterUserMappingStmt
282 AlterRoleStmt AlterRoleSetStmt AlterPolicyStmt AlterStatsStmt
283 AlterDefaultPrivilegesStmt DefACLAction
284 AnalyzeStmt CallStmt ClosePortalStmt ClusterStmt CommentStmt
285 ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
286 CreateDomainStmt CreateExtensionStmt CreateGroupStmt CreateOpClassStmt
287 CreateOpFamilyStmt AlterOpFamilyStmt CreatePLangStmt
288 CreateSchemaStmt CreateSeqStmt CreateStmt CreateStatsStmt CreateTableSpaceStmt
289 CreateFdwStmt CreateForeignServerStmt CreateForeignTableStmt
290 CreateAssertionStmt CreateTransformStmt CreateTrigStmt CreateEventTrigStmt
291 CreateUserStmt CreateUserMappingStmt CreateRoleStmt CreatePolicyStmt
292 CreatedbStmt DeclareCursorStmt DefineStmt DeleteStmt DiscardStmt DoStmt
293 DropOpClassStmt DropOpFamilyStmt DropStmt
294 DropCastStmt DropRoleStmt
295 DropdbStmt DropTableSpaceStmt
296 DropTransformStmt
297 DropUserMappingStmt ExplainStmt FetchStmt
298 GrantStmt GrantRoleStmt ImportForeignSchemaStmt IndexStmt InsertStmt
299 ListenStmt LoadStmt LockStmt MergeStmt NotifyStmt ExplainableStmt PreparableStmt
300 CreateFunctionStmt AlterFunctionStmt ReindexStmt RemoveAggrStmt
301 RemoveFuncStmt RemoveOperStmt RenameStmt ReturnStmt RevokeStmt RevokeRoleStmt
302 RuleActionStmt RuleActionStmtOrEmpty RuleStmt
303 SecLabelStmt SelectStmt TransactionStmt TransactionStmtLegacy TruncateStmt
304 UnlistenStmt UpdateStmt VacuumStmt
305 VariableResetStmt VariableSetStmt VariableShowStmt
306 ViewStmt CheckPointStmt CreateConversionStmt
307 DeallocateStmt PrepareStmt ExecuteStmt
308 DropOwnedStmt ReassignOwnedStmt
309 AlterTSConfigurationStmt AlterTSDictionaryStmt
310 CreateMatViewStmt RefreshMatViewStmt CreateAmStmt
311 CreatePublicationStmt AlterPublicationStmt
312 CreateSubscriptionStmt AlterSubscriptionStmt DropSubscriptionStmt
315 simple_select values_clause
316 PLpgSQL_Expr PLAssignStmt
327 replica_identity partition_cmd index_partition_cmd
335 transaction_mode_list
336 create_extension_opt_list alter_extension_opt_list
338 transaction_mode_item
339 create_extension_opt_item alter_extension_opt_item
348 opt_grant_grant_option
349 opt_nowait opt_if_exists opt_with_data
350 opt_transaction_chain
382 access_method_clause attr_name
383 table_access_method_clause name cursor_name file_name
384 cluster_index_specification
387 opt_inline_handler opt_validator validator_clause
388 opt_collate
406 %type <list> function_with_argtypes_list aggregate_with_argtypes_list operator_with_argtypes_list
416 OptTableElementList TableElementList OptInherit definition
417 OptTypedTableElementList TypedTableElementList
418 reloptions opt_reloptions
419 OptWith opt_definition func_args func_args_list
420 func_args_with_defaults func_args_with_defaults_list
421 aggr_args aggr_args_list
422 func_as createfunc_opt_list opt_createfunc_opt_list alterfunc_opt_list
423 old_aggr_definition old_aggr_list
424 oper_argtypes RuleActionList RuleActionMulti
425 opt_column_list columnList opt_name_list
426 sort_clause opt_sort_clause sortby_list index_params
427 stats_params
428 opt_include opt_c_include index_including_params
429 name_list role_list from_clause from_list opt_array_bounds
430 qualified_name_list any_name any_name_list type_name_list
431 any_operator expr_list attrs
432 distinct_clause opt_distinct_clause
433 target_list opt_target_list insert_column_list set_target_list
434 merge_values_clause
435 set_clause_list set_clause
436 def_list operator_def_list indirection opt_indirection
437 reloption_list TriggerFuncArgs opclass_item_list opclass_drop_list
438 opclass_purpose opt_opfamily transaction_mode_list_or_empty
439 OptTableFuncElementList TableFuncElementList opt_type_modifiers
440 prep_type_clause
441 execute_param_clause using_clause
442 returning_with_clause returning_options
443 opt_enum_val_list enum_val_list table_func_column_list
444 create_generic_options alter_generic_options
445 relation_expr_list dostmt_opt_list
446 transform_element_list transform_type_list
447 TriggerTransitions TriggerReferencing
448 vacuum_relation_list opt_vacuum_relation_list
449 drop_option_list pub_obj_list
499 drop_type_name
502 offset_clause select_offset_value
503 select_fetch_first_value I_or_F_const
519 SetResetClause FunctionSetResetClause
521 %type <node> TableElement TypedTableElement ConstraintElem DomainConstraintElem TableFuncElement
525 a_expr b_expr c_expr AexprConst indirection_el opt_slice_bound
526 columnref in_expr having_clause func_table xmltable array_expr
527 OptWhereClause operator_def_arg
568 GenericType Numeric opt_float JsonType
569 Character ConstCharacter
570 CharacterWithLength CharacterWithoutLength
571 ConstDatetime ConstInterval
572 Bit ConstBit BitWithLength BitWithoutLength
634 opt_frame_clause frame_extent frame_bound
648 json_format_clause_opt
649 json_value_expr
650 json_returning_clause_opt
651 json_name_and_value
652 json_aggregate_func
653 json_argument
654 json_behavior
655 json_on_error_clause_opt
656 json_table
657 json_table_column_definition
658 json_table_column_path_clause_opt
660 json_value_expr_list
661 json_array_aggregate_order_by_clause_opt
662 json_arguments
663 json_behavior_clause_opt
664 json_passing_clause_opt
665 json_table_column_definition_list
668 json_predicate_type_constraint
669 json_quotes_clause_opt
670 json_wrapper_behavior
672 json_object_constructor_null_clause_opt
673 json_array_constructor_null_clause_opt
676 /*
677 * Non-keyword token types. These are hard-wired into the "flex" lexer.
678 * They must be listed first so that their numeric codes do not depend on
679 * the set of keywords. PL/pgSQL depends on this so that it can share the
680 * same lexer. If you add/change tokens here, fix PL/pgSQL to match!
681 *
682 * UIDENT and USCONST are reduced to IDENT and SCONST in parser.c, so that
683 * they need no productions here; but we must assign token codes to them.
684 *
685 * DOT_DOT is unused in the core SQL grammar, and so will always provoke
686 * parse errors. It is needed by PL/pgSQL.
687 */
690 %token TYPECAST DOT_DOT COLON_EQUALS EQUALS_GREATER
691 %token LESS_EQUALS GREATER_EQUALS NOT_EQUALS
693 /*
694 * If you want to make any keyword changes, update the keyword table in
695 * src/include/parser/kwlist.h and add new keywords to the appropriate one
696 * of the reserved-or-not-so-reserved keyword lists, below; search
697 * this file for "Keyword category lists".
698 */
700 /* ordinary key words in alphabetical order */
702 AGGREGATE ALL ALSO ALTER ALWAYS ANALYSE ANALYZE AND ANY ARRAY AS ASC
703 ASENSITIVE ASSERTION ASSIGNMENT ASYMMETRIC ATOMIC AT ATTACH ATTRIBUTE AUTHORIZATION
705 BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
706 BOOLEAN_P BOTH BREADTH BY
708 CACHE CALL CALLED CASCADE CASCADED CASE CAST CATALOG_P CHAIN CHAR_P
709 CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
710 CLUSTER COALESCE COLLATE COLLATION COLUMN COLUMNS COMMENT COMMENTS COMMIT
711 COMMITTED COMPRESSION CONCURRENTLY CONDITIONAL CONFIGURATION CONFLICT
712 CONNECTION CONSTRAINT CONSTRAINTS CONTENT_P CONTINUE_P CONVERSION_P COPY
713 COST CREATE CROSS CSV CUBE CURRENT_P
714 CURRENT_CATALOG CURRENT_DATE CURRENT_ROLE CURRENT_SCHEMA
715 CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
717 DATA_P DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
718 DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS DEPENDS DEPTH DESC
719 DETACH DICTIONARY DISABLE_P DISCARD DISTINCT DO DOCUMENT_P DOMAIN_P
720 DOUBLE_P DROP
722 EACH ELSE EMPTY_P ENABLE_P ENCODING ENCRYPTED END_P ENFORCED ENUM_P ERROR_P
723 ESCAPE EVENT EXCEPT EXCLUDE EXCLUDING EXCLUSIVE EXECUTE EXISTS EXPLAIN
724 EXPRESSION EXTENSION EXTERNAL EXTRACT
726 FALSE_P FAMILY FETCH FILTER FINALIZE FIRST_P FLOAT_P FOLLOWING FOR
727 FORCE FOREIGN FORMAT FORWARD FREEZE FROM FULL FUNCTION FUNCTIONS
729 GENERATED GLOBAL GRANT GRANTED GREATEST GROUP_P GROUPING GROUPS
731 HANDLER HAVING HEADER_P HOLD HOUR_P
733 IDENTITY_P IF_P ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IMPORT_P IN_P INCLUDE
734 INCLUDING INCREMENT INDENT INDEX INDEXES INHERIT INHERITS INITIALLY INLINE_P
735 INNER_P INOUT INPUT_P INSENSITIVE INSERT INSTEAD INT_P INTEGER
736 INTERSECT INTERVAL INTO INVOKER IS ISNULL ISOLATION
738 JOIN JSON JSON_ARRAY JSON_ARRAYAGG JSON_EXISTS JSON_OBJECT JSON_OBJECTAGG
739 JSON_QUERY JSON_SCALAR JSON_SERIALIZE JSON_TABLE JSON_VALUE
741 KEEP KEY KEYS
743 LABEL LANGUAGE LARGE_P LAST_P LATERAL_P
744 LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL
745 LOCALTIME LOCALTIMESTAMP LOCATION LOCK_P LOCKED LOGGED
747 MAPPING MATCH MATCHED MATERIALIZED MAXVALUE MERGE MERGE_ACTION METHOD
748 MINUTE_P MINVALUE MODE MONTH_P MOVE
750 NAME_P NAMES NATIONAL NATURAL NCHAR NESTED NEW NEXT NFC NFD NFKC NFKD NO
751 NONE NORMALIZE NORMALIZED
752 NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF
753 NULLS_P NUMERIC
755 OBJECT_P OF OFF OFFSET OIDS OLD OMIT ON ONLY OPERATOR OPTION OPTIONS OR
756 ORDER ORDINALITY OTHERS OUT_P OUTER_P
757 OVER OVERLAPS OVERLAY OVERRIDING OWNED OWNER
759 PARALLEL PARAMETER PARSER PARTIAL PARTITION PASSING PASSWORD PATH
760 PERIOD PLACING PLAN PLANS POLICY
761 POSITION PRECEDING PRECISION PRESERVE PREPARE PREPARED PRIMARY
762 PRIOR PRIVILEGES PROCEDURAL PROCEDURE PROCEDURES PROGRAM PUBLICATION
764 QUOTE QUOTES
766 RANGE READ REAL REASSIGN RECURSIVE REF_P REFERENCES REFERENCING
767 REFRESH REINDEX RELATIVE_P RELEASE RENAME REPEATABLE REPLACE REPLICA
768 RESET RESTART RESTRICT RETURN RETURNING RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
769 ROUTINE ROUTINES ROW ROWS RULE
771 SAVEPOINT SCALAR SCHEMA SCHEMAS SCROLL SEARCH SECOND_P SECURITY SELECT
772 SEQUENCE SEQUENCES
773 SERIALIZABLE SERVER SESSION SESSION_USER SET SETS SETOF SHARE SHOW
774 SIMILAR SIMPLE SKIP SMALLINT SNAPSHOT SOME SOURCE SQL_P STABLE STANDALONE_P
775 START STATEMENT STATISTICS STDIN STDOUT STORAGE STORED STRICT_P STRING_P STRIP_P
776 SUBSCRIPTION SUBSTRING SUPPORT SYMMETRIC SYSID SYSTEM_P SYSTEM_USER
778 TABLE TABLES TABLESAMPLE TABLESPACE TARGET TEMP TEMPLATE TEMPORARY TEXT_P THEN
779 TIES TIME TIMESTAMP TO TRAILING TRANSACTION TRANSFORM
780 TREAT TRIGGER TRIM TRUE_P
781 TRUNCATE TRUSTED TYPE_P TYPES_P
783 UESCAPE UNBOUNDED UNCONDITIONAL UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN
784 UNLISTEN UNLOGGED UNTIL UPDATE USER USING
786 VACUUM VALID VALIDATE VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
787 VERBOSE VERSION_P VIEW VIEWS VOLATILE
789 WHEN WHERE WHITESPACE_P WINDOW WITH WITHIN WITHOUT WORK WRAPPER WRITE
791 XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLEXISTS XMLFOREST XMLNAMESPACES
792 XMLPARSE XMLPI XMLROOT XMLSERIALIZE XMLTABLE
794 YEAR_P YES_P
796 ZONE
798 /*
799 * The grammar thinks these are keywords, but they are not in the kwlist.h
800 * list and so can never be entered directly. The filter in parser.c
801 * creates these tokens when required (based on looking one token ahead).
802 *
803 * NOT_LA exists so that productions such as NOT LIKE can be given the same
804 * precedence as LIKE; otherwise they'd effectively have the same precedence
805 * as NOT, at least with respect to their left-hand subexpression.
806 * FORMAT_LA, NULLS_LA, WITH_LA, and WITHOUT_LA are needed to make the grammar
807 * LALR(1).
808 */
809 %token FORMAT_LA NOT_LA NULLS_LA WITH_LA WITHOUT_LA
811 /*
812 * The grammar likewise thinks these tokens are keywords, but they are never
813 * generated by the scanner. Rather, they can be injected by parser.c as
814 * the initial token of the string (using the lookahead-token mechanism
815 * implemented there). This provides a way to tell the grammar to parse
816 * something other than the usual list of SQL commands.
817 */
818 %token MODE_TYPE_NAME
819 %token MODE_PLPGSQL_EXPR
820 %token MODE_PLPGSQL_ASSIGN1
821 %token MODE_PLPGSQL_ASSIGN2
822 %token MODE_PLPGSQL_ASSIGN3
825 /* Precedence: lowest to highest */
826 %left UNION EXCEPT
827 %left INTERSECT
828 %left OR
829 %left AND
830 %right NOT
831 %nonassoc IS ISNULL NOTNULL /* IS sets precedence for IS NULL, etc */
833 %nonassoc BETWEEN IN_P LIKE ILIKE SIMILAR NOT_LA
834 %nonassoc ESCAPE /* ESCAPE must be just above LIKE/ILIKE/SIMILAR */
836 /*
837 * Sometimes it is necessary to assign precedence to keywords that are not
838 * really part of the operator hierarchy, in order to resolve grammar
839 * ambiguities. It's best to avoid doing so whenever possible, because such
840 * assignments have global effect and may hide ambiguities besides the one
841 * you intended to solve. (Attaching a precedence to a single rule with
842 * %prec is far safer and should be preferred.) If you must give precedence
843 * to a new keyword, try very hard to give it the same precedence as IDENT.
844 * If the keyword has IDENT's precedence then it clearly acts the same as
845 * non-keywords and other similar keywords, thus reducing the risk of
846 * unexpected precedence effects.
847 *
848 * We used to need to assign IDENT an explicit precedence just less than Op,
849 * to support target_el without AS. While that's not really necessary since
850 * we removed postfix operators, we continue to do so because it provides a
851 * reference point for a precedence level that we can assign to other
852 * keywords that lack a natural precedence level.
853 *
854 * We need to do this for PARTITION, RANGE, ROWS, and GROUPS to support
855 * opt_existing_window_name (see comment there).
856 *
857 * The frame_bound productions UNBOUNDED PRECEDING and UNBOUNDED FOLLOWING
858 * are even messier: since UNBOUNDED is an unreserved keyword (per spec!),
859 * there is no principled way to distinguish these from the productions
860 * a_expr PRECEDING/FOLLOWING. We hack this up by giving UNBOUNDED slightly
861 * lower precedence than PRECEDING and FOLLOWING. At present this doesn't
862 * appear to cause UNBOUNDED to be treated differently from other unreserved
863 * keywords anywhere else in the grammar, but it's definitely risky. We can
864 * blame any funny behavior of UNBOUNDED on the SQL standard, though.
865 *
866 * To support CUBE and ROLLUP in GROUP BY without reserving them, we give them
867 * an explicit priority lower than '(', so that a rule with CUBE '(' will shift
868 * rather than reducing a conflicting rule that takes CUBE as a function name.
869 * Using the same precedence as IDENT seems right for the reasons given above.
870 *
871 * SET is likewise assigned the same precedence as IDENT, to support the
872 * relation_expr_opt_alias production (see comment there).
873 *
874 * KEYS, OBJECT_P, SCALAR, VALUE_P, WITH, and WITHOUT are similarly assigned
875 * the same precedence as IDENT. This allows resolving conflicts in the
876 * json_predicate_type_constraint and json_key_uniqueness_constraint_opt
877 * productions (see comments there).
878 *
879 * Like the UNBOUNDED PRECEDING/FOLLOWING case, NESTED is assigned a lower
880 * precedence than PATH to fix ambiguity in the json_table production.
881 */
882 %nonassoc UNBOUNDED NESTED /* ideally would have same precedence as IDENT */
883 %nonassoc IDENT PARTITION RANGE ROWS GROUPS PRECEDING FOLLOWING CUBE ROLLUP
884 SET KEYS OBJECT_P SCALAR VALUE_P WITH WITHOUT PATH
885 %left Op OPERATOR /* multi-character ops and user-defined operators */
888 %left '^'
889 /* Unary Operators */
890 %left AT /* sets precedence for AT TIME ZONE, AT LOCAL */
891 %left COLLATE
892 %right UMINUS
895 %left TYPECAST
896 %left '.'
897 /*
898 * These might seem to be low-precedence, but actually they are not part
899 * of the arithmetic hierarchy at all in their use as JOIN operators.
900 * We make them high-precedence to support their use as function names.
901 * They wouldn't be given a precedence at all, were it not that we need
902 * left-associativity among the JOIN rules themselves.
903 */
904 %left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
906 %%
908 /*
909 * The target production for the whole parse.
910 *
911 * Ordinarily we parse a list of statements, but if we see one of the
912 * special MODE_XXX symbols as first token, we parse something else.
913 * The options here correspond to enum RawParseMode, which see for details.
914 */
915 parse_toplevel:
916 stmtmulti
917 {
920 }
921 | MODE_TYPE_NAME Typename
922 {
924 }
925 | MODE_PLPGSQL_EXPR PLpgSQL_Expr
926 {
929 }
930 | MODE_PLPGSQL_ASSIGN1 PLAssignStmt
931 {
937 }
938 | MODE_PLPGSQL_ASSIGN2 PLAssignStmt
939 {
945 }
946 | MODE_PLPGSQL_ASSIGN3 PLAssignStmt
947 {
953 }
954 ;
956 /*
957 * At top level, we wrap each stmt with a RawStmt node carrying start location
958 * and length of the stmt's text.
959 * We also take care to discard empty statements entirely (which among other
960 * things dodges the problem of assigning them a location).
961 */
963 {
965 {
966 /* update length of previous stmt */
968 }
971 else
973 }
974 | toplevel_stmt
975 {
978 else
980 }
981 ;
983 /*
984 * toplevel_stmt includes BEGIN and END. stmt does not include them, because
985 * those words have different meanings in function bodies.
986 */
987 toplevel_stmt:
988 stmt
989 | TransactionStmtLegacy
990 ;
992 stmt:
993 AlterEventTrigStmt
994 | AlterCollationStmt
995 | AlterDatabaseStmt
996 | AlterDatabaseSetStmt
997 | AlterDefaultPrivilegesStmt
998 | AlterDomainStmt
999 | AlterEnumStmt
1000 | AlterExtensionStmt
1001 | AlterExtensionContentsStmt
1002 | AlterFdwStmt
1003 | AlterForeignServerStmt
1004 | AlterFunctionStmt
1005 | AlterGroupStmt
1006 | AlterObjectDependsStmt
1007 | AlterObjectSchemaStmt
1008 | AlterOwnerStmt
1009 | AlterOperatorStmt
1010 | AlterTypeStmt
1011 | AlterPolicyStmt
1012 | AlterSeqStmt
1013 | AlterSystemStmt
1014 | AlterTableStmt
1015 | AlterTblSpcStmt
1016 | AlterCompositeTypeStmt
1017 | AlterPublicationStmt
1018 | AlterRoleSetStmt
1019 | AlterRoleStmt
1020 | AlterSubscriptionStmt
1021 | AlterStatsStmt
1022 | AlterTSConfigurationStmt
1023 | AlterTSDictionaryStmt
1024 | AlterUserMappingStmt
1025 | AnalyzeStmt
1026 | CallStmt
1027 | CheckPointStmt
1028 | ClosePortalStmt
1029 | ClusterStmt
1030 | CommentStmt
1031 | ConstraintsSetStmt
1032 | CopyStmt
1033 | CreateAmStmt
1034 | CreateAsStmt
1035 | CreateAssertionStmt
1036 | CreateCastStmt
1037 | CreateConversionStmt
1038 | CreateDomainStmt
1039 | CreateExtensionStmt
1040 | CreateFdwStmt
1041 | CreateForeignServerStmt
1042 | CreateForeignTableStmt
1043 | CreateFunctionStmt
1044 | CreateGroupStmt
1045 | CreateMatViewStmt
1046 | CreateOpClassStmt
1047 | CreateOpFamilyStmt
1048 | CreatePublicationStmt
1049 | AlterOpFamilyStmt
1050 | CreatePolicyStmt
1051 | CreatePLangStmt
1052 | CreateSchemaStmt
1053 | CreateSeqStmt
1054 | CreateStmt
1055 | CreateSubscriptionStmt
1056 | CreateStatsStmt
1057 | CreateTableSpaceStmt
1058 | CreateTransformStmt
1059 | CreateTrigStmt
1060 | CreateEventTrigStmt
1061 | CreateRoleStmt
1062 | CreateUserStmt
1063 | CreateUserMappingStmt
1064 | CreatedbStmt
1065 | DeallocateStmt
1066 | DeclareCursorStmt
1067 | DefineStmt
1068 | DeleteStmt
1069 | DiscardStmt
1070 | DoStmt
1071 | DropCastStmt
1072 | DropOpClassStmt
1073 | DropOpFamilyStmt
1074 | DropOwnedStmt
1075 | DropStmt
1076 | DropSubscriptionStmt
1077 | DropTableSpaceStmt
1078 | DropTransformStmt
1079 | DropRoleStmt
1080 | DropUserMappingStmt
1081 | DropdbStmt
1082 | ExecuteStmt
1083 | ExplainStmt
1084 | FetchStmt
1085 | GrantStmt
1086 | GrantRoleStmt
1087 | ImportForeignSchemaStmt
1088 | IndexStmt
1089 | InsertStmt
1090 | ListenStmt
1091 | RefreshMatViewStmt
1092 | LoadStmt
1093 | LockStmt
1094 | MergeStmt
1095 | NotifyStmt
1096 | PrepareStmt
1097 | ReassignOwnedStmt
1098 | ReindexStmt
1099 | RemoveAggrStmt
1100 | RemoveFuncStmt
1101 | RemoveOperStmt
1102 | RenameStmt
1103 | RevokeStmt
1104 | RevokeRoleStmt
1105 | RuleStmt
1106 | SecLabelStmt
1107 | SelectStmt
1108 | TransactionStmt
1109 | TruncateStmt
1110 | UnlistenStmt
1111 | UpdateStmt
1112 | VacuumStmt
1113 | VariableResetStmt
1114 | VariableSetStmt
1115 | VariableShowStmt
1116 | ViewStmt
1117 | /*EMPTY*/
1119 ;
1121 /*
1122 * Generic supporting productions for DDL
1123 */
1124 opt_single_name:
1127 ;
1129 opt_qualified_name:
1132 ;
1134 opt_concurrently:
1137 ;
1139 opt_drop_behavior:
1143 ;
1145 /*****************************************************************************
1146 *
1147 * CALL statement
1148 *
1149 *****************************************************************************/
1151 CallStmt: CALL func_application
1152 {
1157 }
1158 ;
1160 /*****************************************************************************
1161 *
1162 * Create a new Postgres DBMS role
1163 *
1164 *****************************************************************************/
1166 CreateRoleStmt:
1167 CREATE ROLE RoleId opt_with OptRoleList
1168 {
1175 }
1176 ;
1179 opt_with: WITH
1180 | WITH_LA
1181 | /*EMPTY*/
1182 ;
1184 /*
1185 * Options for CREATE ROLE and ALTER ROLE (also used by CREATE/ALTER USER
1186 * for backwards compatibility). Note: the only option required by SQL99
1187 * is "WITH ADMIN name".
1188 */
1189 OptRoleList:
1192 ;
1194 AlterOptRoleList:
1197 ;
1199 AlterOptRoleElem:
1200 PASSWORD Sconst
1201 {
1204 }
1205 | PASSWORD NULL_P
1206 {
1208 }
1209 | ENCRYPTED PASSWORD Sconst
1210 {
1211 /*
1212 * These days, passwords are always stored in encrypted
1213 * form, so there is no difference between PASSWORD and
1214 * ENCRYPTED PASSWORD.
1215 */
1218 }
1219 | UNENCRYPTED PASSWORD Sconst
1220 {
1226 }
1227 | INHERIT
1228 {
1230 }
1231 | CONNECTION LIMIT SignedIconst
1232 {
1234 }
1235 | VALID UNTIL Sconst
1236 {
1238 }
1239 /* Supported but not documented for roles, for use by ALTER GROUP. */
1240 | USER role_list
1241 {
1243 }
1244 | IDENT
1245 {
1246 /*
1247 * We handle identifiers that aren't parser keywords with
1248 * the following special-case codes, to avoid bloating the
1249 * size of the main parser.
1250 */
1276 {
1277 /*
1278 * Note that INHERIT is a keyword, so it's handled by main parser, but
1279 * NOINHERIT is handled here.
1280 */
1282 }
1283 else
1288 }
1289 ;
1291 CreateOptRoleElem:
1293 /* The following are not supported by ALTER ROLE/USER/GROUP */
1294 | SYSID Iconst
1295 {
1297 }
1298 | ADMIN role_list
1299 {
1301 }
1302 | ROLE role_list
1303 {
1305 }
1306 | IN_P ROLE role_list
1307 {
1309 }
1310 | IN_P GROUP_P role_list
1311 {
1313 }
1314 ;
1317 /*****************************************************************************
1318 *
1319 * Create a new Postgres DBMS user (role with implied login ability)
1320 *
1321 *****************************************************************************/
1323 CreateUserStmt:
1324 CREATE USER RoleId opt_with OptRoleList
1325 {
1332 }
1333 ;
1336 /*****************************************************************************
1337 *
1338 * Alter a postgresql DBMS role
1339 *
1340 *****************************************************************************/
1342 AlterRoleStmt:
1343 ALTER ROLE RoleSpec opt_with AlterOptRoleList
1344 {
1351 }
1352 | ALTER USER RoleSpec opt_with AlterOptRoleList
1353 {
1360 }
1361 ;
1363 opt_in_database:
1366 ;
1368 AlterRoleSetStmt:
1369 ALTER ROLE RoleSpec opt_in_database SetResetClause
1370 {
1377 }
1378 | ALTER ROLE ALL opt_in_database SetResetClause
1379 {
1386 }
1387 | ALTER USER RoleSpec opt_in_database SetResetClause
1388 {
1395 }
1396 | ALTER USER ALL opt_in_database SetResetClause
1397 {
1404 }
1405 ;
1408 /*****************************************************************************
1409 *
1410 * Drop a postgresql DBMS role
1411 *
1412 * XXX Ideally this would have CASCADE/RESTRICT options, but a role
1413 * might own objects in multiple databases, and there is presently no way to
1414 * implement cascading to other databases. So we always behave as RESTRICT.
1415 *****************************************************************************/
1417 DropRoleStmt:
1418 DROP ROLE role_list
1419 {
1425 }
1426 | DROP ROLE IF_P EXISTS role_list
1427 {
1433 }
1434 | DROP USER role_list
1435 {
1441 }
1442 | DROP USER IF_P EXISTS role_list
1443 {
1449 }
1450 | DROP GROUP_P role_list
1451 {
1457 }
1458 | DROP GROUP_P IF_P EXISTS role_list
1459 {
1465 }
1466 ;
1469 /*****************************************************************************
1470 *
1471 * Create a postgresql group (role without login ability)
1472 *
1473 *****************************************************************************/
1475 CreateGroupStmt:
1476 CREATE GROUP_P RoleId opt_with OptRoleList
1477 {
1484 }
1485 ;
1488 /*****************************************************************************
1489 *
1490 * Alter a postgresql group
1491 *
1492 *****************************************************************************/
1494 AlterGroupStmt:
1495 ALTER GROUP_P RoleSpec add_drop USER role_list
1496 {
1504 }
1505 ;
1509 ;
1512 /*****************************************************************************
1513 *
1514 * Manipulate a schema
1515 *
1516 *****************************************************************************/
1518 CreateSchemaStmt:
1519 CREATE SCHEMA opt_single_name AUTHORIZATION RoleSpec OptSchemaEltList
1520 {
1523 /* One can omit the schema name or the authorization id. */
1529 }
1530 | CREATE SCHEMA ColId OptSchemaEltList
1531 {
1534 /* ...but not both */
1540 }
1541 | CREATE SCHEMA IF_P NOT EXISTS opt_single_name AUTHORIZATION RoleSpec OptSchemaEltList
1542 {
1545 /* schema name can be omitted here, too */
1556 }
1557 | CREATE SCHEMA IF_P NOT EXISTS ColId OptSchemaEltList
1558 {
1561 /* ...but not here */
1572 }
1573 ;
1575 OptSchemaEltList:
1576 OptSchemaEltList schema_stmt
1577 {
1579 }
1580 | /* EMPTY */
1582 ;
1584 /*
1585 * schema_stmt are the ones that can show up inside a CREATE SCHEMA
1586 * statement (in addition to by themselves).
1587 */
1588 schema_stmt:
1589 CreateStmt
1590 | IndexStmt
1591 | CreateSeqStmt
1592 | CreateTrigStmt
1593 | GrantStmt
1594 | ViewStmt
1595 ;
1598 /*****************************************************************************
1599 *
1600 * Set PG internal variable
1601 * SET name TO 'var_value'
1602 * Include SQL syntax (thomas 1997-10-22):
1603 * SET TIME ZONE 'var_value'
1604 *
1605 *****************************************************************************/
1607 VariableSetStmt:
1608 SET set_rest
1609 {
1614 }
1615 | SET LOCAL set_rest
1616 {
1621 }
1622 | SET SESSION set_rest
1623 {
1628 }
1629 ;
1631 set_rest:
1632 TRANSACTION transaction_mode_list
1633 {
1642 }
1643 | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
1644 {
1653 }
1654 | set_rest_more
1655 ;
1657 generic_set:
1658 var_name TO var_list
1659 {
1667 }
1668 | var_name '=' var_list
1669 {
1677 }
1678 | var_name TO DEFAULT
1679 {
1686 }
1687 | var_name '=' DEFAULT
1688 {
1695 }
1696 ;
1700 | var_name FROM CURRENT_P
1701 {
1708 }
1709 /* Special syntaxes mandated by SQL standard: */
1710 | TIME ZONE zone_value
1711 {
1720 else
1723 }
1724 | CATALOG_P Sconst
1725 {
1731 }
1732 | SCHEMA Sconst
1733 {
1741 }
1742 | NAMES opt_encoding
1743 {
1751 else
1754 }
1755 | ROLE NonReservedWord_or_Sconst
1756 {
1764 }
1765 | SESSION AUTHORIZATION NonReservedWord_or_Sconst
1766 {
1774 }
1775 | SESSION AUTHORIZATION DEFAULT
1776 {
1783 }
1784 | XML_P OPTION document_or_content
1785 {
1794 }
1795 /* Special syntaxes invented by PostgreSQL: */
1796 | TRANSACTION SNAPSHOT Sconst
1797 {
1805 }
1806 ;
1809 | var_name '.' ColId
1811 ;
1815 ;
1817 var_value: opt_boolean_or_string
1819 | NumericOnly
1821 ;
1827 ;
1829 opt_boolean_or_string:
1833 /*
1834 * OFF is also accepted as a boolean value, but is handled by
1835 * the NonReservedWord rule. The action for booleans and strings
1836 * is the same, so we don't need to distinguish them here.
1837 */
1839 ;
1841 /* Timezone values can be:
1842 * - a string such as 'pst8pdt'
1843 * - an identifier such as "pst8pdt"
1844 * - an integer or floating point number
1845 * - a time interval per SQL99
1846 * ColId gives reduce/reduce errors against ConstInterval and LOCAL,
1847 * so use IDENT (meaning we reject anything that is a key word).
1848 */
1849 zone_value:
1850 Sconst
1851 {
1853 }
1854 | IDENT
1855 {
1857 }
1858 | ConstInterval Sconst opt_interval
1859 {
1863 {
1871 }
1874 }
1876 {
1882 }
1886 ;
1888 opt_encoding:
1892 ;
1894 NonReservedWord_or_Sconst:
1897 ;
1899 VariableResetStmt:
1901 ;
1903 reset_rest:
1905 | TIME ZONE
1906 {
1913 }
1914 | TRANSACTION ISOLATION LEVEL
1915 {
1922 }
1923 | SESSION AUTHORIZATION
1924 {
1931 }
1932 ;
1934 generic_reset:
1935 var_name
1936 {
1943 }
1944 | ALL
1945 {
1951 }
1952 ;
1954 /* SetResetClause allows SET or RESET without LOCAL */
1955 SetResetClause:
1958 ;
1960 /* SetResetClause allows SET or RESET without LOCAL */
1961 FunctionSetResetClause:
1964 ;
1967 VariableShowStmt:
1968 SHOW var_name
1969 {
1974 }
1975 | SHOW TIME ZONE
1976 {
1981 }
1982 | SHOW TRANSACTION ISOLATION LEVEL
1983 {
1988 }
1989 | SHOW SESSION AUTHORIZATION
1990 {
1995 }
1996 | SHOW ALL
1997 {
2002 }
2003 ;
2006 ConstraintsSetStmt:
2007 SET CONSTRAINTS constraints_set_list constraints_set_mode
2008 {
2014 }
2015 ;
2017 constraints_set_list:
2020 ;
2022 constraints_set_mode:
2025 ;
2028 /*
2029 * Checkpoint statement
2030 */
2031 CheckPointStmt:
2032 CHECKPOINT
2033 {
2037 }
2038 ;
2041 /*****************************************************************************
2042 *
2043 * DISCARD { ALL | TEMP | PLANS | SEQUENCES }
2044 *
2045 *****************************************************************************/
2047 DiscardStmt:
2048 DISCARD ALL
2049 {
2054 }
2055 | DISCARD TEMP
2056 {
2061 }
2062 | DISCARD TEMPORARY
2063 {
2068 }
2069 | DISCARD PLANS
2070 {
2075 }
2076 | DISCARD SEQUENCES
2077 {
2082 }
2084 ;
2087 /*****************************************************************************
2088 *
2089 * ALTER [ TABLE | INDEX | SEQUENCE | VIEW | MATERIALIZED VIEW | FOREIGN TABLE ] variations
2090 *
2091 * Note: we accept all subcommands for each of the variants, and sort
2092 * out what's really legal at execution time.
2093 *****************************************************************************/
2095 AlterTableStmt:
2096 ALTER TABLE relation_expr alter_table_cmds
2097 {
2105 }
2106 | ALTER TABLE IF_P EXISTS relation_expr alter_table_cmds
2107 {
2115 }
2116 | ALTER TABLE relation_expr partition_cmd
2117 {
2125 }
2126 | ALTER TABLE IF_P EXISTS relation_expr partition_cmd
2127 {
2135 }
2136 | ALTER TABLE ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
2137 {
2147 }
2148 | ALTER TABLE ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
2149 {
2159 }
2160 | ALTER INDEX qualified_name alter_table_cmds
2161 {
2169 }
2170 | ALTER INDEX IF_P EXISTS qualified_name alter_table_cmds
2171 {
2179 }
2180 | ALTER INDEX qualified_name index_partition_cmd
2181 {
2189 }
2190 | ALTER INDEX ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
2191 {
2201 }
2202 | ALTER INDEX ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
2203 {
2213 }
2214 | ALTER SEQUENCE qualified_name alter_table_cmds
2215 {
2223 }
2224 | ALTER SEQUENCE IF_P EXISTS qualified_name alter_table_cmds
2225 {
2233 }
2234 | ALTER VIEW qualified_name alter_table_cmds
2235 {
2243 }
2244 | ALTER VIEW IF_P EXISTS qualified_name alter_table_cmds
2245 {
2253 }
2254 | ALTER MATERIALIZED VIEW qualified_name alter_table_cmds
2255 {
2263 }
2264 | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name alter_table_cmds
2265 {
2273 }
2274 | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name SET TABLESPACE name opt_nowait
2275 {
2285 }
2286 | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name OWNED BY role_list SET TABLESPACE name opt_nowait
2287 {
2297 }
2298 | ALTER FOREIGN TABLE relation_expr alter_table_cmds
2299 {
2307 }
2308 | ALTER FOREIGN TABLE IF_P EXISTS relation_expr alter_table_cmds
2309 {
2317 }
2318 ;
2320 alter_table_cmds:
2323 ;
2325 partition_cmd:
2326 /* ALTER TABLE <name> ATTACH PARTITION <table_name> FOR VALUES */
2327 ATTACH PARTITION qualified_name PartitionBoundSpec
2328 {
2339 }
2340 /* ALTER TABLE <name> DETACH PARTITION <partition_name> [CONCURRENTLY] */
2341 | DETACH PARTITION qualified_name opt_concurrently
2342 {
2353 }
2354 | DETACH PARTITION qualified_name FINALIZE
2355 {
2365 }
2366 ;
2368 index_partition_cmd:
2369 /* ALTER INDEX <name> ATTACH PARTITION <index_name> */
2370 ATTACH PARTITION qualified_name
2371 {
2382 }
2383 ;
2385 alter_table_cmd:
2386 /* ALTER TABLE <name> ADD <coldef> */
2387 ADD_P columnDef
2388 {
2395 }
2396 /* ALTER TABLE <name> ADD IF NOT EXISTS <coldef> */
2397 | ADD_P IF_P NOT EXISTS columnDef
2398 {
2405 }
2406 /* ALTER TABLE <name> ADD COLUMN <coldef> */
2407 | ADD_P COLUMN columnDef
2408 {
2415 }
2416 /* ALTER TABLE <name> ADD COLUMN IF NOT EXISTS <coldef> */
2417 | ADD_P COLUMN IF_P NOT EXISTS columnDef
2418 {
2425 }
2426 /* ALTER TABLE <name> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
2427 | ALTER opt_column ColId alter_column_default
2428 {
2435 }
2436 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP NOT NULL */
2437 | ALTER opt_column ColId DROP NOT NULL_P
2438 {
2444 }
2445 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET NOT NULL */
2446 | ALTER opt_column ColId SET NOT NULL_P
2447 {
2453 }
2454 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET EXPRESSION AS <expr> */
2456 {
2463 }
2464 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP EXPRESSION */
2465 | ALTER opt_column ColId DROP EXPRESSION
2466 {
2472 }
2473 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP EXPRESSION IF EXISTS */
2474 | ALTER opt_column ColId DROP EXPRESSION IF_P EXISTS
2475 {
2482 }
2483 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET STATISTICS */
2484 | ALTER opt_column ColId SET STATISTICS set_statistics_value
2485 {
2492 }
2493 /* ALTER TABLE <name> ALTER [COLUMN] <colnum> SET STATISTICS */
2494 | ALTER opt_column Iconst SET STATISTICS set_statistics_value
2495 {
2508 }
2509 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET ( column_parameter = value [, ... ] ) */
2510 | ALTER opt_column ColId SET reloptions
2511 {
2518 }
2519 /* ALTER TABLE <name> ALTER [COLUMN] <colname> RESET ( column_parameter [, ... ] ) */
2520 | ALTER opt_column ColId RESET reloptions
2521 {
2528 }
2529 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
2530 | ALTER opt_column ColId SET column_storage
2531 {
2538 }
2539 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET COMPRESSION <cm> */
2540 | ALTER opt_column ColId SET column_compression
2541 {
2548 }
2549 /* ALTER TABLE <name> ALTER [COLUMN] <colname> ADD GENERATED ... AS IDENTITY ... */
2550 | ALTER opt_column ColId ADD_P GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
2551 {
2565 }
2566 /* ALTER TABLE <name> ALTER [COLUMN] <colname> SET <sequence options>/RESET */
2567 | ALTER opt_column ColId alter_identity_column_option_list
2568 {
2575 }
2576 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP IDENTITY */
2577 | ALTER opt_column ColId DROP IDENTITY_P
2578 {
2585 }
2586 /* ALTER TABLE <name> ALTER [COLUMN] <colname> DROP IDENTITY IF EXISTS */
2587 | ALTER opt_column ColId DROP IDENTITY_P IF_P EXISTS
2588 {
2595 }
2596 /* ALTER TABLE <name> DROP [COLUMN] IF EXISTS <colname> [RESTRICT|CASCADE] */
2597 | DROP opt_column IF_P EXISTS ColId opt_drop_behavior
2598 {
2606 }
2607 /* ALTER TABLE <name> DROP [COLUMN] <colname> [RESTRICT|CASCADE] */
2608 | DROP opt_column ColId opt_drop_behavior
2609 {
2617 }
2618 /*
2619 * ALTER TABLE <name> ALTER [COLUMN] <colname> [SET DATA] TYPE <typename>
2620 * [ USING <expression> ]
2621 */
2622 | ALTER opt_column ColId opt_set_data TYPE_P Typename opt_collate_clause alter_using
2623 {
2630 /* We only use these fields of the ColumnDef node */
2636 }
2637 /* ALTER FOREIGN TABLE <name> ALTER [COLUMN] <colname> OPTIONS */
2638 | ALTER opt_column ColId alter_generic_options
2639 {
2646 }
2647 /* ALTER TABLE <name> ADD CONSTRAINT ... */
2648 | ADD_P TableConstraint
2649 {
2655 }
2656 /* ALTER TABLE <name> ALTER CONSTRAINT ... */
2657 | ALTER CONSTRAINT name ConstraintAttributeSpec
2658 {
2671 }
2672 /* ALTER TABLE <name> VALIDATE CONSTRAINT ... */
2673 | VALIDATE CONSTRAINT name
2674 {
2680 }
2681 /* ALTER TABLE <name> DROP CONSTRAINT IF EXISTS <name> [RESTRICT|CASCADE] */
2682 | DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
2683 {
2691 }
2692 /* ALTER TABLE <name> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
2693 | DROP CONSTRAINT name opt_drop_behavior
2694 {
2702 }
2703 /* ALTER TABLE <name> SET WITHOUT OIDS, for backward compat */
2704 | SET WITHOUT OIDS
2705 {
2710 }
2711 /* ALTER TABLE <name> CLUSTER ON <indexname> */
2712 | CLUSTER ON name
2713 {
2719 }
2720 /* ALTER TABLE <name> SET WITHOUT CLUSTER */
2721 | SET WITHOUT CLUSTER
2722 {
2728 }
2729 /* ALTER TABLE <name> SET LOGGED */
2730 | SET LOGGED
2731 {
2736 }
2737 /* ALTER TABLE <name> SET UNLOGGED */
2738 | SET UNLOGGED
2739 {
2744 }
2745 /* ALTER TABLE <name> ENABLE TRIGGER <trig> */
2746 | ENABLE_P TRIGGER name
2747 {
2753 }
2754 /* ALTER TABLE <name> ENABLE ALWAYS TRIGGER <trig> */
2755 | ENABLE_P ALWAYS TRIGGER name
2756 {
2762 }
2763 /* ALTER TABLE <name> ENABLE REPLICA TRIGGER <trig> */
2764 | ENABLE_P REPLICA TRIGGER name
2765 {
2771 }
2772 /* ALTER TABLE <name> ENABLE TRIGGER ALL */
2773 | ENABLE_P TRIGGER ALL
2774 {
2779 }
2780 /* ALTER TABLE <name> ENABLE TRIGGER USER */
2781 | ENABLE_P TRIGGER USER
2782 {
2787 }
2788 /* ALTER TABLE <name> DISABLE TRIGGER <trig> */
2789 | DISABLE_P TRIGGER name
2790 {
2796 }
2797 /* ALTER TABLE <name> DISABLE TRIGGER ALL */
2798 | DISABLE_P TRIGGER ALL
2799 {
2804 }
2805 /* ALTER TABLE <name> DISABLE TRIGGER USER */
2806 | DISABLE_P TRIGGER USER
2807 {
2812 }
2813 /* ALTER TABLE <name> ENABLE RULE <rule> */
2814 | ENABLE_P RULE name
2815 {
2821 }
2822 /* ALTER TABLE <name> ENABLE ALWAYS RULE <rule> */
2823 | ENABLE_P ALWAYS RULE name
2824 {
2830 }
2831 /* ALTER TABLE <name> ENABLE REPLICA RULE <rule> */
2832 | ENABLE_P REPLICA RULE name
2833 {
2839 }
2840 /* ALTER TABLE <name> DISABLE RULE <rule> */
2841 | DISABLE_P RULE name
2842 {
2848 }
2849 /* ALTER TABLE <name> INHERIT <parent> */
2850 | INHERIT qualified_name
2851 {
2857 }
2858 /* ALTER TABLE <name> NO INHERIT <parent> */
2859 | NO INHERIT qualified_name
2860 {
2866 }
2867 /* ALTER TABLE <name> OF <type_name> */
2868 | OF any_name
2869 {
2877 }
2878 /* ALTER TABLE <name> NOT OF */
2879 | NOT OF
2880 {
2885 }
2886 /* ALTER TABLE <name> OWNER TO RoleSpec */
2887 | OWNER TO RoleSpec
2888 {
2894 }
2895 /* ALTER TABLE <name> SET ACCESS METHOD { <amname> | DEFAULT } */
2896 | SET ACCESS METHOD set_access_method_name
2897 {
2903 }
2904 /* ALTER TABLE <name> SET TABLESPACE <tablespacename> */
2905 | SET TABLESPACE name
2906 {
2912 }
2913 /* ALTER TABLE <name> SET (...) */
2914 | SET reloptions
2915 {
2921 }
2922 /* ALTER TABLE <name> RESET (...) */
2923 | RESET reloptions
2924 {
2930 }
2931 /* ALTER TABLE <name> REPLICA IDENTITY */
2932 | REPLICA IDENTITY_P replica_identity
2933 {
2939 }
2940 /* ALTER TABLE <name> ENABLE ROW LEVEL SECURITY */
2941 | ENABLE_P ROW LEVEL SECURITY
2942 {
2947 }
2948 /* ALTER TABLE <name> DISABLE ROW LEVEL SECURITY */
2949 | DISABLE_P ROW LEVEL SECURITY
2950 {
2955 }
2956 /* ALTER TABLE <name> FORCE ROW LEVEL SECURITY */
2957 | FORCE ROW LEVEL SECURITY
2958 {
2963 }
2964 /* ALTER TABLE <name> NO FORCE ROW LEVEL SECURITY */
2965 | NO FORCE ROW LEVEL SECURITY
2966 {
2971 }
2972 | alter_generic_options
2973 {
2979 }
2980 ;
2982 alter_column_default:
2985 ;
2987 opt_collate_clause:
2988 COLLATE any_name
2989 {
2996 }
2998 ;
3000 alter_using:
3003 ;
3005 replica_identity:
3006 NOTHING
3007 {
3013 }
3014 | FULL
3015 {
3021 }
3022 | DEFAULT
3023 {
3029 }
3030 | USING INDEX name
3031 {
3037 }
3038 ;
3040 reloptions:
3042 ;
3046 ;
3048 reloption_list:
3051 ;
3053 /* This should match def_elem and also allow qualified names */
3054 reloption_elem:
3055 ColLabel '=' def_arg
3056 {
3058 }
3059 | ColLabel
3060 {
3062 }
3064 {
3067 }
3068 | ColLabel '.' ColLabel
3069 {
3071 }
3072 ;
3074 alter_identity_column_option_list:
3075 alter_identity_column_option
3077 | alter_identity_column_option_list alter_identity_column_option
3079 ;
3081 alter_identity_column_option:
3082 RESTART
3083 {
3085 }
3086 | RESTART opt_with NumericOnly
3087 {
3089 }
3090 | SET SeqOptElem
3091 {
3100 }
3101 | SET GENERATED generated_when
3102 {
3104 }
3105 ;
3107 set_statistics_value:
3110 ;
3112 set_access_method_name:
3115 ;
3117 PartitionBoundSpec:
3118 /* a HASH partition */
3120 {
3128 {
3132 {
3139 }
3141 {
3148 }
3149 else
3155 }
3171 }
3173 /* a LIST partition */
3175 {
3184 }
3186 /* a RANGE partition */
3188 {
3198 }
3200 /* a DEFAULT partition */
3201 | DEFAULT
3202 {
3209 }
3210 ;
3212 hash_partbound_elem:
3213 NonReservedWord Iconst
3214 {
3216 }
3217 ;
3219 hash_partbound:
3220 hash_partbound_elem
3221 {
3223 }
3224 | hash_partbound ',' hash_partbound_elem
3225 {
3227 }
3228 ;
3230 /*****************************************************************************
3231 *
3232 * ALTER TYPE
3233 *
3234 * really variants of the ALTER TABLE subcommands with different spellings
3235 *****************************************************************************/
3237 AlterCompositeTypeStmt:
3238 ALTER TYPE_P any_name alter_type_cmds
3239 {
3242 /* can't use qualified_name, sigh */
3247 }
3248 ;
3250 alter_type_cmds:
3253 ;
3255 alter_type_cmd:
3256 /* ALTER TYPE <name> ADD ATTRIBUTE <coldef> [RESTRICT|CASCADE] */
3257 ADD_P ATTRIBUTE TableFuncElement opt_drop_behavior
3258 {
3265 }
3266 /* ALTER TYPE <name> DROP ATTRIBUTE IF EXISTS <attname> [RESTRICT|CASCADE] */
3267 | DROP ATTRIBUTE IF_P EXISTS ColId opt_drop_behavior
3268 {
3276 }
3277 /* ALTER TYPE <name> DROP ATTRIBUTE <attname> [RESTRICT|CASCADE] */
3278 | DROP ATTRIBUTE ColId opt_drop_behavior
3279 {
3287 }
3288 /* ALTER TYPE <name> ALTER ATTRIBUTE <attname> [SET DATA] TYPE <typename> [RESTRICT|CASCADE] */
3289 | ALTER ATTRIBUTE ColId opt_set_data TYPE_P Typename opt_collate_clause opt_drop_behavior
3290 {
3298 /* We only use these fields of the ColumnDef node */
3304 }
3305 ;
3308 /*****************************************************************************
3309 *
3310 * QUERY :
3311 * close <portalname>
3312 *
3313 *****************************************************************************/
3315 ClosePortalStmt:
3316 CLOSE cursor_name
3317 {
3322 }
3323 | CLOSE ALL
3324 {
3329 }
3330 ;
3333 /*****************************************************************************
3334 *
3335 * QUERY :
3336 * COPY relname [(columnList)] FROM/TO file [WITH] [(options)]
3337 * COPY ( query ) TO file [WITH] [(options)]
3338 *
3339 * where 'query' can be one of:
3340 * { SELECT | UPDATE | INSERT | DELETE }
3341 *
3342 * and 'file' can be one of:
3343 * { PROGRAM 'command' | STDIN | STDOUT | 'filename' }
3344 *
3345 * In the preferred syntax the options are comma-separated
3346 * and use generic identifiers instead of keywords. The pre-9.0
3347 * syntax had a hard-wired, space-separated set of options.
3348 *
3349 * Really old syntax, from versions 7.2 and prior:
3350 * COPY [ BINARY ] table FROM/TO file
3351 * [ [ USING ] DELIMITERS 'delimiter' ] ]
3352 * [ WITH NULL AS 'null string' ]
3353 * This option placement is not supported with COPY (query...).
3354 *
3355 *****************************************************************************/
3357 CopyStmt: COPY opt_binary qualified_name opt_column_list
3358 copy_from opt_program copy_file_name copy_delimiter opt_with
3359 copy_options where_clause
3360 {
3384 /* Concatenate user-supplied flags */
3392 }
3394 {
3413 }
3414 ;
3416 copy_from:
3419 ;
3421 opt_program:
3424 ;
3426 /*
3427 * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
3428 * used depends on the direction. (It really doesn't make sense to copy from
3429 * stdout. We silently correct the "typo".) - AY 9/94
3430 */
3431 copy_file_name:
3435 ;
3439 ;
3441 /* old COPY option syntax */
3442 copy_opt_list:
3445 ;
3447 copy_opt_item:
3448 BINARY
3449 {
3451 }
3452 | FREEZE
3453 {
3455 }
3456 | DELIMITER opt_as Sconst
3457 {
3459 }
3460 | NULL_P opt_as Sconst
3461 {
3463 }
3464 | CSV
3465 {
3467 }
3468 | HEADER_P
3469 {
3471 }
3472 | QUOTE opt_as Sconst
3473 {
3475 }
3476 | ESCAPE opt_as Sconst
3477 {
3479 }
3480 | FORCE QUOTE columnList
3481 {
3483 }
3484 | FORCE QUOTE '*'
3485 {
3487 }
3488 | FORCE NOT NULL_P columnList
3489 {
3491 }
3492 | FORCE NOT NULL_P '*'
3493 {
3495 }
3496 | FORCE NULL_P columnList
3497 {
3499 }
3500 | FORCE NULL_P '*'
3501 {
3503 }
3504 | ENCODING Sconst
3505 {
3507 }
3508 ;
3510 /* The following exist for backward compatibility with very old versions */
3512 opt_binary:
3513 BINARY
3514 {
3516 }
3518 ;
3520 copy_delimiter:
3521 opt_using DELIMITERS Sconst
3522 {
3524 }
3526 ;
3528 opt_using:
3529 USING
3530 | /*EMPTY*/
3531 ;
3533 /* new COPY option syntax */
3534 copy_generic_opt_list:
3535 copy_generic_opt_elem
3536 {
3538 }
3539 | copy_generic_opt_list ',' copy_generic_opt_elem
3540 {
3542 }
3543 ;
3545 copy_generic_opt_elem:
3546 ColLabel copy_generic_opt_arg
3547 {
3549 }
3550 ;
3552 copy_generic_opt_arg:
3559 ;
3561 copy_generic_opt_arg_list:
3562 copy_generic_opt_arg_list_item
3563 {
3565 }
3566 | copy_generic_opt_arg_list ',' copy_generic_opt_arg_list_item
3567 {
3569 }
3570 ;
3572 /* beware of emitting non-string list elements here; see commands/define.c */
3573 copy_generic_opt_arg_list_item:
3575 ;
3578 /*****************************************************************************
3579 *
3580 * QUERY :
3581 * CREATE TABLE relname
3582 *
3583 *****************************************************************************/
3586 OptInherit OptPartitionSpec table_access_method_clause OptWith
3587 OnCommitOption OptTableSpace
3588 {
3604 }
3605 | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name '('
3606 OptTableElementList ')' OptInherit OptPartitionSpec table_access_method_clause
3607 OptWith OnCommitOption OptTableSpace
3608 {
3624 }
3625 | CREATE OptTemp TABLE qualified_name OF any_name
3626 OptTypedTableElementList OptPartitionSpec table_access_method_clause
3627 OptWith OnCommitOption OptTableSpace
3628 {
3645 }
3646 | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name OF any_name
3647 OptTypedTableElementList OptPartitionSpec table_access_method_clause
3648 OptWith OnCommitOption OptTableSpace
3649 {
3666 }
3667 | CREATE OptTemp TABLE qualified_name PARTITION OF qualified_name
3668 OptTypedTableElementList PartitionBoundSpec OptPartitionSpec
3669 table_access_method_clause OptWith OnCommitOption OptTableSpace
3670 {
3687 }
3688 | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name PARTITION OF
3689 qualified_name OptTypedTableElementList PartitionBoundSpec OptPartitionSpec
3690 table_access_method_clause OptWith OnCommitOption OptTableSpace
3691 {
3708 }
3709 ;
3711 /*
3712 * Redundancy here is needed to avoid shift/reduce conflicts,
3713 * since TEMP is not a reserved word. See also OptTempTableName.
3714 *
3715 * NOTE: we accept both GLOBAL and LOCAL options. They currently do nothing,
3716 * but future versions might consider GLOBAL to request SQL-spec-compliant
3717 * temp table behavior, so warn about that. Since we have no modules the
3718 * LOCAL keyword is really meaningless; furthermore, some other products
3719 * implement LOCAL as meaning the same as our default temp table behavior,
3720 * so we'll probably continue to treat LOCAL as a noise word.
3721 */
3726 | GLOBAL TEMPORARY
3727 {
3732 }
3733 | GLOBAL TEMP
3734 {
3739 }
3742 ;
3744 OptTableElementList:
3747 ;
3749 OptTypedTableElementList:
3752 ;
3754 TableElementList:
3755 TableElement
3756 {
3758 }
3759 | TableElementList ',' TableElement
3760 {
3762 }
3763 ;
3765 TypedTableElementList:
3766 TypedTableElement
3767 {
3769 }
3770 | TypedTableElementList ',' TypedTableElement
3771 {
3773 }
3774 ;
3776 TableElement:
3780 ;
3782 TypedTableElement:
3785 ;
3787 columnDef: ColId Typename opt_column_storage opt_column_compression create_generic_options ColQualList
3788 {
3805 yyscanner);
3808 }
3809 ;
3811 columnOptions: ColId ColQualList
3812 {
3826 yyscanner);
3829 }
3830 | ColId WITH OPTIONS ColQualList
3831 {
3845 yyscanner);
3848 }
3849 ;
3851 column_compression:
3854 ;
3856 opt_column_compression:
3859 ;
3861 column_storage:
3864 ;
3866 opt_column_storage:
3869 ;
3871 ColQualList:
3874 ;
3876 ColConstraint:
3877 CONSTRAINT name ColConstraintElem
3878 {
3884 }
3887 | COLLATE any_name
3888 {
3889 /*
3890 * Note: the CollateClause is momentarily included in
3891 * the list built by ColQualList, but we split it out
3892 * again in SplitColQualList.
3893 */
3900 }
3901 ;
3903 /* DEFAULT NULL is already the default for Postgres.
3904 * But define it here and carry it forward into the system
3905 * to make it explicit.
3906 * - thomas 1998-09-13
3907 *
3908 * WITH NULL and NULL are not SQL-standard syntax elements,
3909 * so leave them out. Use DEFAULT NULL to explicitly indicate
3910 * that a column may have that value. WITH NULL leads to
3911 * shift/reduce conflicts with WITH TIME ZONE anyway.
3912 * - thomas 1999-01-08
3913 *
3914 * DEFAULT expression must be b_expr not a_expr to prevent shift/reduce
3915 * conflict on NOT (since NOT might start a subsequent NOT NULL constraint,
3916 * or be part of a_expr NOT LIKE or similar constructs).
3917 */
3918 ColConstraintElem:
3919 NOT NULL_P opt_no_inherit
3920 {
3930 }
3931 | NULL_P
3932 {
3938 }
3939 | UNIQUE opt_unique_null_treatment opt_definition OptConsTableSpace
3940 {
3951 }
3952 | PRIMARY KEY opt_definition OptConsTableSpace
3953 {
3963 }
3965 {
3977 }
3978 | DEFAULT b_expr
3979 {
3987 }
3988 | GENERATED generated_when AS IDENTITY_P OptParenthesizedSeqOptList
3989 {
3997 }
3999 {
4008 /*
4009 * Can't do this in the grammar because of shift/reduce
4010 * conflicts. (IDENTITY allows both ALWAYS and BY
4011 * DEFAULT, but generated columns only allow ALWAYS.) We
4012 * can also give a more useful error message and location.
4013 */
4021 }
4022 | REFERENCES qualified_name opt_column_list key_match key_actions
4023 {
4039 }
4040 ;
4042 opt_unique_null_treatment:
4046 ;
4048 generated_when:
4051 ;
4053 /*
4054 * ConstraintAttr represents constraint attributes, which we parse as if
4055 * they were independent constraint clauses, in order to avoid shift/reduce
4056 * conflicts (since NOT might start either an independent NOT NULL clause
4057 * or an attribute). parse_utilcmd.c is responsible for attaching the
4058 * attribute information to the preceding "real" constraint node, and for
4059 * complaining if attribute clauses appear in the wrong place or wrong
4060 * combinations.
4061 *
4062 * See also ConstraintAttributeSpec, which can be used in places where
4063 * there is no parsing conflict. (Note: currently, NOT VALID and NO INHERIT
4064 * are allowed clauses in ConstraintAttributeSpec, but not here. Someday we
4065 * might need to allow them here too, but for the moment it doesn't seem
4066 * useful in the statements that use ConstraintAttr.)
4067 */
4068 ConstraintAttr:
4069 DEFERRABLE
4070 {
4076 }
4077 | NOT DEFERRABLE
4078 {
4084 }
4085 | INITIALLY DEFERRED
4086 {
4092 }
4093 | INITIALLY IMMEDIATE
4094 {
4100 }
4101 | ENFORCED
4102 {
4108 }
4109 | NOT ENFORCED
4110 {
4116 }
4117 ;
4120 TableLikeClause:
4121 LIKE qualified_name TableLikeOptionList
4122 {
4129 }
4130 ;
4132 TableLikeOptionList:
4136 ;
4138 TableLikeOption:
4149 ;
4152 /* ConstraintElem specifies constraint syntax which is not embedded into
4153 * a column definition. ColConstraintElem specifies the embedded form.
4154 * - thomas 1997-12-03
4155 */
4156 TableConstraint:
4157 CONSTRAINT name ConstraintElem
4158 {
4164 }
4166 ;
4168 ConstraintElem:
4170 {
4182 }
4183 | NOT NULL_P ColId ConstraintAttributeSpec
4184 {
4190 /* no NOT VALID support yet */
4196 }
4197 | UNIQUE opt_unique_null_treatment '(' columnList opt_without_overlaps ')' opt_c_include opt_definition OptConsTableSpace
4198 ConstraintAttributeSpec
4199 {
4215 }
4216 | UNIQUE ExistingIndex ConstraintAttributeSpec
4217 {
4231 }
4232 | PRIMARY KEY '(' columnList opt_without_overlaps ')' opt_c_include opt_definition OptConsTableSpace
4233 ConstraintAttributeSpec
4234 {
4249 }
4250 | PRIMARY KEY ExistingIndex ConstraintAttributeSpec
4251 {
4265 }
4267 opt_c_include opt_definition OptConsTableSpace OptWhereClause
4268 ConstraintAttributeSpec
4269 {
4285 }
4287 opt_column_and_period_list key_match key_actions ConstraintAttributeSpec
4288 {
4296 {
4299 }
4302 {
4305 }
4313 yyscanner);
4316 }
4317 ;
4319 /*
4320 * DomainConstraint is separate from TableConstraint because the syntax for
4321 * NOT NULL constraints is different. For table constraints, we need to
4322 * accept a column name, but for domain constraints, we don't. (We could
4323 * accept something like NOT NULL VALUE, but that seems weird.) CREATE DOMAIN
4324 * (which uses ColQualList) has for a long time accepted NOT NULL without a
4325 * column name, so it makes sense that ALTER DOMAIN (which uses
4326 * DomainConstraint) does as well. None of these syntaxes are per SQL
4327 * standard; we are just living with the bits of inconsistency that have built
4328 * up over time.
4329 */
4330 DomainConstraint:
4331 CONSTRAINT name DomainConstraintElem
4332 {
4338 }
4340 ;
4342 DomainConstraintElem:
4344 {
4357 }
4358 | NOT NULL_P ConstraintAttributeSpec
4359 {
4365 /* no NOT VALID, NO INHERIT support */
4371 }
4372 ;
4376 ;
4378 opt_without_overlaps:
4381 ;
4383 opt_column_list:
4386 ;
4388 columnList:
4391 ;
4393 optionalPeriodName:
4396 ;
4398 opt_column_and_period_list:
4401 ;
4403 columnElem: ColId
4404 {
4406 }
4407 ;
4411 ;
4413 key_match: MATCH FULL
4414 {
4416 }
4417 | MATCH PARTIAL
4418 {
4424 }
4425 | MATCH SIMPLE
4426 {
4428 }
4429 | /*EMPTY*/
4430 {
4432 }
4433 ;
4435 ExclusionConstraintList:
4437 | ExclusionConstraintList ',' ExclusionConstraintElem
4439 ;
4441 ExclusionConstraintElem: index_elem WITH any_operator
4442 {
4444 }
4445 /* allow OPERATOR() decoration for the benefit of ruleutils.c */
4447 {
4449 }
4450 ;
4452 OptWhereClause:
4455 ;
4457 key_actions:
4458 key_update
4459 {
4467 }
4468 | key_delete
4469 {
4477 }
4478 | key_update key_delete
4479 {
4485 }
4486 | key_delete key_update
4487 {
4493 }
4494 | /*EMPTY*/
4495 {
4505 }
4506 ;
4508 key_update: ON UPDATE key_action
4509 {
4517 }
4518 ;
4520 key_delete: ON DELETE_P key_action
4521 {
4523 }
4524 ;
4526 key_action:
4527 NO ACTION
4528 {
4534 }
4535 | RESTRICT
4536 {
4542 }
4543 | CASCADE
4544 {
4550 }
4551 | SET NULL_P opt_column_list
4552 {
4558 }
4559 | SET DEFAULT opt_column_list
4560 {
4566 }
4567 ;
4571 ;
4573 /* Optional partition key specification */
4576 ;
4579 {
4587 }
4588 ;
4592 ;
4594 part_elem: ColId opt_collate opt_qualified_name
4595 {
4604 }
4605 | func_expr_windowless opt_collate opt_qualified_name
4606 {
4615 }
4617 {
4626 }
4627 ;
4629 table_access_method_clause:
4632 ;
4634 /* WITHOUT OIDS is legacy only */
4635 OptWith:
4639 ;
4645 ;
4649 ;
4653 ;
4656 ;
4658 /*****************************************************************************
4659 *
4660 * QUERY :
4661 * CREATE STATISTICS [[IF NOT EXISTS] stats_name] [(stat types)]
4662 * ON expression-list FROM from_list
4663 *
4664 * Note: the expectation here is that the clauses after ON are a subset of
4665 * SELECT syntax, allowing for expressions and joined tables, and probably
4666 * someday a WHERE clause. Much less than that is currently implemented,
4667 * but the grammar accepts it and then we'll throw FEATURE_NOT_SUPPORTED
4668 * errors as necessary at execution.
4669 *
4670 * Statistics name is optional unless IF NOT EXISTS is specified.
4671 *
4672 *****************************************************************************/
4674 CreateStatsStmt:
4675 CREATE STATISTICS opt_qualified_name
4676 opt_name_list ON stats_params FROM from_list
4677 {
4687 }
4688 | CREATE STATISTICS IF_P NOT EXISTS any_name
4689 opt_name_list ON stats_params FROM from_list
4690 {
4700 }
4701 ;
4703 /*
4704 * Statistics attributes can be either simple column references, or arbitrary
4705 * expressions in parens. For compatibility with index attributes permitted
4706 * in CREATE INDEX, we allow an expression that's just a function call to be
4707 * written without parens.
4708 */
4712 ;
4714 stats_param: ColId
4715 {
4719 }
4720 | func_expr_windowless
4721 {
4725 }
4727 {
4731 }
4732 ;
4734 /*****************************************************************************
4735 *
4736 * QUERY :
4737 * ALTER STATISTICS [IF EXISTS] stats_name
4738 * SET STATISTICS <SignedIconst>
4739 *
4740 *****************************************************************************/
4742 AlterStatsStmt:
4743 ALTER STATISTICS any_name SET STATISTICS set_statistics_value
4744 {
4751 }
4752 | ALTER STATISTICS IF_P EXISTS any_name SET STATISTICS set_statistics_value
4753 {
4760 }
4761 ;
4763 /*****************************************************************************
4764 *
4765 * QUERY :
4766 * CREATE TABLE relname AS SelectStmt [ WITH [NO] DATA ]
4767 *
4768 *
4769 * Note: SELECT ... INTO is a now-deprecated alternative for this.
4770 *
4771 *****************************************************************************/
4773 CreateAsStmt:
4774 CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
4775 {
4783 /* cram additional flags into the IntoClause */
4787 }
4788 | CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS SelectStmt opt_with_data
4789 {
4797 /* cram additional flags into the IntoClause */
4801 }
4802 ;
4804 create_as_target:
4805 qualified_name opt_column_list table_access_method_clause
4806 OptWith OnCommitOption OptTableSpace
4807 {
4817 }
4818 ;
4820 opt_with_data:
4824 ;
4827 /*****************************************************************************
4828 *
4829 * QUERY :
4830 * CREATE MATERIALIZED VIEW relname AS SelectStmt
4831 *
4832 *****************************************************************************/
4834 CreateMatViewStmt:
4835 CREATE OptNoLog MATERIALIZED VIEW create_mv_target AS SelectStmt opt_with_data
4836 {
4844 /* cram additional flags into the IntoClause */
4848 }
4849 | CREATE OptNoLog MATERIALIZED VIEW IF_P NOT EXISTS create_mv_target AS SelectStmt opt_with_data
4850 {
4858 /* cram additional flags into the IntoClause */
4862 }
4863 ;
4865 create_mv_target:
4866 qualified_name opt_column_list table_access_method_clause opt_reloptions OptTableSpace
4867 {
4877 }
4878 ;
4882 ;
4885 /*****************************************************************************
4886 *
4887 * QUERY :
4888 * REFRESH MATERIALIZED VIEW qualified_name
4889 *
4890 *****************************************************************************/
4892 RefreshMatViewStmt:
4893 REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data
4894 {
4901 }
4902 ;
4905 /*****************************************************************************
4906 *
4907 * QUERY :
4908 * CREATE SEQUENCE seqname
4909 * ALTER SEQUENCE seqname
4910 *
4911 *****************************************************************************/
4913 CreateSeqStmt:
4914 CREATE OptTemp SEQUENCE qualified_name OptSeqOptList
4915 {
4924 }
4925 | CREATE OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList
4926 {
4935 }
4936 ;
4938 AlterSeqStmt:
4939 ALTER SEQUENCE qualified_name SeqOptList
4940 {
4947 }
4948 | ALTER SEQUENCE IF_P EXISTS qualified_name SeqOptList
4949 {
4956 }
4958 ;
4962 ;
4966 ;
4970 ;
4972 SeqOptElem: AS SimpleTypename
4973 {
4975 }
4976 | CACHE NumericOnly
4977 {
4979 }
4980 | CYCLE
4981 {
4983 }
4984 | NO CYCLE
4985 {
4987 }
4988 | INCREMENT opt_by NumericOnly
4989 {
4991 }
4992 | LOGGED
4993 {
4995 }
4996 | MAXVALUE NumericOnly
4997 {
4999 }
5000 | MINVALUE NumericOnly
5001 {
5003 }
5004 | NO MAXVALUE
5005 {
5007 }
5008 | NO MINVALUE
5009 {
5011 }
5012 | OWNED BY any_name
5013 {
5015 }
5016 | SEQUENCE NAME_P any_name
5017 {
5019 }
5020 | START opt_with NumericOnly
5021 {
5023 }
5024 | RESTART
5025 {
5027 }
5028 | RESTART opt_with NumericOnly
5029 {
5031 }
5032 | UNLOGGED
5033 {
5035 }
5036 ;
5038 opt_by: BY
5039 | /* EMPTY */
5040 ;
5042 NumericOnly:
5045 | '-' FCONST
5046 {
5051 }
5053 ;
5057 ;
5059 /*****************************************************************************
5060 *
5061 * QUERIES :
5062 * CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE ...
5063 * DROP [PROCEDURAL] LANGUAGE ...
5064 *
5065 *****************************************************************************/
5067 CreatePLangStmt:
5068 CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name
5069 {
5070 /*
5071 * We now interpret parameterless CREATE LANGUAGE as
5072 * CREATE EXTENSION. "OR REPLACE" is silently translated
5073 * to "IF NOT EXISTS", which isn't quite the same, but
5074 * seems more useful than throwing an error. We just
5075 * ignore TRUSTED, as the previous code would have too.
5076 */
5083 }
5084 | CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name
5085 HANDLER handler_name opt_inline_handler opt_validator
5086 {
5096 }
5097 ;
5099 opt_trusted:
5102 ;
5104 /* This ought to be just func_name, but that causes reduce/reduce conflicts
5105 * (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
5106 * Work around by using simple names, instead.
5107 */
5108 handler_name:
5111 ;
5113 opt_inline_handler:
5116 ;
5118 validator_clause:
5121 ;
5123 opt_validator:
5126 ;
5128 opt_procedural:
5129 PROCEDURAL
5130 | /*EMPTY*/
5131 ;
5133 /*****************************************************************************
5134 *
5135 * QUERY:
5136 * CREATE TABLESPACE tablespace LOCATION '/path/to/tablespace/'
5137 *
5138 *****************************************************************************/
5140 CreateTableSpaceStmt: CREATE TABLESPACE name OptTableSpaceOwner LOCATION Sconst opt_reloptions
5141 {
5149 }
5150 ;
5154 ;
5156 /*****************************************************************************
5157 *
5158 * QUERY :
5159 * DROP TABLESPACE <tablespace>
5160 *
5161 * No need for drop behaviour as we cannot implement dependencies for
5162 * objects in other databases; we can only support RESTRICT.
5163 *
5164 ****************************************************************************/
5166 DropTableSpaceStmt: DROP TABLESPACE name
5167 {
5173 }
5174 | DROP TABLESPACE IF_P EXISTS name
5175 {
5181 }
5182 ;
5184 /*****************************************************************************
5185 *
5186 * QUERY:
5187 * CREATE EXTENSION extension
5188 * [ WITH ] [ SCHEMA schema ] [ VERSION version ]
5189 *
5190 *****************************************************************************/
5192 CreateExtensionStmt: CREATE EXTENSION name opt_with create_extension_opt_list
5193 {
5200 }
5201 | CREATE EXTENSION IF_P NOT EXISTS name opt_with create_extension_opt_list
5202 {
5209 }
5210 ;
5212 create_extension_opt_list:
5213 create_extension_opt_list create_extension_opt_item
5215 | /* EMPTY */
5217 ;
5219 create_extension_opt_item:
5220 SCHEMA name
5221 {
5223 }
5224 | VERSION_P NonReservedWord_or_Sconst
5225 {
5227 }
5228 | FROM NonReservedWord_or_Sconst
5229 {
5234 }
5235 | CASCADE
5236 {
5238 }
5239 ;
5241 /*****************************************************************************
5242 *
5243 * ALTER EXTENSION name UPDATE [ TO version ]
5244 *
5245 *****************************************************************************/
5247 AlterExtensionStmt: ALTER EXTENSION name UPDATE alter_extension_opt_list
5248 {
5254 }
5255 ;
5257 alter_extension_opt_list:
5258 alter_extension_opt_list alter_extension_opt_item
5260 | /* EMPTY */
5262 ;
5264 alter_extension_opt_item:
5265 TO NonReservedWord_or_Sconst
5266 {
5268 }
5269 ;
5271 /*****************************************************************************
5272 *
5273 * ALTER EXTENSION name ADD/DROP object-identifier
5274 *
5275 *****************************************************************************/
5277 AlterExtensionContentsStmt:
5278 ALTER EXTENSION name add_drop object_type_name name
5279 {
5287 }
5288 | ALTER EXTENSION name add_drop object_type_any_name any_name
5289 {
5297 }
5298 | ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes
5299 {
5307 }
5309 {
5317 }
5318 | ALTER EXTENSION name add_drop DOMAIN_P Typename
5319 {
5327 }
5328 | ALTER EXTENSION name add_drop FUNCTION function_with_argtypes
5329 {
5337 }
5338 | ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes
5339 {
5347 }
5348 | ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name
5349 {
5357 }
5358 | ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name
5359 {
5367 }
5368 | ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes
5369 {
5377 }
5378 | ALTER EXTENSION name add_drop ROUTINE function_with_argtypes
5379 {
5387 }
5388 | ALTER EXTENSION name add_drop TRANSFORM FOR Typename LANGUAGE name
5389 {
5397 }
5398 | ALTER EXTENSION name add_drop TYPE_P Typename
5399 {
5407 }
5408 ;
5410 /*****************************************************************************
5411 *
5412 * QUERY:
5413 * CREATE FOREIGN DATA WRAPPER name options
5414 *
5415 *****************************************************************************/
5417 CreateFdwStmt: CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options
5418 {
5425 }
5426 ;
5428 fdw_option:
5433 ;
5435 fdw_options:
5438 ;
5440 opt_fdw_options:
5443 ;
5445 /*****************************************************************************
5446 *
5447 * QUERY :
5448 * ALTER FOREIGN DATA WRAPPER name options
5449 *
5450 ****************************************************************************/
5452 AlterFdwStmt: ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options
5453 {
5460 }
5461 | ALTER FOREIGN DATA_P WRAPPER name fdw_options
5462 {
5469 }
5470 ;
5472 /* Options definition for CREATE FDW, SERVER and USER MAPPING */
5473 create_generic_options:
5476 ;
5478 generic_option_list:
5479 generic_option_elem
5480 {
5482 }
5483 | generic_option_list ',' generic_option_elem
5484 {
5486 }
5487 ;
5489 /* Options definition for ALTER FDW, SERVER and USER MAPPING */
5490 alter_generic_options:
5492 ;
5494 alter_generic_option_list:
5495 alter_generic_option_elem
5496 {
5498 }
5499 | alter_generic_option_list ',' alter_generic_option_elem
5500 {
5502 }
5503 ;
5505 alter_generic_option_elem:
5506 generic_option_elem
5507 {
5509 }
5510 | SET generic_option_elem
5511 {
5514 }
5515 | ADD_P generic_option_elem
5516 {
5519 }
5520 | DROP generic_option_name
5521 {
5523 }
5524 ;
5526 generic_option_elem:
5527 generic_option_name generic_option_arg
5528 {
5530 }
5531 ;
5533 generic_option_name:
5535 ;
5537 /* We could use def_arg here, but the spec only requires string literals */
5538 generic_option_arg:
5540 ;
5542 /*****************************************************************************
5543 *
5544 * QUERY:
5545 * CREATE SERVER name [TYPE] [VERSION] [OPTIONS]
5546 *
5547 *****************************************************************************/
5549 CreateForeignServerStmt: CREATE SERVER name opt_type opt_foreign_server_version
5550 FOREIGN DATA_P WRAPPER name create_generic_options
5551 {
5561 }
5562 | CREATE SERVER IF_P NOT EXISTS name opt_type opt_foreign_server_version
5563 FOREIGN DATA_P WRAPPER name create_generic_options
5564 {
5574 }
5575 ;
5577 opt_type:
5580 ;
5583 foreign_server_version:
5586 ;
5588 opt_foreign_server_version:
5591 ;
5593 /*****************************************************************************
5594 *
5595 * QUERY :
5596 * ALTER SERVER name [VERSION] [OPTIONS]
5597 *
5598 ****************************************************************************/
5600 AlterForeignServerStmt: ALTER SERVER name foreign_server_version alter_generic_options
5601 {
5609 }
5610 | ALTER SERVER name foreign_server_version
5611 {
5618 }
5619 | ALTER SERVER name alter_generic_options
5620 {
5626 }
5627 ;
5629 /*****************************************************************************
5630 *
5631 * QUERY:
5632 * CREATE FOREIGN TABLE relname (...) SERVER name (...)
5633 *
5634 *****************************************************************************/
5636 CreateForeignTableStmt:
5637 CREATE FOREIGN TABLE qualified_name
5639 OptInherit SERVER name create_generic_options
5640 {
5653 /* FDW-specific data */
5657 }
5658 | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name
5660 OptInherit SERVER name create_generic_options
5661 {
5674 /* FDW-specific data */
5678 }
5679 | CREATE FOREIGN TABLE qualified_name
5680 PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec
5681 SERVER name create_generic_options
5682 {
5696 /* FDW-specific data */
5700 }
5701 | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name
5702 PARTITION OF qualified_name OptTypedTableElementList PartitionBoundSpec
5703 SERVER name create_generic_options
5704 {
5718 /* FDW-specific data */
5722 }
5723 ;
5725 /*****************************************************************************
5726 *
5727 * QUERY:
5728 * IMPORT FOREIGN SCHEMA remote_schema
5729 * [ { LIMIT TO | EXCEPT } ( table_list ) ]
5730 * FROM SERVER server_name INTO local_schema [ OPTIONS (...) ]
5731 *
5732 ****************************************************************************/
5734 ImportForeignSchemaStmt:
5735 IMPORT_P FOREIGN SCHEMA name import_qualification
5736 FROM SERVER name INTO name create_generic_options
5737 {
5747 }
5748 ;
5750 import_qualification_type:
5753 ;
5755 import_qualification:
5757 {
5763 }
5764 | /*EMPTY*/
5765 {
5770 }
5771 ;
5773 /*****************************************************************************
5774 *
5775 * QUERY:
5776 * CREATE USER MAPPING FOR auth_ident SERVER name [OPTIONS]
5777 *
5778 *****************************************************************************/
5780 CreateUserMappingStmt: CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
5781 {
5789 }
5790 | CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options
5791 {
5799 }
5800 ;
5802 /* User mapping authorization identifier */
5805 ;
5807 /*****************************************************************************
5808 *
5809 * QUERY :
5810 * DROP USER MAPPING FOR auth_ident SERVER name
5811 *
5812 * XXX you'd think this should have a CASCADE/RESTRICT option, even if it's
5813 * only pro forma; but the SQL standard doesn't show one.
5814 ****************************************************************************/
5816 DropUserMappingStmt: DROP USER MAPPING FOR auth_ident SERVER name
5817 {
5824 }
5825 | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
5826 {
5833 }
5834 ;
5836 /*****************************************************************************
5837 *
5838 * QUERY :
5839 * ALTER USER MAPPING FOR auth_ident SERVER name OPTIONS
5840 *
5841 ****************************************************************************/
5843 AlterUserMappingStmt: ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
5844 {
5851 }
5852 ;
5854 /*****************************************************************************
5855 *
5856 * QUERIES:
5857 * CREATE POLICY name ON table
5858 * [AS { PERMISSIVE | RESTRICTIVE } ]
5859 * [FOR { SELECT | INSERT | UPDATE | DELETE } ]
5860 * [TO role, ...]
5861 * [USING (qual)] [WITH CHECK (with check qual)]
5862 * ALTER POLICY name ON table [TO role, ...]
5863 * [USING (qual)] [WITH CHECK (with check qual)]
5864 *
5865 *****************************************************************************/
5867 CreatePolicyStmt:
5868 CREATE POLICY name ON qualified_name RowSecurityDefaultPermissive
5869 RowSecurityDefaultForCmd RowSecurityDefaultToRole
5870 RowSecurityOptionalExpr RowSecurityOptionalWithCheck
5871 {
5882 }
5883 ;
5885 AlterPolicyStmt:
5886 ALTER POLICY name ON qualified_name RowSecurityOptionalToRole
5887 RowSecurityOptionalExpr RowSecurityOptionalWithCheck
5888 {
5897 }
5898 ;
5900 RowSecurityOptionalExpr:
5903 ;
5905 RowSecurityOptionalWithCheck:
5908 ;
5910 RowSecurityDefaultToRole:
5913 ;
5915 RowSecurityOptionalToRole:
5918 ;
5920 RowSecurityDefaultPermissive:
5921 AS IDENT
5922 {
5927 else
5934 }
5936 ;
5938 RowSecurityDefaultForCmd:
5941 ;
5943 row_security_cmd:
5949 ;
5951 /*****************************************************************************
5952 *
5953 * QUERY:
5954 * CREATE ACCESS METHOD name HANDLER handler_name
5955 *
5956 *****************************************************************************/
5958 CreateAmStmt: CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name
5959 {
5966 }
5967 ;
5969 am_type:
5972 ;
5974 /*****************************************************************************
5975 *
5976 * QUERIES :
5977 * CREATE TRIGGER ...
5978 *
5979 *****************************************************************************/
5981 CreateTrigStmt:
5982 CREATE opt_or_replace TRIGGER name TriggerActionTime TriggerEvents ON
5983 qualified_name TriggerReferencing TriggerForSpec TriggerWhen
5985 {
6004 }
6005 | CREATE opt_or_replace CONSTRAINT TRIGGER name AFTER TriggerEvents ON
6006 qualified_name OptConstrFromTable ConstraintAttributeSpec
6007 FOR EACH ROW TriggerWhen
6009 {
6034 }
6035 ;
6037 TriggerActionTime:
6041 ;
6043 TriggerEvents:
6044 TriggerOneEvent
6046 | TriggerEvents OR TriggerOneEvent
6047 {
6055 /*
6056 * concat'ing the columns lists loses information about
6057 * which columns went with which event, but so long as
6058 * only UPDATE carries columns and we disallow multiple
6059 * UPDATE items, it doesn't matter. Command execution
6060 * should just ignore the columns for non-UPDATE events.
6061 */
6064 }
6065 ;
6067 TriggerOneEvent:
6068 INSERT
6070 | DELETE_P
6072 | UPDATE
6074 | UPDATE OF columnList
6076 | TRUNCATE
6078 ;
6080 TriggerReferencing:
6083 ;
6085 TriggerTransitions:
6088 ;
6090 TriggerTransition:
6091 TransitionOldOrNew TransitionRowOrTable opt_as TransitionRelName
6092 {
6099 }
6100 ;
6102 TransitionOldOrNew:
6105 ;
6107 TransitionRowOrTable:
6109 /*
6110 * According to the standard, lack of a keyword here implies ROW.
6111 * Support for that would require prohibiting ROW entirely here,
6112 * reserving the keyword ROW, and/or requiring AS (instead of
6113 * allowing it to be optional, as the standard specifies) as the
6114 * next token. Requiring ROW seems cleanest and easiest to
6115 * explain.
6116 */
6118 ;
6120 TransitionRelName:
6122 ;
6124 TriggerForSpec:
6125 FOR TriggerForOptEach TriggerForType
6126 {
6128 }
6129 | /* EMPTY */
6130 {
6131 /*
6132 * If ROW/STATEMENT not specified, default to
6133 * STATEMENT, per SQL
6134 */
6136 }
6137 ;
6139 TriggerForOptEach:
6140 EACH
6141 | /*EMPTY*/
6142 ;
6144 TriggerForType:
6147 ;
6149 TriggerWhen:
6152 ;
6154 FUNCTION_or_PROCEDURE:
6155 FUNCTION
6156 | PROCEDURE
6157 ;
6159 TriggerFuncArgs:
6163 ;
6165 TriggerFuncArg:
6166 Iconst
6167 {
6169 }
6173 ;
6175 OptConstrFromTable:
6178 ;
6180 ConstraintAttributeSpec:
6181 /*EMPTY*/
6183 | ConstraintAttributeSpec ConstraintAttributeElem
6184 {
6185 /*
6186 * We must complain about conflicting options.
6187 * We could, but choose not to, complain about redundant
6188 * options (ie, where $2's bit is already set in $1).
6189 */
6192 /* special message for this case */
6193 if ((newspec & (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED)) == (CAS_NOT_DEFERRABLE | CAS_INITIALLY_DEFERRED))
6198 /* generic message for other conflicts */
6199 if ((newspec & (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE)) == (CAS_NOT_DEFERRABLE | CAS_DEFERRABLE) ||
6200 (newspec & (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED)) == (CAS_INITIALLY_IMMEDIATE | CAS_INITIALLY_DEFERRED) ||
6207 }
6208 ;
6210 ConstraintAttributeElem:
6219 ;
6222 /*****************************************************************************
6223 *
6224 * QUERIES :
6225 * CREATE EVENT TRIGGER ...
6226 * ALTER EVENT TRIGGER ...
6227 *
6228 *****************************************************************************/
6230 CreateEventTrigStmt:
6231 CREATE EVENT TRIGGER name ON ColLabel
6233 {
6241 }
6242 | CREATE EVENT TRIGGER name ON ColLabel
6243 WHEN event_trigger_when_list
6245 {
6253 }
6254 ;
6256 event_trigger_when_list:
6257 event_trigger_when_item
6259 | event_trigger_when_list AND event_trigger_when_item
6261 ;
6263 event_trigger_when_item:
6266 ;
6268 event_trigger_value_list:
6269 SCONST
6271 | event_trigger_value_list ',' SCONST
6273 ;
6275 AlterEventTrigStmt:
6276 ALTER EVENT TRIGGER name enable_trigger
6277 {
6283 }
6284 ;
6286 enable_trigger:
6291 ;
6293 /*****************************************************************************
6294 *
6295 * QUERY :
6296 * CREATE ASSERTION ...
6297 *
6298 *****************************************************************************/
6300 CreateAssertionStmt:
6302 {
6309 }
6310 ;
6313 /*****************************************************************************
6314 *
6315 * QUERY :
6316 * define (aggregate,operator,type)
6317 *
6318 *****************************************************************************/
6320 DefineStmt:
6321 CREATE opt_or_replace AGGREGATE func_name aggr_args definition
6322 {
6332 }
6333 | CREATE opt_or_replace AGGREGATE func_name old_aggr_definition
6334 {
6335 /* old-style (pre-8.2) syntax for CREATE AGGREGATE */
6345 }
6346 | CREATE OPERATOR any_operator definition
6347 {
6356 }
6357 | CREATE TYPE_P any_name definition
6358 {
6367 }
6368 | CREATE TYPE_P any_name
6369 {
6370 /* Shell type (identified by lack of definition) */
6379 }
6381 {
6384 /* can't use qualified_name, sigh */
6388 }
6390 {
6396 }
6397 | CREATE TYPE_P any_name AS RANGE definition
6398 {
6404 }
6405 | CREATE TEXT_P SEARCH PARSER any_name definition
6406 {
6414 }
6415 | CREATE TEXT_P SEARCH DICTIONARY any_name definition
6416 {
6424 }
6425 | CREATE TEXT_P SEARCH TEMPLATE any_name definition
6426 {
6434 }
6435 | CREATE TEXT_P SEARCH CONFIGURATION any_name definition
6436 {
6444 }
6445 | CREATE COLLATION any_name definition
6446 {
6454 }
6455 | CREATE COLLATION IF_P NOT EXISTS any_name definition
6456 {
6465 }
6466 | CREATE COLLATION any_name FROM any_name
6467 {
6475 }
6476 | CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name
6477 {
6486 }
6487 ;
6490 ;
6494 ;
6497 {
6499 }
6500 | ColLabel
6501 {
6503 }
6504 ;
6506 /* Note: any simple identifier will be returned as a type name! */
6513 ;
6516 ;
6520 ;
6522 /*
6523 * Must use IDENT here to avoid reduce/reduce conflicts; fortunately none of
6524 * the item names needed in old aggregate definitions are likely to become
6525 * SQL keywords.
6526 */
6528 {
6530 }
6531 ;
6533 opt_enum_val_list:
6536 ;
6538 enum_val_list: Sconst
6540 | enum_val_list ',' Sconst
6542 ;
6544 /*****************************************************************************
6545 *
6546 * ALTER TYPE enumtype ADD ...
6547 *
6548 *****************************************************************************/
6550 AlterEnumStmt:
6551 ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst
6552 {
6562 }
6563 | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst BEFORE Sconst
6564 {
6574 }
6575 | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists Sconst AFTER Sconst
6576 {
6586 }
6587 | ALTER TYPE_P any_name RENAME VALUE_P Sconst TO Sconst
6588 {
6598 }
6599 | ALTER TYPE_P any_name DROP VALUE_P Sconst
6600 {
6601 /*
6602 * The following problems must be solved before this can be
6603 * implemented:
6604 *
6605 * - There must be no instance of the target value in
6606 * any table.
6607 *
6608 * - The value must not appear in any catalog metadata,
6609 * such as stored view expressions or column defaults.
6610 *
6611 * - The value must not appear in any non-leaf page of a
6612 * btree (and similar issues with other index types).
6613 * This is problematic because a value could persist
6614 * there long after it's gone from user-visible data.
6615 *
6616 * - Concurrent sessions must not be able to insert the
6617 * value while the preceding conditions are being checked.
6618 *
6619 * - Possibly more...
6620 */
6625 }
6626 ;
6630 ;
6633 /*****************************************************************************
6634 *
6635 * QUERIES :
6636 * CREATE OPERATOR CLASS ...
6637 * CREATE OPERATOR FAMILY ...
6638 * ALTER OPERATOR FAMILY ...
6639 * DROP OPERATOR CLASS ...
6640 * DROP OPERATOR FAMILY ...
6641 *
6642 *****************************************************************************/
6644 CreateOpClassStmt:
6645 CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename
6646 USING name opt_opfamily AS opclass_item_list
6647 {
6657 }
6658 ;
6660 opclass_item_list:
6663 ;
6665 opclass_item:
6666 OPERATOR Iconst any_operator opclass_purpose
6667 {
6678 }
6679 | OPERATOR Iconst operator_with_argtypes opclass_purpose
6680 {
6688 }
6689 | FUNCTION Iconst function_with_argtypes
6690 {
6697 }
6699 {
6707 }
6708 | STORAGE Typename
6709 {
6715 }
6716 ;
6720 ;
6724 ;
6729 ;
6732 CreateOpFamilyStmt:
6733 CREATE OPERATOR FAMILY any_name USING name
6734 {
6740 }
6741 ;
6743 AlterOpFamilyStmt:
6744 ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list
6745 {
6753 }
6754 | ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list
6755 {
6763 }
6764 ;
6766 opclass_drop_list:
6769 ;
6771 opclass_drop:
6773 {
6780 }
6782 {
6789 }
6790 ;
6793 DropOpClassStmt:
6794 DROP OPERATOR CLASS any_name USING name opt_drop_behavior
6795 {
6804 }
6805 | DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior
6806 {
6815 }
6816 ;
6818 DropOpFamilyStmt:
6819 DROP OPERATOR FAMILY any_name USING name opt_drop_behavior
6820 {
6829 }
6830 | DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior
6831 {
6840 }
6841 ;
6844 /*****************************************************************************
6845 *
6846 * QUERY:
6847 *
6848 * DROP OWNED BY username [, username ...] [ RESTRICT | CASCADE ]
6849 * REASSIGN OWNED BY username [, username ...] TO username
6850 *
6851 *****************************************************************************/
6852 DropOwnedStmt:
6853 DROP OWNED BY role_list opt_drop_behavior
6854 {
6860 }
6861 ;
6863 ReassignOwnedStmt:
6864 REASSIGN OWNED BY role_list TO RoleSpec
6865 {
6871 }
6872 ;
6874 /*****************************************************************************
6875 *
6876 * QUERY:
6877 *
6878 * DROP itemtype [ IF EXISTS ] itemname [, itemname ...]
6879 * [ RESTRICT | CASCADE ]
6880 *
6881 *****************************************************************************/
6883 DropStmt: DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior
6884 {
6893 }
6894 | DROP object_type_any_name any_name_list opt_drop_behavior
6895 {
6904 }
6905 | DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior
6906 {
6915 }
6916 | DROP drop_type_name name_list opt_drop_behavior
6917 {
6926 }
6927 | DROP object_type_name_on_any_name name ON any_name opt_drop_behavior
6928 {
6937 }
6938 | DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior
6939 {
6948 }
6949 | DROP TYPE_P type_name_list opt_drop_behavior
6950 {
6959 }
6960 | DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior
6961 {
6970 }
6971 | DROP DOMAIN_P type_name_list opt_drop_behavior
6972 {
6981 }
6982 | DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior
6983 {
6992 }
6993 | DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior
6994 {
7003 }
7004 | DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior
7005 {
7014 }
7015 ;
7017 /* object types taking any_name/any_name_list */
7018 object_type_any_name:
7032 ;
7034 /*
7035 * object types taking name/name_list
7036 *
7037 * DROP handles some of them separately
7038 */
7040 object_type_name:
7046 ;
7048 drop_type_name:
7057 ;
7059 /* object types attached to a table */
7060 object_type_name_on_any_name:
7064 ;
7066 any_name_list:
7069 ;
7073 ;
7077 | attrs '.' attr_name
7079 ;
7081 type_name_list:
7084 ;
7086 /*****************************************************************************
7087 *
7088 * QUERY:
7089 * truncate table relname1, relname2, ...
7090 *
7091 *****************************************************************************/
7093 TruncateStmt:
7094 TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior
7095 {
7102 }
7103 ;
7105 opt_restart_seqs:
7109 ;
7111 /*****************************************************************************
7112 *
7113 * COMMENT ON <object> IS <text>
7114 *
7115 *****************************************************************************/
7117 CommentStmt:
7118 COMMENT ON object_type_any_name any_name IS comment_text
7119 {
7126 }
7127 | COMMENT ON COLUMN any_name IS comment_text
7128 {
7135 }
7136 | COMMENT ON object_type_name name IS comment_text
7137 {
7144 }
7145 | COMMENT ON TYPE_P Typename IS comment_text
7146 {
7153 }
7154 | COMMENT ON DOMAIN_P Typename IS comment_text
7155 {
7162 }
7163 | COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text
7164 {
7171 }
7172 | COMMENT ON FUNCTION function_with_argtypes IS comment_text
7173 {
7180 }
7181 | COMMENT ON OPERATOR operator_with_argtypes IS comment_text
7182 {
7189 }
7190 | COMMENT ON CONSTRAINT name ON any_name IS comment_text
7191 {
7198 }
7199 | COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text
7200 {
7204 /*
7205 * should use Typename not any_name in the production, but
7206 * there's a shift/reduce conflict if we do that, so fix it
7207 * up here.
7208 */
7212 }
7213 | COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text
7214 {
7221 }
7222 | COMMENT ON PROCEDURE function_with_argtypes IS comment_text
7223 {
7230 }
7231 | COMMENT ON ROUTINE function_with_argtypes IS comment_text
7232 {
7239 }
7240 | COMMENT ON TRANSFORM FOR Typename LANGUAGE name IS comment_text
7241 {
7248 }
7249 | COMMENT ON OPERATOR CLASS any_name USING name IS comment_text
7250 {
7257 }
7258 | COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text
7259 {
7266 }
7267 | COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
7268 {
7275 }
7277 {
7284 }
7285 ;
7287 comment_text:
7290 ;
7293 /*****************************************************************************
7294 *
7295 * SECURITY LABEL [FOR <provider>] ON <object> IS <label>
7296 *
7297 * As with COMMENT ON, <object> can refer to various types of database
7298 * objects (e.g. TABLE, COLUMN, etc.).
7299 *
7300 *****************************************************************************/
7302 SecLabelStmt:
7303 SECURITY LABEL opt_provider ON object_type_any_name any_name
7304 IS security_label
7305 {
7313 }
7314 | SECURITY LABEL opt_provider ON COLUMN any_name
7315 IS security_label
7316 {
7324 }
7325 | SECURITY LABEL opt_provider ON object_type_name name
7326 IS security_label
7327 {
7335 }
7336 | SECURITY LABEL opt_provider ON TYPE_P Typename
7337 IS security_label
7338 {
7346 }
7347 | SECURITY LABEL opt_provider ON DOMAIN_P Typename
7348 IS security_label
7349 {
7357 }
7358 | SECURITY LABEL opt_provider ON AGGREGATE aggregate_with_argtypes
7359 IS security_label
7360 {
7368 }
7369 | SECURITY LABEL opt_provider ON FUNCTION function_with_argtypes
7370 IS security_label
7371 {
7379 }
7380 | SECURITY LABEL opt_provider ON LARGE_P OBJECT_P NumericOnly
7381 IS security_label
7382 {
7390 }
7391 | SECURITY LABEL opt_provider ON PROCEDURE function_with_argtypes
7392 IS security_label
7393 {
7401 }
7402 | SECURITY LABEL opt_provider ON ROUTINE function_with_argtypes
7403 IS security_label
7404 {
7412 }
7413 ;
7417 ;
7421 ;
7423 /*****************************************************************************
7424 *
7425 * QUERY:
7426 * fetch/move
7427 *
7428 *****************************************************************************/
7430 FetchStmt: FETCH fetch_args
7431 {
7436 }
7437 | MOVE fetch_args
7438 {
7443 }
7444 ;
7446 fetch_args: cursor_name
7447 {
7454 }
7455 | from_in cursor_name
7456 {
7463 }
7464 | NEXT opt_from_in cursor_name
7465 {
7472 }
7473 | PRIOR opt_from_in cursor_name
7474 {
7481 }
7482 | FIRST_P opt_from_in cursor_name
7483 {
7490 }
7491 | LAST_P opt_from_in cursor_name
7492 {
7499 }
7500 | ABSOLUTE_P SignedIconst opt_from_in cursor_name
7501 {
7508 }
7509 | RELATIVE_P SignedIconst opt_from_in cursor_name
7510 {
7517 }
7518 | SignedIconst opt_from_in cursor_name
7519 {
7526 }
7527 | ALL opt_from_in cursor_name
7528 {
7535 }
7536 | FORWARD opt_from_in cursor_name
7537 {
7544 }
7545 | FORWARD SignedIconst opt_from_in cursor_name
7546 {
7553 }
7554 | FORWARD ALL opt_from_in cursor_name
7555 {
7562 }
7563 | BACKWARD opt_from_in cursor_name
7564 {
7571 }
7572 | BACKWARD SignedIconst opt_from_in cursor_name
7573 {
7580 }
7581 | BACKWARD ALL opt_from_in cursor_name
7582 {
7589 }
7590 ;
7592 from_in: FROM
7593 | IN_P
7594 ;
7596 opt_from_in: from_in
7597 | /* EMPTY */
7598 ;
7601 /*****************************************************************************
7602 *
7603 * GRANT and REVOKE statements
7604 *
7605 *****************************************************************************/
7607 GrantStmt: GRANT privileges ON privilege_target TO grantee_list
7608 opt_grant_grant_option opt_granted_by
7609 {
7621 }
7622 ;
7624 RevokeStmt:
7625 REVOKE privileges ON privilege_target
7626 FROM grantee_list opt_granted_by opt_drop_behavior
7627 {
7640 }
7641 | REVOKE GRANT OPTION FOR privileges ON privilege_target
7642 FROM grantee_list opt_granted_by opt_drop_behavior
7643 {
7656 }
7657 ;
7660 /*
7661 * Privilege names are represented as strings; the validity of the privilege
7662 * names gets checked at execution. This is a bit annoying but we have little
7663 * choice because of the syntactic conflict with lists of role names in
7664 * GRANT/REVOKE. What's more, we have to call out in the "privilege"
7665 * production any reserved keywords that need to be usable as privilege names.
7666 */
7668 /* either ALL [PRIVILEGES] or a list of individual privileges */
7669 privileges: privilege_list
7671 | ALL
7673 | ALL PRIVILEGES
7676 {
7682 }
7684 {
7690 }
7691 ;
7695 ;
7697 privilege: SELECT opt_column_list
7698 {
7704 }
7705 | REFERENCES opt_column_list
7706 {
7712 }
7713 | CREATE opt_column_list
7714 {
7720 }
7721 | ALTER SYSTEM_P
7722 {
7727 }
7728 | ColId opt_column_list
7729 {
7735 }
7736 ;
7738 parameter_name_list:
7739 parameter_name
7740 {
7742 }
7743 | parameter_name_list ',' parameter_name
7744 {
7746 }
7747 ;
7749 parameter_name:
7750 ColId
7751 {
7753 }
7754 | parameter_name '.' ColId
7755 {
7757 }
7758 ;
7761 /* Don't bother trying to fold the first two rules into one using
7762 * opt_table. You're going to get conflicts.
7763 */
7764 privilege_target:
7765 qualified_name_list
7766 {
7773 }
7774 | TABLE qualified_name_list
7775 {
7782 }
7783 | SEQUENCE qualified_name_list
7784 {
7791 }
7792 | FOREIGN DATA_P WRAPPER name_list
7793 {
7800 }
7801 | FOREIGN SERVER name_list
7802 {
7809 }
7810 | FUNCTION function_with_argtypes_list
7811 {
7818 }
7819 | PROCEDURE function_with_argtypes_list
7820 {
7827 }
7828 | ROUTINE function_with_argtypes_list
7829 {
7836 }
7837 | DATABASE name_list
7838 {
7845 }
7846 | DOMAIN_P any_name_list
7847 {
7854 }
7855 | LANGUAGE name_list
7856 {
7863 }
7864 | LARGE_P OBJECT_P NumericOnly_list
7865 {
7872 }
7873 | PARAMETER parameter_name_list
7874 {
7880 }
7881 | SCHEMA name_list
7882 {
7889 }
7890 | TABLESPACE name_list
7891 {
7898 }
7899 | TYPE_P any_name_list
7900 {
7907 }
7908 | ALL TABLES IN_P SCHEMA name_list
7909 {
7916 }
7917 | ALL SEQUENCES IN_P SCHEMA name_list
7918 {
7925 }
7926 | ALL FUNCTIONS IN_P SCHEMA name_list
7927 {
7934 }
7935 | ALL PROCEDURES IN_P SCHEMA name_list
7936 {
7943 }
7944 | ALL ROUTINES IN_P SCHEMA name_list
7945 {
7952 }
7953 ;
7956 grantee_list:
7959 ;
7961 grantee:
7964 ;
7967 opt_grant_grant_option:
7970 ;
7972 /*****************************************************************************
7973 *
7974 * GRANT and REVOKE ROLE statements
7975 *
7976 *****************************************************************************/
7978 GrantRoleStmt:
7979 GRANT privilege_list TO role_list opt_granted_by
7980 {
7989 }
7990 | GRANT privilege_list TO role_list WITH grant_role_opt_list opt_granted_by
7991 {
8000 }
8001 ;
8003 RevokeRoleStmt:
8004 REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior
8005 {
8015 }
8016 | REVOKE ColId OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior
8017 {
8030 }
8031 ;
8033 grant_role_opt_list:
8036 ;
8038 grant_role_opt:
8039 ColLabel grant_role_opt_value
8040 {
8042 }
8043 ;
8045 grant_role_opt_value:
8049 ;
8053 ;
8055 /*****************************************************************************
8056 *
8057 * ALTER DEFAULT PRIVILEGES statement
8058 *
8059 *****************************************************************************/
8061 AlterDefaultPrivilegesStmt:
8062 ALTER DEFAULT PRIVILEGES DefACLOptionList DefACLAction
8063 {
8069 }
8070 ;
8072 DefACLOptionList:
8075 ;
8077 DefACLOption:
8078 IN_P SCHEMA name_list
8079 {
8081 }
8082 | FOR ROLE role_list
8083 {
8085 }
8086 | FOR USER role_list
8087 {
8089 }
8090 ;
8092 /*
8093 * This should match GRANT/REVOKE, except that individual target objects
8094 * are not mentioned and we only allow a subset of object types.
8095 */
8096 DefACLAction:
8097 GRANT privileges ON defacl_privilege_target TO grantee_list
8098 opt_grant_grant_option
8099 {
8110 }
8111 | REVOKE privileges ON defacl_privilege_target
8112 FROM grantee_list opt_drop_behavior
8113 {
8125 }
8126 | REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target
8127 FROM grantee_list opt_drop_behavior
8128 {
8140 }
8141 ;
8143 defacl_privilege_target:
8150 ;
8153 /*****************************************************************************
8154 *
8155 * QUERY: CREATE INDEX
8156 *
8157 * Note: we cannot put TABLESPACE clause after WHERE clause unless we are
8158 * willing to make TABLESPACE a fully reserved word.
8159 *****************************************************************************/
8161 IndexStmt: CREATE opt_unique INDEX opt_concurrently opt_single_name
8163 opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
8164 {
8192 }
8193 | CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name
8195 opt_include opt_unique_null_treatment opt_reloptions OptTableSpace where_clause
8196 {
8224 }
8225 ;
8227 opt_unique:
8230 ;
8232 access_method_clause:
8235 ;
8239 ;
8242 index_elem_options:
8243 opt_collate opt_qualified_name opt_asc_desc opt_nulls_order
8244 {
8254 }
8255 | opt_collate any_name reloptions opt_asc_desc opt_nulls_order
8256 {
8266 }
8267 ;
8269 /*
8270 * Index attributes can be either simple column references, or arbitrary
8271 * expressions in parens. For backwards-compatibility reasons, we allow
8272 * an expression that's just a function call to be written without parens.
8273 */
8274 index_elem: ColId index_elem_options
8275 {
8278 }
8279 | func_expr_windowless index_elem_options
8280 {
8283 }
8285 {
8288 }
8289 ;
8293 ;
8297 ;
8301 ;
8307 ;
8312 ;
8315 /*****************************************************************************
8316 *
8317 * QUERY:
8318 * create [or replace] function <fname>
8319 * [(<type-1> { , <type-n>})]
8320 * returns <type-r>
8321 * as <filename or code in language as appropriate>
8322 * language <lang> [with parameters]
8323 *
8324 *****************************************************************************/
8326 CreateFunctionStmt:
8327 CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
8328 RETURNS func_return opt_createfunc_opt_list opt_routine_body
8329 {
8340 }
8341 | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
8343 {
8355 }
8356 | CREATE opt_or_replace FUNCTION func_name func_args_with_defaults
8357 opt_createfunc_opt_list opt_routine_body
8358 {
8369 }
8370 | CREATE opt_or_replace PROCEDURE func_name func_args_with_defaults
8371 opt_createfunc_opt_list opt_routine_body
8372 {
8383 }
8384 ;
8386 opt_or_replace:
8389 ;
8393 ;
8395 func_args_list:
8398 ;
8400 function_with_argtypes_list:
8402 | function_with_argtypes_list ',' function_with_argtypes
8404 ;
8406 function_with_argtypes:
8407 func_name func_args
8408 {
8415 }
8416 /*
8417 * Because of reduce/reduce conflicts, we can't use func_name
8418 * below, but we can write it out the long way, which actually
8419 * allows more cases.
8420 */
8421 | type_func_name_keyword
8422 {
8428 }
8429 | ColId
8430 {
8436 }
8437 | ColId indirection
8438 {
8442 yyscanner);
8445 }
8446 ;
8448 /*
8449 * func_args_with_defaults is separate because we only want to accept
8450 * defaults in CREATE FUNCTION, not in ALTER etc.
8451 */
8452 func_args_with_defaults:
8455 ;
8457 func_args_with_defaults_list:
8459 | func_args_with_defaults_list ',' func_arg_with_default
8461 ;
8463 /*
8464 * The style with arg_class first is SQL99 standard, but Oracle puts
8465 * param_name first; accept both since it's likely people will try both
8466 * anyway. Don't bother trying to save productions by letting arg_class
8467 * have an empty alternative ... you'll get shift/reduce conflicts.
8468 *
8469 * We can catch over-specified arguments here if we want to,
8470 * but for now better to silently swallow typmod, etc.
8471 * - thomas 2000-03-22
8472 */
8473 func_arg:
8474 arg_class param_name func_type
8475 {
8484 }
8485 | param_name arg_class func_type
8486 {
8495 }
8496 | param_name func_type
8497 {
8506 }
8507 | arg_class func_type
8508 {
8517 }
8518 | func_type
8519 {
8528 }
8529 ;
8531 /* INOUT is SQL99 standard, IN OUT is for Oracle compatibility */
8537 ;
8539 /*
8540 * Ideally param_name should be ColId, but that causes too many conflicts.
8541 */
8542 param_name: type_function_name
8543 ;
8545 func_return:
8546 func_type
8547 {
8548 /* We can catch over-specified results here if we want to,
8549 * but for now better to silently swallow typmod, etc.
8550 * - thomas 2000-03-22
8551 */
8553 }
8554 ;
8556 /*
8557 * We would like to make the %TYPE productions here be ColId attrs etc,
8558 * but that causes reduce/reduce conflicts. type_function_name
8559 * is next best choice.
8560 */
8562 | type_function_name attrs '%' TYPE_P
8563 {
8567 }
8568 | SETOF type_function_name attrs '%' TYPE_P
8569 {
8574 }
8575 ;
8577 func_arg_with_default:
8578 func_arg
8579 {
8581 }
8582 | func_arg DEFAULT a_expr
8583 {
8586 }
8587 | func_arg '=' a_expr
8588 {
8591 }
8592 ;
8594 /* Aggregate args can be most things that function args can be */
8595 aggr_arg: func_arg
8596 {
8605 }
8606 ;
8608 /*
8609 * The SQL standard offers no guidance on how to declare aggregate argument
8610 * lists, since it doesn't have CREATE AGGREGATE etc. We accept these cases:
8611 *
8612 * (*) - normal agg with no args
8613 * (aggr_arg,...) - normal agg with args
8614 * (ORDER BY aggr_arg,...) - ordered-set agg with no direct args
8615 * (aggr_arg,... ORDER BY aggr_arg,...) - ordered-set agg with direct args
8616 *
8617 * The zero-argument case is spelled with '*' for consistency with COUNT(*).
8618 *
8619 * An additional restriction is that if the direct-args list ends in a
8620 * VARIADIC item, the ordered-args list must contain exactly one item that
8621 * is also VARIADIC with the same type. This allows us to collapse the two
8622 * VARIADIC items into one, which is necessary to represent the aggregate in
8623 * pg_proc. We check this at the grammar stage so that we can return a list
8624 * in which the second VARIADIC item is already discarded, avoiding extra work
8625 * in cases such as DROP AGGREGATE.
8626 *
8627 * The return value of this production is a two-element list, in which the
8628 * first item is a sublist of FunctionParameter nodes (with any duplicate
8629 * VARIADIC item already dropped, as per above) and the second is an Integer
8630 * node, containing -1 if there was no ORDER BY and otherwise the number
8631 * of argument declarations before the ORDER BY. (If this number is equal
8632 * to the first sublist's length, then we dropped a duplicate VARIADIC item.)
8633 * This representation is passed as-is to CREATE AGGREGATE; for operations
8634 * on existing aggregates, we can just apply extractArgTypes to the first
8635 * sublist.
8636 */
8638 {
8640 }
8642 {
8644 }
8646 {
8648 }
8650 {
8651 /* this is the only case requiring consistency checking */
8653 }
8654 ;
8656 aggr_args_list:
8659 ;
8661 aggregate_with_argtypes:
8662 func_name aggr_args
8663 {
8670 }
8671 ;
8673 aggregate_with_argtypes_list:
8675 | aggregate_with_argtypes_list ',' aggregate_with_argtypes
8677 ;
8679 opt_createfunc_opt_list:
8680 createfunc_opt_list
8682 ;
8684 createfunc_opt_list:
8685 /* Must be at least one to prevent conflict */
8688 ;
8690 /*
8691 * Options common to both CREATE FUNCTION and ALTER FUNCTION
8692 */
8693 common_func_opt_item:
8694 CALLED ON NULL_P INPUT_P
8695 {
8697 }
8698 | RETURNS NULL_P ON NULL_P INPUT_P
8699 {
8701 }
8702 | STRICT_P
8703 {
8705 }
8706 | IMMUTABLE
8707 {
8709 }
8710 | STABLE
8711 {
8713 }
8714 | VOLATILE
8715 {
8717 }
8718 | EXTERNAL SECURITY DEFINER
8719 {
8721 }
8722 | EXTERNAL SECURITY INVOKER
8723 {
8725 }
8726 | SECURITY DEFINER
8727 {
8729 }
8730 | SECURITY INVOKER
8731 {
8733 }
8734 | LEAKPROOF
8735 {
8737 }
8738 | NOT LEAKPROOF
8739 {
8741 }
8742 | COST NumericOnly
8743 {
8745 }
8746 | ROWS NumericOnly
8747 {
8749 }
8750 | SUPPORT any_name
8751 {
8753 }
8754 | FunctionSetResetClause
8755 {
8756 /* we abuse the normal content of a DefElem here */
8758 }
8759 | PARALLEL ColId
8760 {
8762 }
8763 ;
8765 createfunc_opt_item:
8766 AS func_as
8767 {
8769 }
8770 | LANGUAGE NonReservedWord_or_Sconst
8771 {
8773 }
8774 | TRANSFORM transform_type_list
8775 {
8777 }
8778 | WINDOW
8779 {
8781 }
8782 | common_func_opt_item
8783 {
8785 }
8786 ;
8789 | Sconst ',' Sconst
8790 {
8792 }
8793 ;
8795 ReturnStmt: RETURN a_expr
8796 {
8801 }
8802 ;
8804 opt_routine_body:
8805 ReturnStmt
8806 {
8808 }
8809 | BEGIN_P ATOMIC routine_body_stmt_list END_P
8810 {
8811 /*
8812 * A compound statement is stored as a single-item list
8813 * containing the list of statements as its member. That
8814 * way, the parse analysis code can tell apart an empty
8815 * body from no body at all.
8816 */
8818 }
8819 | /*EMPTY*/
8820 {
8822 }
8823 ;
8825 routine_body_stmt_list:
8826 routine_body_stmt_list routine_body_stmt ';'
8827 {
8828 /* As in stmtmulti, discard empty statements */
8831 else
8833 }
8834 | /*EMPTY*/
8835 {
8837 }
8838 ;
8840 routine_body_stmt:
8841 stmt
8842 | ReturnStmt
8843 ;
8845 transform_type_list:
8848 ;
8850 opt_definition:
8853 ;
8855 table_func_column: param_name func_type
8856 {
8865 }
8866 ;
8868 table_func_column_list:
8869 table_func_column
8870 {
8872 }
8873 | table_func_column_list ',' table_func_column
8874 {
8876 }
8877 ;
8879 /*****************************************************************************
8880 * ALTER FUNCTION / ALTER PROCEDURE / ALTER ROUTINE
8881 *
8882 * RENAME and OWNER subcommands are already provided by the generic
8883 * ALTER infrastructure, here we just specify alterations that can
8884 * only be applied to functions.
8885 *
8886 *****************************************************************************/
8887 AlterFunctionStmt:
8888 ALTER FUNCTION function_with_argtypes alterfunc_opt_list opt_restrict
8889 {
8896 }
8897 | ALTER PROCEDURE function_with_argtypes alterfunc_opt_list opt_restrict
8898 {
8905 }
8906 | ALTER ROUTINE function_with_argtypes alterfunc_opt_list opt_restrict
8907 {
8914 }
8915 ;
8917 alterfunc_opt_list:
8918 /* At least one option must be specified */
8921 ;
8923 /* Ignored, merely for SQL compliance */
8924 opt_restrict:
8925 RESTRICT
8926 | /* EMPTY */
8927 ;
8930 /*****************************************************************************
8931 *
8932 * QUERY:
8933 *
8934 * DROP FUNCTION funcname (arg1, arg2, ...) [ RESTRICT | CASCADE ]
8935 * DROP PROCEDURE procname (arg1, arg2, ...) [ RESTRICT | CASCADE ]
8936 * DROP ROUTINE routname (arg1, arg2, ...) [ RESTRICT | CASCADE ]
8937 * DROP AGGREGATE aggname (arg1, ...) [ RESTRICT | CASCADE ]
8938 * DROP OPERATOR opname (leftoperand_typ, rightoperand_typ) [ RESTRICT | CASCADE ]
8939 *
8940 *****************************************************************************/
8942 RemoveFuncStmt:
8943 DROP FUNCTION function_with_argtypes_list opt_drop_behavior
8944 {
8953 }
8954 | DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior
8955 {
8964 }
8965 | DROP PROCEDURE function_with_argtypes_list opt_drop_behavior
8966 {
8975 }
8976 | DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
8977 {
8986 }
8987 | DROP ROUTINE function_with_argtypes_list opt_drop_behavior
8988 {
8997 }
8998 | DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior
8999 {
9008 }
9009 ;
9011 RemoveAggrStmt:
9012 DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior
9013 {
9022 }
9023 | DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior
9024 {
9033 }
9034 ;
9036 RemoveOperStmt:
9037 DROP OPERATOR operator_with_argtypes_list opt_drop_behavior
9038 {
9047 }
9048 | DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior
9049 {
9058 }
9059 ;
9061 oper_argtypes:
9063 {
9069 }
9076 ;
9078 any_operator:
9079 all_Op
9081 | ColId '.' any_operator
9083 ;
9085 operator_with_argtypes_list:
9087 | operator_with_argtypes_list ',' operator_with_argtypes
9089 ;
9091 operator_with_argtypes:
9092 any_operator oper_argtypes
9093 {
9099 }
9100 ;
9102 /*****************************************************************************
9103 *
9104 * DO <anonymous code block> [ LANGUAGE language ]
9105 *
9106 * We use a DefElem list for future extensibility, and to allow flexibility
9107 * in the clause order.
9108 *
9109 *****************************************************************************/
9111 DoStmt: DO dostmt_opt_list
9112 {
9117 }
9118 ;
9120 dostmt_opt_list:
9123 ;
9125 dostmt_opt_item:
9126 Sconst
9127 {
9129 }
9130 | LANGUAGE NonReservedWord_or_Sconst
9131 {
9133 }
9134 ;
9136 /*****************************************************************************
9137 *
9138 * CREATE CAST / DROP CAST
9139 *
9140 *****************************************************************************/
9143 WITH FUNCTION function_with_argtypes cast_context
9144 {
9153 }
9155 WITHOUT FUNCTION cast_context
9156 {
9165 }
9167 WITH INOUT cast_context
9168 {
9177 }
9178 ;
9183 ;
9187 {
9196 }
9197 ;
9201 ;
9204 /*****************************************************************************
9205 *
9206 * CREATE TRANSFORM / DROP TRANSFORM
9207 *
9208 *****************************************************************************/
9210 CreateTransformStmt: CREATE opt_or_replace TRANSFORM FOR Typename LANGUAGE name '(' transform_element_list ')'
9211 {
9220 }
9221 ;
9223 transform_element_list: FROM SQL_P WITH FUNCTION function_with_argtypes ',' TO SQL_P WITH FUNCTION function_with_argtypes
9224 {
9226 }
9227 | TO SQL_P WITH FUNCTION function_with_argtypes ',' FROM SQL_P WITH FUNCTION function_with_argtypes
9228 {
9230 }
9231 | FROM SQL_P WITH FUNCTION function_with_argtypes
9232 {
9234 }
9235 | TO SQL_P WITH FUNCTION function_with_argtypes
9236 {
9238 }
9239 ;
9242 DropTransformStmt: DROP TRANSFORM opt_if_exists FOR Typename LANGUAGE name opt_drop_behavior
9243 {
9251 }
9252 ;
9255 /*****************************************************************************
9256 *
9257 * QUERY:
9258 *
9259 * REINDEX [ (options) ] {INDEX | TABLE | SCHEMA} [CONCURRENTLY] <name>
9260 * REINDEX [ (options) ] {DATABASE | SYSTEM} [CONCURRENTLY] [<name>]
9261 *****************************************************************************/
9263 ReindexStmt:
9264 REINDEX opt_reindex_option_list reindex_target_relation opt_concurrently qualified_name
9265 {
9276 }
9277 | REINDEX opt_reindex_option_list SCHEMA opt_concurrently name
9278 {
9289 }
9290 | REINDEX opt_reindex_option_list reindex_target_all opt_concurrently opt_single_name
9291 {
9302 }
9303 ;
9304 reindex_target_relation:
9307 ;
9308 reindex_target_all:
9311 ;
9312 opt_reindex_option_list:
9315 ;
9317 /*****************************************************************************
9318 *
9319 * ALTER TABLESPACE
9320 *
9321 *****************************************************************************/
9323 AlterTblSpcStmt:
9324 ALTER TABLESPACE name SET reloptions
9325 {
9333 }
9334 | ALTER TABLESPACE name RESET reloptions
9335 {
9343 }
9344 ;
9346 /*****************************************************************************
9347 *
9348 * ALTER THING name RENAME TO newname
9349 *
9350 *****************************************************************************/
9352 RenameStmt: ALTER AGGREGATE aggregate_with_argtypes RENAME TO name
9353 {
9361 }
9362 | ALTER COLLATION any_name RENAME TO name
9363 {
9371 }
9372 | ALTER CONVERSION_P any_name RENAME TO name
9373 {
9381 }
9382 | ALTER DATABASE name RENAME TO name
9383 {
9391 }
9392 | ALTER DOMAIN_P any_name RENAME TO name
9393 {
9401 }
9402 | ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name
9403 {
9411 }
9412 | ALTER FOREIGN DATA_P WRAPPER name RENAME TO name
9413 {
9421 }
9422 | ALTER FUNCTION function_with_argtypes RENAME TO name
9423 {
9431 }
9432 | ALTER GROUP_P RoleId RENAME TO RoleId
9433 {
9441 }
9442 | ALTER opt_procedural LANGUAGE name RENAME TO name
9443 {
9451 }
9452 | ALTER OPERATOR CLASS any_name USING name RENAME TO name
9453 {
9461 }
9462 | ALTER OPERATOR FAMILY any_name USING name RENAME TO name
9463 {
9471 }
9472 | ALTER POLICY name ON qualified_name RENAME TO name
9473 {
9482 }
9483 | ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name
9484 {
9493 }
9494 | ALTER PROCEDURE function_with_argtypes RENAME TO name
9495 {
9503 }
9504 | ALTER PUBLICATION name RENAME TO name
9505 {
9513 }
9514 | ALTER ROUTINE function_with_argtypes RENAME TO name
9515 {
9523 }
9524 | ALTER SCHEMA name RENAME TO name
9525 {
9533 }
9534 | ALTER SERVER name RENAME TO name
9535 {
9543 }
9544 | ALTER SUBSCRIPTION name RENAME TO name
9545 {
9553 }
9554 | ALTER TABLE relation_expr RENAME TO name
9555 {
9564 }
9565 | ALTER TABLE IF_P EXISTS relation_expr RENAME TO name
9566 {
9575 }
9576 | ALTER SEQUENCE qualified_name RENAME TO name
9577 {
9586 }
9587 | ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name
9588 {
9597 }
9598 | ALTER VIEW qualified_name RENAME TO name
9599 {
9608 }
9609 | ALTER VIEW IF_P EXISTS qualified_name RENAME TO name
9610 {
9619 }
9620 | ALTER MATERIALIZED VIEW qualified_name RENAME TO name
9621 {
9630 }
9631 | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name
9632 {
9641 }
9642 | ALTER INDEX qualified_name RENAME TO name
9643 {
9652 }
9653 | ALTER INDEX IF_P EXISTS qualified_name RENAME TO name
9654 {
9663 }
9664 | ALTER FOREIGN TABLE relation_expr RENAME TO name
9665 {
9674 }
9675 | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name
9676 {
9685 }
9686 | ALTER TABLE relation_expr RENAME opt_column name TO name
9687 {
9697 }
9698 | ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
9699 {
9709 }
9710 | ALTER VIEW qualified_name RENAME opt_column name TO name
9711 {
9721 }
9722 | ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
9723 {
9733 }
9734 | ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name
9735 {
9745 }
9746 | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name
9747 {
9757 }
9758 | ALTER TABLE relation_expr RENAME CONSTRAINT name TO name
9759 {
9768 }
9769 | ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name
9770 {
9779 }
9780 | ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name
9781 {
9791 }
9792 | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name
9793 {
9803 }
9804 | ALTER RULE name ON qualified_name RENAME TO name
9805 {
9814 }
9815 | ALTER TRIGGER name ON qualified_name RENAME TO name
9816 {
9825 }
9826 | ALTER EVENT TRIGGER name RENAME TO name
9827 {
9834 }
9835 | ALTER ROLE RoleId RENAME TO RoleId
9836 {
9844 }
9845 | ALTER USER RoleId RENAME TO RoleId
9846 {
9854 }
9855 | ALTER TABLESPACE name RENAME TO name
9856 {
9864 }
9865 | ALTER STATISTICS any_name RENAME TO name
9866 {
9874 }
9875 | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name
9876 {
9884 }
9885 | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name
9886 {
9894 }
9895 | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name
9896 {
9904 }
9905 | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name
9906 {
9914 }
9915 | ALTER TYPE_P any_name RENAME TO name
9916 {
9924 }
9925 | ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior
9926 {
9937 }
9938 ;
9940 opt_column: COLUMN
9941 | /*EMPTY*/
9942 ;
9946 ;
9948 /*****************************************************************************
9949 *
9950 * ALTER THING name DEPENDS ON EXTENSION name
9951 *
9952 *****************************************************************************/
9954 AlterObjectDependsStmt:
9955 ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name
9956 {
9964 }
9965 | ALTER PROCEDURE function_with_argtypes opt_no DEPENDS ON EXTENSION name
9966 {
9974 }
9975 | ALTER ROUTINE function_with_argtypes opt_no DEPENDS ON EXTENSION name
9976 {
9984 }
9985 | ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name
9986 {
9995 }
9996 | ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name
9997 {
10005 }
10006 | ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name
10007 {
10015 }
10016 ;
10020 ;
10022 /*****************************************************************************
10023 *
10024 * ALTER THING name SET SCHEMA name
10025 *
10026 *****************************************************************************/
10028 AlterObjectSchemaStmt:
10029 ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name
10030 {
10038 }
10039 | ALTER COLLATION any_name SET SCHEMA name
10040 {
10048 }
10049 | ALTER CONVERSION_P any_name SET SCHEMA name
10050 {
10058 }
10059 | ALTER DOMAIN_P any_name SET SCHEMA name
10060 {
10068 }
10069 | ALTER EXTENSION name SET SCHEMA name
10070 {
10078 }
10079 | ALTER FUNCTION function_with_argtypes SET SCHEMA name
10080 {
10088 }
10089 | ALTER OPERATOR operator_with_argtypes SET SCHEMA name
10090 {
10098 }
10099 | ALTER OPERATOR CLASS any_name USING name SET SCHEMA name
10100 {
10108 }
10109 | ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name
10110 {
10118 }
10119 | ALTER PROCEDURE function_with_argtypes SET SCHEMA name
10120 {
10128 }
10129 | ALTER ROUTINE function_with_argtypes SET SCHEMA name
10130 {
10138 }
10139 | ALTER TABLE relation_expr SET SCHEMA name
10140 {
10148 }
10149 | ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name
10150 {
10158 }
10159 | ALTER STATISTICS any_name SET SCHEMA name
10160 {
10168 }
10169 | ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name
10170 {
10178 }
10179 | ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name
10180 {
10188 }
10189 | ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name
10190 {
10198 }
10199 | ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name
10200 {
10208 }
10209 | ALTER SEQUENCE qualified_name SET SCHEMA name
10210 {
10218 }
10219 | ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name
10220 {
10228 }
10229 | ALTER VIEW qualified_name SET SCHEMA name
10230 {
10238 }
10239 | ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name
10240 {
10248 }
10249 | ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name
10250 {
10258 }
10259 | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name
10260 {
10268 }
10269 | ALTER FOREIGN TABLE relation_expr SET SCHEMA name
10270 {
10278 }
10279 | ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name
10280 {
10288 }
10289 | ALTER TYPE_P any_name SET SCHEMA name
10290 {
10298 }
10299 ;
10301 /*****************************************************************************
10302 *
10303 * ALTER OPERATOR name SET define
10304 *
10305 *****************************************************************************/
10307 AlterOperatorStmt:
10309 {
10315 }
10316 ;
10320 ;
10324 | ColLabel '=' operator_def_arg
10326 | ColLabel
10328 ;
10330 /* must be similar enough to def_arg to avoid reduce/reduce conflicts */
10331 operator_def_arg:
10337 ;
10339 /*****************************************************************************
10340 *
10341 * ALTER TYPE name SET define
10342 *
10343 * We repurpose ALTER OPERATOR's version of "definition" here
10344 *
10345 *****************************************************************************/
10347 AlterTypeStmt:
10349 {
10355 }
10356 ;
10358 /*****************************************************************************
10359 *
10360 * ALTER THING name OWNER TO newname
10361 *
10362 *****************************************************************************/
10364 AlterOwnerStmt: ALTER AGGREGATE aggregate_with_argtypes OWNER TO RoleSpec
10365 {
10372 }
10373 | ALTER COLLATION any_name OWNER TO RoleSpec
10374 {
10381 }
10382 | ALTER CONVERSION_P any_name OWNER TO RoleSpec
10383 {
10390 }
10391 | ALTER DATABASE name OWNER TO RoleSpec
10392 {
10399 }
10400 | ALTER DOMAIN_P any_name OWNER TO RoleSpec
10401 {
10408 }
10409 | ALTER FUNCTION function_with_argtypes OWNER TO RoleSpec
10410 {
10417 }
10418 | ALTER opt_procedural LANGUAGE name OWNER TO RoleSpec
10419 {
10426 }
10427 | ALTER LARGE_P OBJECT_P NumericOnly OWNER TO RoleSpec
10428 {
10435 }
10436 | ALTER OPERATOR operator_with_argtypes OWNER TO RoleSpec
10437 {
10444 }
10445 | ALTER OPERATOR CLASS any_name USING name OWNER TO RoleSpec
10446 {
10453 }
10454 | ALTER OPERATOR FAMILY any_name USING name OWNER TO RoleSpec
10455 {
10462 }
10463 | ALTER PROCEDURE function_with_argtypes OWNER TO RoleSpec
10464 {
10471 }
10472 | ALTER ROUTINE function_with_argtypes OWNER TO RoleSpec
10473 {
10480 }
10481 | ALTER SCHEMA name OWNER TO RoleSpec
10482 {
10489 }
10490 | ALTER TYPE_P any_name OWNER TO RoleSpec
10491 {
10498 }
10499 | ALTER TABLESPACE name OWNER TO RoleSpec
10500 {
10507 }
10508 | ALTER STATISTICS any_name OWNER TO RoleSpec
10509 {
10516 }
10517 | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO RoleSpec
10518 {
10525 }
10526 | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO RoleSpec
10527 {
10534 }
10535 | ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleSpec
10536 {
10543 }
10544 | ALTER SERVER name OWNER TO RoleSpec
10545 {
10552 }
10553 | ALTER EVENT TRIGGER name OWNER TO RoleSpec
10554 {
10561 }
10562 | ALTER PUBLICATION name OWNER TO RoleSpec
10563 {
10570 }
10571 | ALTER SUBSCRIPTION name OWNER TO RoleSpec
10572 {
10579 }
10580 ;
10583 /*****************************************************************************
10584 *
10585 * CREATE PUBLICATION name [WITH options]
10586 *
10587 * CREATE PUBLICATION FOR ALL TABLES [WITH options]
10588 *
10589 * CREATE PUBLICATION FOR pub_obj [, ...] [WITH options]
10590 *
10591 * pub_obj is one of:
10592 *
10593 * TABLE table [, ...]
10594 * TABLES IN SCHEMA schema [, ...]
10595 *
10596 *****************************************************************************/
10598 CreatePublicationStmt:
10599 CREATE PUBLICATION name opt_definition
10600 {
10606 }
10607 | CREATE PUBLICATION name FOR ALL TABLES opt_definition
10608 {
10615 }
10616 | CREATE PUBLICATION name FOR pub_obj_list opt_definition
10617 {
10625 }
10626 ;
10628 /*
10629 * FOR TABLE and FOR TABLES IN SCHEMA specifications
10630 *
10631 * This rule parses publication objects with and without keyword prefixes.
10632 *
10633 * The actual type of the object without keyword prefix depends on the previous
10634 * one with keyword prefix. It will be preprocessed in preprocess_pubobj_list().
10635 *
10636 * For the object without keyword prefix, we cannot just use relation_expr here,
10637 * because some extended expressions in relation_expr cannot be used as a
10638 * schemaname and we cannot differentiate it. So, we extract the rules from
10639 * relation_expr here.
10640 */
10641 PublicationObjSpec:
10642 TABLE relation_expr opt_column_list OptWhereClause
10643 {
10650 }
10651 | TABLES IN_P SCHEMA ColId
10652 {
10657 }
10658 | TABLES IN_P SCHEMA CURRENT_SCHEMA
10659 {
10663 }
10664 | ColId opt_column_list OptWhereClause
10665 {
10668 /*
10669 * If either a row filter or column list is specified, create
10670 * a PublicationTable object.
10671 */
10673 {
10674 /*
10675 * The OptWhereClause must be stored here but it is
10676 * valid only for tables. For non-table objects, an
10677 * error will be thrown later via
10678 * preprocess_pubobj_list().
10679 */
10684 }
10685 else
10686 {
10688 }
10690 }
10691 | ColId indirection opt_column_list OptWhereClause
10692 {
10700 }
10701 /* grammar like tablename * , ONLY tablename, ONLY ( tablename ) */
10702 | extended_relation_expr opt_column_list OptWhereClause
10703 {
10710 }
10711 | CURRENT_SCHEMA
10712 {
10716 }
10717 ;
10719 pub_obj_list: PublicationObjSpec
10721 | pub_obj_list ',' PublicationObjSpec
10723 ;
10725 /*****************************************************************************
10726 *
10727 * ALTER PUBLICATION name SET ( options )
10728 *
10729 * ALTER PUBLICATION name ADD pub_obj [, ...]
10730 *
10731 * ALTER PUBLICATION name DROP pub_obj [, ...]
10732 *
10733 * ALTER PUBLICATION name SET pub_obj [, ...]
10734 *
10735 * pub_obj is one of:
10736 *
10737 * TABLE table_name [, ...]
10738 * TABLES IN SCHEMA schema_name [, ...]
10739 *
10740 *****************************************************************************/
10742 AlterPublicationStmt:
10743 ALTER PUBLICATION name SET definition
10744 {
10750 }
10751 | ALTER PUBLICATION name ADD_P pub_obj_list
10752 {
10760 }
10761 | ALTER PUBLICATION name SET pub_obj_list
10762 {
10770 }
10771 | ALTER PUBLICATION name DROP pub_obj_list
10772 {
10780 }
10781 ;
10783 /*****************************************************************************
10784 *
10785 * CREATE SUBSCRIPTION name ...
10786 *
10787 *****************************************************************************/
10789 CreateSubscriptionStmt:
10790 CREATE SUBSCRIPTION name CONNECTION Sconst PUBLICATION name_list opt_definition
10791 {
10799 }
10800 ;
10802 /*****************************************************************************
10803 *
10804 * ALTER SUBSCRIPTION name ...
10805 *
10806 *****************************************************************************/
10808 AlterSubscriptionStmt:
10809 ALTER SUBSCRIPTION name SET definition
10810 {
10818 }
10819 | ALTER SUBSCRIPTION name CONNECTION Sconst
10820 {
10828 }
10829 | ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition
10830 {
10838 }
10839 | ALTER SUBSCRIPTION name ADD_P PUBLICATION name_list opt_definition
10840 {
10849 }
10850 | ALTER SUBSCRIPTION name DROP PUBLICATION name_list opt_definition
10851 {
10860 }
10861 | ALTER SUBSCRIPTION name SET PUBLICATION name_list opt_definition
10862 {
10871 }
10872 | ALTER SUBSCRIPTION name ENABLE_P
10873 {
10882 }
10883 | ALTER SUBSCRIPTION name DISABLE_P
10884 {
10893 }
10894 | ALTER SUBSCRIPTION name SKIP definition
10895 {
10903 }
10904 ;
10906 /*****************************************************************************
10907 *
10908 * DROP SUBSCRIPTION [ IF EXISTS ] name
10909 *
10910 *****************************************************************************/
10912 DropSubscriptionStmt: DROP SUBSCRIPTION name opt_drop_behavior
10913 {
10920 }
10921 | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior
10922 {
10929 }
10930 ;
10932 /*****************************************************************************
10933 *
10934 * QUERY: Define Rewrite Rule
10935 *
10936 *****************************************************************************/
10938 RuleStmt: CREATE opt_or_replace RULE name AS
10939 ON event TO qualified_name where_clause
10940 DO opt_instead RuleActionList
10941 {
10952 }
10953 ;
10955 RuleActionList:
10959 ;
10961 /* the thrashing around here is to discard "empty" statements... */
10962 RuleActionMulti:
10963 RuleActionMulti ';' RuleActionStmtOrEmpty
10966 else
10968 }
10969 | RuleActionStmtOrEmpty
10972 else
10974 }
10975 ;
10977 RuleActionStmt:
10978 SelectStmt
10979 | InsertStmt
10980 | UpdateStmt
10981 | DeleteStmt
10982 | NotifyStmt
10983 ;
10985 RuleActionStmtOrEmpty:
10988 ;
10994 ;
10996 opt_instead:
11000 ;
11003 /*****************************************************************************
11004 *
11005 * QUERY:
11006 * NOTIFY <identifier> can appear both in rule bodies and
11007 * as a query-level command
11008 *
11009 *****************************************************************************/
11011 NotifyStmt: NOTIFY ColId notify_payload
11012 {
11018 }
11019 ;
11021 notify_payload:
11024 ;
11026 ListenStmt: LISTEN ColId
11027 {
11032 }
11033 ;
11035 UnlistenStmt:
11036 UNLISTEN ColId
11037 {
11042 }
11043 | UNLISTEN '*'
11044 {
11049 }
11050 ;
11053 /*****************************************************************************
11054 *
11055 * Transactions:
11056 *
11057 * BEGIN / COMMIT / ROLLBACK
11058 * (also older versions END / ABORT)
11059 *
11060 *****************************************************************************/
11062 TransactionStmt:
11063 ABORT_P opt_transaction opt_transaction_chain
11064 {
11072 }
11073 | START TRANSACTION transaction_mode_list_or_empty
11074 {
11081 }
11082 | COMMIT opt_transaction opt_transaction_chain
11083 {
11091 }
11092 | ROLLBACK opt_transaction opt_transaction_chain
11093 {
11101 }
11102 | SAVEPOINT ColId
11103 {
11110 }
11111 | RELEASE SAVEPOINT ColId
11112 {
11119 }
11120 | RELEASE ColId
11121 {
11128 }
11129 | ROLLBACK opt_transaction TO SAVEPOINT ColId
11130 {
11137 }
11138 | ROLLBACK opt_transaction TO ColId
11139 {
11146 }
11147 | PREPARE TRANSACTION Sconst
11148 {
11155 }
11156 | COMMIT PREPARED Sconst
11157 {
11164 }
11165 | ROLLBACK PREPARED Sconst
11166 {
11173 }
11174 ;
11176 TransactionStmtLegacy:
11177 BEGIN_P opt_transaction transaction_mode_list_or_empty
11178 {
11185 }
11186 | END_P opt_transaction opt_transaction_chain
11187 {
11195 }
11196 ;
11198 opt_transaction: WORK
11199 | TRANSACTION
11200 | /*EMPTY*/
11201 ;
11203 transaction_mode_item:
11204 ISOLATION LEVEL iso_level
11207 | READ ONLY
11210 | READ WRITE
11213 | DEFERRABLE
11216 | NOT DEFERRABLE
11219 ;
11221 /* Syntax with commas is SQL-spec, without commas is Postgres historical */
11222 transaction_mode_list:
11223 transaction_mode_item
11225 | transaction_mode_list ',' transaction_mode_item
11227 | transaction_mode_list transaction_mode_item
11229 ;
11231 transaction_mode_list_or_empty:
11232 transaction_mode_list
11233 | /* EMPTY */
11235 ;
11237 opt_transaction_chain:
11241 ;
11244 /*****************************************************************************
11245 *
11246 * QUERY:
11247 * CREATE [ OR REPLACE ] [ TEMP ] VIEW <viewname> '('target-list ')'
11248 * AS <query> [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
11249 *
11250 *****************************************************************************/
11252 ViewStmt: CREATE OptTemp VIEW qualified_name opt_column_list opt_reloptions
11253 AS SelectStmt opt_check_option
11254 {
11265 }
11266 | CREATE OR REPLACE OptTemp VIEW qualified_name opt_column_list opt_reloptions
11267 AS SelectStmt opt_check_option
11268 {
11279 }
11281 AS SelectStmt opt_check_option
11282 {
11298 }
11300 AS SelectStmt opt_check_option
11301 {
11317 }
11318 ;
11320 opt_check_option:
11325 ;
11327 /*****************************************************************************
11328 *
11329 * QUERY:
11330 * LOAD "filename"
11331 *
11332 *****************************************************************************/
11334 LoadStmt: LOAD file_name
11335 {
11340 }
11341 ;
11344 /*****************************************************************************
11345 *
11346 * CREATE DATABASE
11347 *
11348 *****************************************************************************/
11350 CreatedbStmt:
11351 CREATE DATABASE name opt_with createdb_opt_list
11352 {
11358 }
11359 ;
11361 createdb_opt_list:
11364 ;
11366 createdb_opt_items:
11369 ;
11371 createdb_opt_item:
11372 createdb_opt_name opt_equal NumericOnly
11373 {
11375 }
11376 | createdb_opt_name opt_equal opt_boolean_or_string
11377 {
11379 }
11380 | createdb_opt_name opt_equal DEFAULT
11381 {
11383 }
11384 ;
11386 /*
11387 * Ideally we'd use ColId here, but that causes shift/reduce conflicts against
11388 * the ALTER DATABASE SET/RESET syntaxes. Instead call out specific keywords
11389 * we need, and allow IDENT so that database option names don't have to be
11390 * parser keywords unless they are already keywords for other reasons.
11391 *
11392 * XXX this coding technique is fragile since if someone makes a formerly
11393 * non-keyword option name into a keyword and forgets to add it here, the
11394 * option will silently break. Best defense is to provide a regression test
11395 * exercising every such option, at least at the syntax level.
11396 */
11397 createdb_opt_name:
11405 ;
11407 /*
11408 * Though the equals sign doesn't match other WITH options, pg_dump uses
11409 * equals for backward compatibility, and it doesn't seem worth removing it.
11410 */
11412 | /*EMPTY*/
11413 ;
11416 /*****************************************************************************
11417 *
11418 * ALTER DATABASE
11419 *
11420 *****************************************************************************/
11422 AlterDatabaseStmt:
11423 ALTER DATABASE name WITH createdb_opt_list
11424 {
11430 }
11431 | ALTER DATABASE name createdb_opt_list
11432 {
11438 }
11439 | ALTER DATABASE name SET TABLESPACE name
11440 {
11447 }
11448 | ALTER DATABASE name REFRESH COLLATION VERSION_P
11449 {
11454 }
11455 ;
11457 AlterDatabaseSetStmt:
11458 ALTER DATABASE name SetResetClause
11459 {
11465 }
11466 ;
11469 /*****************************************************************************
11470 *
11471 * DROP DATABASE [ IF EXISTS ] dbname [ [ WITH ] ( options ) ]
11472 *
11473 * This is implicitly CASCADE, no need for drop behavior
11474 *****************************************************************************/
11476 DropdbStmt: DROP DATABASE name
11477 {
11484 }
11485 | DROP DATABASE IF_P EXISTS name
11486 {
11493 }
11495 {
11502 }
11504 {
11511 }
11512 ;
11514 drop_option_list:
11515 drop_option
11516 {
11518 }
11519 | drop_option_list ',' drop_option
11520 {
11522 }
11523 ;
11525 /*
11526 * Currently only the FORCE option is supported, but the syntax is designed
11527 * to be extensible so that we can add more options in the future if required.
11528 */
11529 drop_option:
11530 FORCE
11531 {
11533 }
11534 ;
11536 /*****************************************************************************
11537 *
11538 * ALTER COLLATION
11539 *
11540 *****************************************************************************/
11542 AlterCollationStmt: ALTER COLLATION any_name REFRESH VERSION_P
11543 {
11548 }
11549 ;
11552 /*****************************************************************************
11553 *
11554 * ALTER SYSTEM
11555 *
11556 * This is used to change configuration parameters persistently.
11557 *****************************************************************************/
11559 AlterSystemStmt:
11560 ALTER SYSTEM_P SET generic_set
11561 {
11566 }
11567 | ALTER SYSTEM_P RESET generic_reset
11568 {
11573 }
11574 ;
11577 /*****************************************************************************
11578 *
11579 * Manipulate a domain
11580 *
11581 *****************************************************************************/
11583 CreateDomainStmt:
11584 CREATE DOMAIN_P any_name opt_as Typename ColQualList
11585 {
11591 yyscanner);
11593 }
11594 ;
11596 AlterDomainStmt:
11597 /* ALTER DOMAIN <domain> {SET DEFAULT <expr>|DROP DEFAULT} */
11598 ALTER DOMAIN_P any_name alter_column_default
11599 {
11606 }
11607 /* ALTER DOMAIN <domain> DROP NOT NULL */
11608 | ALTER DOMAIN_P any_name DROP NOT NULL_P
11609 {
11615 }
11616 /* ALTER DOMAIN <domain> SET NOT NULL */
11617 | ALTER DOMAIN_P any_name SET NOT NULL_P
11618 {
11624 }
11625 /* ALTER DOMAIN <domain> ADD CONSTRAINT ... */
11626 | ALTER DOMAIN_P any_name ADD_P DomainConstraint
11627 {
11634 }
11635 /* ALTER DOMAIN <domain> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
11636 | ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
11637 {
11646 }
11647 /* ALTER DOMAIN <domain> DROP CONSTRAINT IF EXISTS <name> [RESTRICT|CASCADE] */
11648 | ALTER DOMAIN_P any_name DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior
11649 {
11658 }
11659 /* ALTER DOMAIN <domain> VALIDATE CONSTRAINT <name> */
11660 | ALTER DOMAIN_P any_name VALIDATE CONSTRAINT name
11661 {
11668 }
11669 ;
11671 opt_as: AS
11672 | /* EMPTY */
11673 ;
11676 /*****************************************************************************
11677 *
11678 * Manipulate a text search dictionary or configuration
11679 *
11680 *****************************************************************************/
11682 AlterTSDictionaryStmt:
11683 ALTER TEXT_P SEARCH DICTIONARY any_name definition
11684 {
11690 }
11691 ;
11693 AlterTSConfigurationStmt:
11694 ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list
11695 {
11705 }
11706 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list
11707 {
11717 }
11718 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name
11719 {
11729 }
11730 | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name
11731 {
11741 }
11742 | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
11743 {
11751 }
11752 | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
11753 {
11761 }
11762 ;
11764 /* Use this if TIME or ORDINALITY after WITH should be taken as an identifier */
11765 any_with: WITH
11766 | WITH_LA
11767 ;
11770 /*****************************************************************************
11771 *
11772 * Manipulate a conversion
11773 *
11774 * CREATE [DEFAULT] CONVERSION <conversion_name>
11775 * FOR <encoding_name> TO <encoding_name> FROM <func_name>
11776 *
11777 *****************************************************************************/
11779 CreateConversionStmt:
11780 CREATE opt_default CONVERSION_P any_name FOR Sconst
11781 TO Sconst FROM any_name
11782 {
11791 }
11792 ;
11794 /*****************************************************************************
11795 *
11796 * QUERY:
11797 * CLUSTER (options) [ <qualified_name> [ USING <index_name> ] ]
11798 * CLUSTER [VERBOSE] [ <qualified_name> [ USING <index_name> ] ]
11799 * CLUSTER [VERBOSE] <index_name> ON <qualified_name> (for pre-8.3)
11800 *
11801 *****************************************************************************/
11803 ClusterStmt:
11805 {
11812 }
11814 {
11821 }
11822 /* unparenthesized VERBOSE kept for pre-14 compatibility */
11823 | CLUSTER opt_verbose qualified_name cluster_index_specification
11824 {
11833 }
11834 /* unparenthesized VERBOSE kept for pre-17 compatibility */
11835 | CLUSTER opt_verbose
11836 {
11845 }
11846 /* kept for pre-8.3 compatibility */
11847 | CLUSTER opt_verbose name ON qualified_name
11848 {
11857 }
11858 ;
11860 cluster_index_specification:
11863 ;
11866 /*****************************************************************************
11867 *
11868 * QUERY:
11869 * VACUUM
11870 * ANALYZE
11871 *
11872 *****************************************************************************/
11874 VacuumStmt: VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list
11875 {
11894 }
11896 {
11903 }
11904 ;
11906 AnalyzeStmt: analyze_keyword opt_verbose opt_vacuum_relation_list
11907 {
11917 }
11919 {
11926 }
11927 ;
11929 utility_option_list:
11930 utility_option_elem
11931 {
11933 }
11934 | utility_option_list ',' utility_option_elem
11935 {
11937 }
11938 ;
11940 analyze_keyword:
11941 ANALYZE
11942 | ANALYSE /* British */
11943 ;
11945 utility_option_elem:
11946 utility_option_name utility_option_arg
11947 {
11949 }
11950 ;
11952 utility_option_name:
11956 ;
11958 utility_option_arg:
11962 ;
11964 opt_analyze:
11967 ;
11969 opt_verbose:
11972 ;
11976 ;
11980 ;
11982 opt_name_list:
11985 ;
11987 vacuum_relation:
11988 relation_expr opt_name_list
11989 {
11991 }
11992 ;
11994 vacuum_relation_list:
11995 vacuum_relation
11997 | vacuum_relation_list ',' vacuum_relation
11999 ;
12001 opt_vacuum_relation_list:
12004 ;
12007 /*****************************************************************************
12008 *
12009 * QUERY:
12010 * EXPLAIN [ANALYZE] [VERBOSE] query
12011 * EXPLAIN ( options ) query
12012 *
12013 *****************************************************************************/
12015 ExplainStmt:
12016 EXPLAIN ExplainableStmt
12017 {
12023 }
12024 | EXPLAIN analyze_keyword opt_verbose ExplainableStmt
12025 {
12034 }
12035 | EXPLAIN VERBOSE ExplainableStmt
12036 {
12042 }
12044 {
12050 }
12051 ;
12053 ExplainableStmt:
12054 SelectStmt
12055 | InsertStmt
12056 | UpdateStmt
12057 | DeleteStmt
12058 | MergeStmt
12059 | DeclareCursorStmt
12060 | CreateAsStmt
12061 | CreateMatViewStmt
12062 | RefreshMatViewStmt
12063 | ExecuteStmt /* by default all are $$=$1 */
12064 ;
12066 /*****************************************************************************
12067 *
12068 * QUERY:
12069 * PREPARE <plan_name> [(args, ...)] AS <query>
12070 *
12071 *****************************************************************************/
12073 PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt
12074 {
12081 }
12082 ;
12086 ;
12088 PreparableStmt:
12089 SelectStmt
12090 | InsertStmt
12091 | UpdateStmt
12092 | DeleteStmt
12093 | MergeStmt /* by default all are $$=$1 */
12094 ;
12096 /*****************************************************************************
12097 *
12098 * EXECUTE <plan_name> [(params, ...)]
12099 * CREATE TABLE <name> AS EXECUTE <plan_name> [(params, ...)]
12100 *
12101 *****************************************************************************/
12103 ExecuteStmt: EXECUTE name execute_param_clause
12104 {
12110 }
12111 | CREATE OptTemp TABLE create_as_target AS
12112 EXECUTE name execute_param_clause opt_with_data
12113 {
12124 /* cram additional flags into the IntoClause */
12128 }
12129 | CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS
12130 EXECUTE name execute_param_clause opt_with_data
12131 {
12142 /* cram additional flags into the IntoClause */
12146 }
12147 ;
12151 ;
12153 /*****************************************************************************
12154 *
12155 * QUERY:
12156 * DEALLOCATE [PREPARE] <plan_name>
12157 *
12158 *****************************************************************************/
12160 DeallocateStmt: DEALLOCATE name
12161 {
12168 }
12169 | DEALLOCATE PREPARE name
12170 {
12177 }
12178 | DEALLOCATE ALL
12179 {
12186 }
12187 | DEALLOCATE PREPARE ALL
12188 {
12195 }
12196 ;
12198 /*****************************************************************************
12199 *
12200 * QUERY:
12201 * INSERT STATEMENTS
12202 *
12203 *****************************************************************************/
12205 InsertStmt:
12206 opt_with_clause INSERT INTO insert_target insert_rest
12207 opt_on_conflict returning_clause
12208 {
12215 }
12216 ;
12218 /*
12219 * Can't easily make AS optional here, because VALUES in insert_rest would
12220 * have a shift/reduce conflict with VALUES as an optional alias. We could
12221 * easily allow unreserved_keywords as optional aliases, but that'd be an odd
12222 * divergence from other places. So just require AS for now.
12223 */
12224 insert_target:
12225 qualified_name
12226 {
12228 }
12229 | qualified_name AS ColId
12230 {
12233 }
12234 ;
12236 insert_rest:
12237 SelectStmt
12238 {
12242 }
12243 | OVERRIDING override_kind VALUE_P SelectStmt
12244 {
12249 }
12251 {
12255 }
12257 {
12262 }
12263 | DEFAULT VALUES
12264 {
12268 }
12269 ;
12271 override_kind:
12274 ;
12276 insert_column_list:
12277 insert_column_item
12279 | insert_column_list ',' insert_column_item
12281 ;
12283 insert_column_item:
12284 ColId opt_indirection
12285 {
12291 }
12292 ;
12294 opt_on_conflict:
12295 ON CONFLICT opt_conf_expr DO UPDATE SET set_clause_list where_clause
12296 {
12303 }
12304 |
12305 ON CONFLICT opt_conf_expr DO NOTHING
12306 {
12313 }
12314 | /*EMPTY*/
12315 {
12317 }
12318 ;
12320 opt_conf_expr:
12322 {
12328 }
12329 |
12330 ON CONSTRAINT name
12331 {
12337 }
12338 | /*EMPTY*/
12339 {
12341 }
12342 ;
12344 returning_clause:
12345 RETURNING returning_with_clause target_list
12346 {
12352 }
12353 | /* EMPTY */
12354 {
12356 }
12357 ;
12359 returning_with_clause:
12362 ;
12364 returning_options:
12367 ;
12369 returning_option:
12370 returning_option_kind AS ColId
12371 {
12378 }
12379 ;
12381 returning_option_kind:
12384 ;
12387 /*****************************************************************************
12388 *
12389 * QUERY:
12390 * DELETE STATEMENTS
12391 *
12392 *****************************************************************************/
12394 DeleteStmt: opt_with_clause DELETE_P FROM relation_expr_opt_alias
12395 using_clause where_or_current_clause returning_clause
12396 {
12406 }
12407 ;
12409 using_clause:
12412 ;
12415 /*****************************************************************************
12416 *
12417 * QUERY:
12418 * LOCK TABLE
12419 *
12420 *****************************************************************************/
12422 LockStmt: LOCK_P opt_table relation_expr_list opt_lock opt_nowait
12423 {
12430 }
12431 ;
12435 ;
12445 ;
12449 ;
12451 opt_nowait_or_skip:
12455 ;
12458 /*****************************************************************************
12459 *
12460 * QUERY:
12461 * UpdateStmt (UPDATE)
12462 *
12463 *****************************************************************************/
12465 UpdateStmt: opt_with_clause UPDATE relation_expr_opt_alias
12466 SET set_clause_list
12467 from_clause
12468 where_or_current_clause
12469 returning_clause
12470 {
12481 }
12482 ;
12484 set_clause_list:
12487 ;
12489 set_clause:
12490 set_target '=' a_expr
12491 {
12494 }
12496 {
12501 /* Create a MultiAssignRef source for each target */
12503 {
12511 i++;
12512 }
12515 }
12516 ;
12518 set_target:
12519 ColId opt_indirection
12520 {
12526 }
12527 ;
12529 set_target_list:
12532 ;
12535 /*****************************************************************************
12536 *
12537 * QUERY:
12538 * MERGE
12539 *
12540 *****************************************************************************/
12542 MergeStmt:
12543 opt_with_clause MERGE INTO relation_expr_opt_alias
12544 USING table_ref
12545 ON a_expr
12546 merge_when_list
12547 returning_clause
12548 {
12560 }
12561 ;
12563 merge_when_list:
12566 ;
12568 /*
12569 * A WHEN clause may be WHEN MATCHED, WHEN NOT MATCHED BY SOURCE, or WHEN NOT
12570 * MATCHED [BY TARGET]. The first two cases match target tuples, and support
12571 * UPDATE/DELETE/DO NOTHING actions. The third case does not match target
12572 * tuples, and only supports INSERT/DO NOTHING actions.
12573 */
12574 merge_when_clause:
12575 merge_when_tgt_matched opt_merge_when_condition THEN merge_update
12576 {
12581 }
12582 | merge_when_tgt_matched opt_merge_when_condition THEN merge_delete
12583 {
12588 }
12589 | merge_when_tgt_not_matched opt_merge_when_condition THEN merge_insert
12590 {
12595 }
12596 | merge_when_tgt_matched opt_merge_when_condition THEN DO NOTHING
12597 {
12605 }
12606 | merge_when_tgt_not_matched opt_merge_when_condition THEN DO NOTHING
12607 {
12615 }
12616 ;
12618 merge_when_tgt_matched:
12621 ;
12623 merge_when_tgt_not_matched:
12626 ;
12628 opt_merge_when_condition:
12631 ;
12633 merge_update:
12634 UPDATE SET set_clause_list
12635 {
12643 }
12644 ;
12646 merge_delete:
12647 DELETE_P
12648 {
12656 }
12657 ;
12659 merge_insert:
12660 INSERT merge_values_clause
12661 {
12668 }
12669 | INSERT OVERRIDING override_kind VALUE_P merge_values_clause
12670 {
12677 }
12679 {
12686 }
12688 {
12695 }
12696 | INSERT DEFAULT VALUES
12697 {
12704 }
12705 ;
12707 merge_values_clause:
12709 {
12711 }
12712 ;
12714 /*****************************************************************************
12715 *
12716 * QUERY:
12717 * CURSOR STATEMENTS
12718 *
12719 *****************************************************************************/
12720 DeclareCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR SelectStmt
12721 {
12725 /* currently we always set FAST_PLAN option */
12729 }
12730 ;
12733 ;
12741 ;
12746 ;
12748 /*****************************************************************************
12749 *
12750 * QUERY:
12751 * SELECT STATEMENTS
12752 *
12753 *****************************************************************************/
12755 /* A complete SELECT statement looks like this.
12756 *
12757 * The rule returns either a single SelectStmt node or a tree of them,
12758 * representing a set-operation tree.
12759 *
12760 * There is an ambiguity when a sub-SELECT is within an a_expr and there
12761 * are excess parentheses: do the parentheses belong to the sub-SELECT or
12762 * to the surrounding a_expr? We don't really care, but bison wants to know.
12763 * To resolve the ambiguity, we are careful to define the grammar so that
12764 * the decision is staved off as long as possible: as long as we can keep
12765 * absorbing parentheses into the sub-SELECT, we will do so, and only when
12766 * it's no longer possible to do that will we decide that parens belong to
12767 * the expression. For example, in "SELECT (((SELECT 2)) + 3)" the extra
12768 * parentheses are treated as part of the sub-select. The necessity of doing
12769 * it that way is shown by "SELECT (((SELECT 2)) UNION SELECT 2)". Had we
12770 * parsed "((SELECT 2))" as an a_expr, it'd be too late to go back to the
12771 * SELECT viewpoint when we see the UNION.
12772 *
12773 * This approach is implemented by defining a nonterminal select_with_parens,
12774 * which represents a SELECT with at least one outer layer of parentheses,
12775 * and being careful to use select_with_parens, never '(' SelectStmt ')',
12776 * in the expression grammar. We will then have shift-reduce conflicts
12777 * which we can resolve in favor of always treating '(' <select> ')' as
12778 * a select_with_parens. To resolve the conflicts, the productions that
12779 * conflict with the select_with_parens productions are manually given
12780 * precedences lower than the precedence of ')', thereby ensuring that we
12781 * shift ')' (and then reduce to select_with_parens) rather than trying to
12782 * reduce the inner <select> nonterminal to something else. We use UMINUS
12783 * precedence for this, which is a fairly arbitrary choice.
12784 *
12785 * To be able to define select_with_parens itself without ambiguity, we need
12786 * a nonterminal select_no_parens that represents a SELECT structure with no
12787 * outermost parentheses. This is a little bit tedious, but it works.
12788 *
12789 * In non-expression contexts, we use SelectStmt which can represent a SELECT
12790 * with or without outer parentheses.
12791 */
12793 SelectStmt: select_no_parens %prec UMINUS
12794 | select_with_parens %prec UMINUS
12795 ;
12797 select_with_parens:
12799 {
12802 /*
12803 * As SelectStmt's location starts at the SELECT keyword,
12804 * we need to track the length of the SelectStmt within
12805 * parentheses to be able to extract the relevant part
12806 * of the query. Without this, the RawStmt's length would
12807 * be used and would include the closing parenthesis.
12808 */
12811 }
12813 ;
12815 /*
12816 * This rule parses the equivalent of the standard's <query expression>.
12817 * The duplicative productions are annoying, but hard to get rid of without
12818 * creating shift/reduce conflicts.
12819 *
12820 * The locking clause (FOR UPDATE etc) may be before or after LIMIT/OFFSET.
12821 * In <=7.2.X, LIMIT/OFFSET had to be after FOR UPDATE
12822 * We now support both orderings, but prefer LIMIT/OFFSET before the locking
12823 * clause.
12824 * 2002-08-28 bjm
12825 */
12826 select_no_parens:
12828 | select_clause sort_clause
12829 {
12832 yyscanner);
12834 }
12835 | select_clause opt_sort_clause for_locking_clause opt_select_limit
12836 {
12839 NULL,
12840 yyscanner);
12842 }
12843 | select_clause opt_sort_clause select_limit opt_for_locking_clause
12844 {
12847 NULL,
12848 yyscanner);
12850 }
12851 | with_clause select_clause
12852 {
12854 NULL,
12856 yyscanner);
12858 }
12859 | with_clause select_clause sort_clause
12860 {
12862 NULL,
12864 yyscanner);
12866 }
12867 | with_clause select_clause opt_sort_clause for_locking_clause opt_select_limit
12868 {
12872 yyscanner);
12874 }
12875 | with_clause select_clause opt_sort_clause select_limit opt_for_locking_clause
12876 {
12880 yyscanner);
12882 }
12883 ;
12885 select_clause:
12888 ;
12890 /*
12891 * This rule parses SELECT statements that can appear within set operations,
12892 * including UNION, INTERSECT and EXCEPT. '(' and ')' can be used to specify
12893 * the ordering of the set operations. Without '(' and ')' we want the
12894 * operations to be ordered per the precedence specs at the head of this file.
12895 *
12896 * As with select_no_parens, simple_select cannot have outer parentheses,
12897 * but can have parenthesized subclauses.
12898 *
12899 * It might appear that we could fold the first two alternatives into one
12900 * by using opt_distinct_clause. However, that causes a shift/reduce conflict
12901 * against INSERT ... SELECT ... ON CONFLICT. We avoid the ambiguity by
12902 * requiring SELECT DISTINCT [ON] to be followed by a non-empty target_list.
12903 *
12904 * Note that sort clauses cannot be included at this level --- SQL requires
12905 * SELECT foo UNION SELECT bar ORDER BY baz
12906 * to be parsed as
12907 * (SELECT foo UNION SELECT bar) ORDER BY baz
12908 * not
12909 * SELECT foo UNION (SELECT bar ORDER BY baz)
12910 * Likewise for WITH, FOR UPDATE and LIMIT. Therefore, those clauses are
12911 * described as part of the select_no_parens production, not simple_select.
12912 * This does not limit functionality, because you can reintroduce these
12913 * clauses inside parentheses.
12914 *
12915 * NOTE: only the leftmost component SelectStmt should have INTO.
12916 * However, this is not checked by the grammar; parse analysis must check it.
12917 */
12918 simple_select:
12919 SELECT opt_all_clause opt_target_list
12920 into_clause from_clause where_clause
12921 group_clause having_clause window_clause
12922 {
12935 }
12936 | SELECT distinct_clause target_list
12937 into_clause from_clause where_clause
12938 group_clause having_clause window_clause
12939 {
12953 }
12955 | TABLE relation_expr
12956 {
12957 /* same as SELECT * FROM relation_expr */
12974 }
12975 | select_clause UNION set_quantifier select_clause
12976 {
12978 }
12979 | select_clause INTERSECT set_quantifier select_clause
12980 {
12982 }
12983 | select_clause EXCEPT set_quantifier select_clause
12984 {
12986 }
12987 ;
12989 /*
12990 * SQL standard WITH clause looks like:
12991 *
12992 * WITH [ RECURSIVE ] <query name> [ (<column>,...) ]
12993 * AS (query) [ SEARCH or CYCLE clause ]
12994 *
12995 * Recognizing WITH_LA here allows a CTE to be named TIME or ORDINALITY.
12996 */
12997 with_clause:
12998 WITH cte_list
12999 {
13004 }
13005 | WITH_LA cte_list
13006 {
13011 }
13012 | WITH RECURSIVE cte_list
13013 {
13018 }
13019 ;
13021 cte_list:
13024 ;
13026 common_table_expr: name opt_name_list AS opt_materialized '(' PreparableStmt ')' opt_search_clause opt_cycle_clause
13027 {
13038 }
13039 ;
13041 opt_materialized:
13045 ;
13047 opt_search_clause:
13048 SEARCH DEPTH FIRST_P BY columnList SET ColId
13049 {
13057 }
13058 | SEARCH BREADTH FIRST_P BY columnList SET ColId
13059 {
13067 }
13068 | /*EMPTY*/
13069 {
13071 }
13072 ;
13074 opt_cycle_clause:
13075 CYCLE columnList SET ColId TO AexprConst DEFAULT AexprConst USING ColId
13076 {
13086 }
13087 | CYCLE columnList SET ColId USING ColId
13088 {
13098 }
13099 | /*EMPTY*/
13100 {
13102 }
13103 ;
13105 opt_with_clause:
13108 ;
13110 into_clause:
13111 INTO OptTempTableName
13112 {
13121 }
13122 | /*EMPTY*/
13124 ;
13126 /*
13127 * Redundancy here is needed to avoid shift/reduce conflicts,
13128 * since TEMP is not a reserved word. See also OptTemp.
13129 */
13130 OptTempTableName:
13131 TEMPORARY opt_table qualified_name
13132 {
13135 }
13136 | TEMP opt_table qualified_name
13137 {
13140 }
13141 | LOCAL TEMPORARY opt_table qualified_name
13142 {
13145 }
13146 | LOCAL TEMP opt_table qualified_name
13147 {
13150 }
13151 | GLOBAL TEMPORARY opt_table qualified_name
13152 {
13158 }
13159 | GLOBAL TEMP opt_table qualified_name
13160 {
13166 }
13167 | UNLOGGED opt_table qualified_name
13168 {
13171 }
13172 | TABLE qualified_name
13173 {
13176 }
13177 | qualified_name
13178 {
13181 }
13182 ;
13184 opt_table: TABLE
13185 | /*EMPTY*/
13186 ;
13188 set_quantifier:
13192 ;
13194 /* We use (NIL) as a placeholder to indicate that all target expressions
13195 * should be placed in the DISTINCT list during parsetree analysis.
13196 */
13197 distinct_clause:
13200 ;
13202 opt_all_clause:
13203 ALL
13204 | /*EMPTY*/
13205 ;
13207 opt_distinct_clause:
13210 ;
13212 opt_sort_clause:
13215 ;
13217 sort_clause:
13219 ;
13221 sortby_list:
13224 ;
13226 sortby: a_expr USING qual_all_Op opt_nulls_order
13227 {
13234 }
13235 | a_expr opt_asc_desc opt_nulls_order
13236 {
13243 }
13244 ;
13247 select_limit:
13248 limit_clause offset_clause
13249 {
13253 }
13254 | offset_clause limit_clause
13255 {
13259 }
13260 | limit_clause
13261 {
13263 }
13264 | offset_clause
13265 {
13275 }
13276 ;
13278 opt_select_limit:
13281 ;
13283 limit_clause:
13284 LIMIT select_limit_value
13285 {
13295 }
13296 | LIMIT select_limit_value ',' select_offset_value
13297 {
13298 /* Disabled because it was too confusing, bjm 2002-02-18 */
13304 }
13305 /* SQL:2008 syntax */
13306 /* to avoid shift/reduce conflicts, handle the optional value with
13307 * a separate production rather than an opt_ expression. The fact
13308 * that ONLY is fully reserved means that this way, we defer any
13309 * decision about what rule reduces ROW or ROWS to the point where
13310 * we can see the ONLY token in the lookahead slot.
13311 */
13312 | FETCH first_or_next select_fetch_first_value row_or_rows ONLY
13313 {
13323 }
13324 | FETCH first_or_next select_fetch_first_value row_or_rows WITH TIES
13325 {
13335 }
13336 | FETCH first_or_next row_or_rows ONLY
13337 {
13347 }
13348 | FETCH first_or_next row_or_rows WITH TIES
13349 {
13359 }
13360 ;
13362 offset_clause:
13363 OFFSET select_offset_value
13365 /* SQL:2008 syntax */
13366 | OFFSET select_fetch_first_value row_or_rows
13368 ;
13370 select_limit_value:
13372 | ALL
13373 {
13374 /* LIMIT ALL is represented as a NULL constant */
13376 }
13377 ;
13379 select_offset_value:
13381 ;
13383 /*
13384 * Allowing full expressions without parentheses causes various parsing
13385 * problems with the trailing ROW/ROWS key words. SQL spec only calls for
13386 * <simple value specification>, which is either a literal or a parameter (but
13387 * an <SQL parameter reference> could be an identifier, bringing up conflicts
13388 * with ROW/ROWS). We solve this by leveraging the presence of ONLY (see above)
13389 * to determine whether the expression is missing rather than trying to make it
13390 * optional in this rule.
13391 *
13392 * c_expr covers almost all the spec-required cases (and more), but it doesn't
13393 * cover signed numeric literals, which are allowed by the spec. So we include
13394 * those here explicitly. We need FCONST as well as ICONST because values that
13395 * don't fit in the platform's "long", but do fit in bigint, should still be
13396 * accepted here. (This is possible in 64-bit Windows as well as all 32-bit
13397 * builds.)
13398 */
13399 select_fetch_first_value:
13401 | '+' I_or_F_const
13403 | '-' I_or_F_const
13405 ;
13407 I_or_F_const:
13410 ;
13412 /* noise words */
13415 ;
13419 ;
13422 /*
13423 * This syntax for group_clause tries to follow the spec quite closely.
13424 * However, the spec allows only column references, not expressions,
13425 * which introduces an ambiguity between implicit row constructors
13426 * (a,b) and lists of column references.
13427 *
13428 * We handle this by using the a_expr production for what the spec calls
13429 * <ordinary grouping set>, which in the spec represents either one column
13430 * reference or a parenthesized list of column references. Then, we check the
13431 * top node of the a_expr to see if it's an implicit RowExpr, and if so, just
13432 * grab and use the list, discarding the node. (this is done in parse analysis,
13433 * not here)
13434 *
13435 * (we abuse the row_format field of RowExpr to distinguish implicit and
13436 * explicit row constructors; it's debatable if anyone sanely wants to use them
13437 * in a group clause, but if they have a reason to, we make it possible.)
13438 *
13439 * Each item in the group_clause list is either an expression tree or a
13440 * GroupingSet node of some type.
13441 */
13442 group_clause:
13443 GROUP_P BY set_quantifier group_by_list
13444 {
13450 }
13451 | /*EMPTY*/
13452 {
13458 }
13459 ;
13461 group_by_list:
13464 ;
13466 group_by_item:
13472 ;
13474 empty_grouping_set:
13476 {
13478 }
13479 ;
13481 /*
13482 * These hacks rely on setting precedence of CUBE and ROLLUP below that of '(',
13483 * so that they shift in these rules rather than reducing the conflicting
13484 * unreserved_keyword rule.
13485 */
13487 rollup_clause:
13489 {
13491 }
13492 ;
13494 cube_clause:
13496 {
13498 }
13499 ;
13501 grouping_sets_clause:
13503 {
13505 }
13506 ;
13508 having_clause:
13511 ;
13513 for_locking_clause:
13516 ;
13518 opt_for_locking_clause:
13521 ;
13523 for_locking_items:
13526 ;
13528 for_locking_item:
13529 for_locking_strength locked_rels_list opt_nowait_or_skip
13530 {
13537 }
13538 ;
13540 for_locking_strength:
13545 ;
13547 locked_rels_list:
13550 ;
13553 /*
13554 * We should allow ROW '(' expr_list ')' too, but that seems to require
13555 * making VALUES a fully reserved word, which will probably break more apps
13556 * than allowing the noise-word is worth.
13557 */
13558 values_clause:
13560 {
13566 }
13568 {
13573 }
13574 ;
13577 /*****************************************************************************
13578 *
13579 * clauses common to all Optimizable Stmts:
13580 * from_clause - allow list of both JOIN expressions and table names
13581 * where_clause - qualifications for joins or restrictions
13582 *
13583 *****************************************************************************/
13585 from_clause:
13588 ;
13590 from_list:
13593 ;
13595 /*
13596 * table_ref is where an alias clause can be attached.
13597 */
13598 table_ref: relation_expr opt_alias_clause
13599 {
13602 }
13603 | relation_expr opt_alias_clause tablesample_clause
13604 {
13608 /* relation_expr goes inside the RangeTableSample node */
13611 }
13612 | func_table func_alias_clause
13613 {
13619 }
13620 | LATERAL_P func_table func_alias_clause
13621 {
13628 }
13629 | xmltable opt_alias_clause
13630 {
13635 }
13636 | LATERAL_P xmltable opt_alias_clause
13637 {
13643 }
13644 | select_with_parens opt_alias_clause
13645 {
13652 }
13653 | LATERAL_P select_with_parens opt_alias_clause
13654 {
13661 }
13662 | joined_table
13663 {
13665 }
13667 {
13670 }
13671 | json_table opt_alias_clause
13672 {
13677 }
13678 | LATERAL_P json_table opt_alias_clause
13679 {
13685 }
13686 ;
13689 /*
13690 * It may seem silly to separate joined_table from table_ref, but there is
13691 * method in SQL's madness: if you don't do it this way you get reduce-
13692 * reduce conflicts, because it's not clear to the parser generator whether
13693 * to expect alias_clause after ')' or not. For the same reason we must
13694 * treat 'JOIN' and 'join_type JOIN' separately, rather than allowing
13695 * join_type to expand to empty; if we try it, the parser generator can't
13696 * figure out when to reduce an empty join_type right after table_ref.
13697 *
13698 * Note that a CROSS JOIN is the same as an unqualified
13699 * INNER JOIN, and an INNER JOIN/ON has the same shape
13700 * but a qualification expression to limit membership.
13701 * A NATURAL JOIN implicitly matches column names between
13702 * tables and the shape is determined by which columns are
13703 * in common. We'll collect columns during the later transformations.
13704 */
13706 joined_table:
13708 {
13710 }
13711 | table_ref CROSS JOIN table_ref
13712 {
13713 /* CROSS JOIN is same as unqualified inner join */
13724 }
13725 | table_ref join_type JOIN table_ref join_qual
13726 {
13734 {
13735 /* USING clause */
13738 }
13739 else
13740 {
13741 /* ON clause */
13743 }
13745 }
13746 | table_ref JOIN table_ref join_qual
13747 {
13748 /* letting join_type reduce to empty doesn't work */
13756 {
13757 /* USING clause */
13760 }
13761 else
13762 {
13763 /* ON clause */
13765 }
13767 }
13768 | table_ref NATURAL join_type JOIN table_ref
13769 {
13780 }
13781 | table_ref NATURAL JOIN table_ref
13782 {
13783 /* letting join_type reduce to empty doesn't work */
13794 }
13795 ;
13797 alias_clause:
13799 {
13803 }
13804 | AS ColId
13805 {
13808 }
13810 {
13814 }
13815 | ColId
13816 {
13819 }
13820 ;
13824 ;
13826 /*
13827 * The alias clause after JOIN ... USING only accepts the AS ColId spelling,
13828 * per SQL standard. (The grammar could parse the other variants, but they
13829 * don't seem to be useful, and it might lead to parser problems in the
13830 * future.)
13831 */
13832 opt_alias_clause_for_join_using:
13833 AS ColId
13834 {
13837 /* the column name list will be inserted later */
13838 }
13840 ;
13842 /*
13843 * func_alias_clause can include both an Alias and a coldeflist, so we make it
13844 * return a 2-element list that gets disassembled by calling production.
13845 */
13846 func_alias_clause:
13847 alias_clause
13848 {
13850 }
13852 {
13854 }
13856 {
13861 }
13863 {
13868 }
13869 | /*EMPTY*/
13870 {
13872 }
13873 ;
13879 ;
13881 /* OUTER is just noise... */
13882 opt_outer: OUTER_P
13883 | /*EMPTY*/
13884 ;
13886 /* JOIN qualification clauses
13887 * Possibilities are:
13888 * USING ( column list ) [ AS alias ]
13889 * allows only unqualified column names,
13890 * which must match between tables.
13891 * ON expr allows more general qualifications.
13892 *
13893 * We return USING as a two-element List (the first item being a sub-List
13894 * of the common column names, and the second either an Alias item or NULL).
13895 * An ON-expr will not be a List, so it can be told apart that way.
13896 */
13899 {
13901 }
13902 | ON a_expr
13903 {
13905 }
13906 ;
13909 relation_expr:
13910 qualified_name
13911 {
13912 /* inheritance query, implicitly */
13916 }
13917 | extended_relation_expr
13918 {
13920 }
13921 ;
13923 extended_relation_expr:
13924 qualified_name '*'
13925 {
13926 /* inheritance query, explicitly */
13930 }
13931 | ONLY qualified_name
13932 {
13933 /* no inheritance */
13937 }
13939 {
13940 /* no inheritance, SQL99-style syntax */
13944 }
13945 ;
13948 relation_expr_list:
13951 ;
13954 /*
13955 * Given "UPDATE foo set set ...", we have to decide without looking any
13956 * further ahead whether the first "set" is an alias or the UPDATE's SET
13957 * keyword. Since "set" is allowed as a column name both interpretations
13958 * are feasible. We resolve the shift/reduce conflict by giving the first
13959 * relation_expr_opt_alias production a higher precedence than the SET token
13960 * has, causing the parser to prefer to reduce, in effect assuming that the
13961 * SET is not an alias.
13962 */
13963 relation_expr_opt_alias: relation_expr %prec UMINUS
13964 {
13966 }
13967 | relation_expr ColId
13968 {
13974 }
13975 | relation_expr AS ColId
13976 {
13982 }
13983 ;
13985 /*
13986 * TABLESAMPLE decoration in a FROM item
13987 */
13988 tablesample_clause:
13990 {
13993 /* n->relation will be filled in later */
13999 }
14000 ;
14002 opt_repeatable_clause:
14005 ;
14007 /*
14008 * func_table represents a function invocation in a FROM list. It can be
14009 * a plain function call, like "foo(...)", or a ROWS FROM expression with
14010 * one or more function calls, "ROWS FROM (foo(...), bar(...))",
14011 * optionally with WITH ORDINALITY attached.
14012 * In the ROWS FROM syntax, a column definition list can be given for each
14013 * function, for example:
14014 * ROWS FROM (foo() AS (foo_res_a text, foo_res_b text),
14015 * bar() AS (bar_res_a text, bar_res_b text))
14016 * It's also possible to attach a column definition list to the RangeFunction
14017 * as a whole, but that's handled by the table_ref production.
14018 */
14019 func_table: func_expr_windowless opt_ordinality
14020 {
14027 /* alias and coldeflist are set by table_ref production */
14029 }
14031 {
14038 /* alias and coldeflist are set by table_ref production */
14040 }
14041 ;
14043 rowsfrom_item: func_expr_windowless opt_col_def_list
14045 ;
14047 rowsfrom_list:
14050 ;
14054 ;
14058 ;
14061 where_clause:
14064 ;
14066 /* variant for UPDATE and DELETE */
14067 where_or_current_clause:
14069 | WHERE CURRENT_P OF cursor_name
14070 {
14073 /* cvarno is filled in by parse analysis */
14077 }
14079 ;
14082 OptTableFuncElementList:
14085 ;
14087 TableFuncElementList:
14088 TableFuncElement
14089 {
14091 }
14092 | TableFuncElementList ',' TableFuncElement
14093 {
14095 }
14096 ;
14098 TableFuncElement: ColId Typename opt_collate_clause
14099 {
14116 }
14117 ;
14119 /*
14120 * XMLTABLE
14121 */
14122 xmltable:
14124 {
14133 }
14135 c_expr xmlexists_argument COLUMNS xmltable_column_list ')'
14136 {
14145 }
14146 ;
14150 ;
14152 xmltable_column_el:
14153 ColId Typename
14154 {
14166 }
14167 | ColId Typename xmltable_column_option_list
14168 {
14182 {
14186 {
14193 }
14195 {
14202 }
14204 {
14208 errmsg("conflicting or redundant NULL / NOT NULL declarations for column \"%s\"", fc->colname),
14212 }
14213 else
14214 {
14220 }
14221 }
14223 }
14224 | ColId FOR ORDINALITY
14225 {
14230 /* other fields are ignored, initialized by makeNode */
14234 }
14235 ;
14237 xmltable_column_option_list:
14238 xmltable_column_option_el
14240 | xmltable_column_option_list xmltable_column_option_el
14242 ;
14244 xmltable_column_option_el:
14245 IDENT b_expr
14247 | DEFAULT b_expr
14249 | NOT NULL_P
14251 | NULL_P
14253 | PATH b_expr
14255 ;
14257 xml_namespace_list:
14258 xml_namespace_el
14260 | xml_namespace_list ',' xml_namespace_el
14262 ;
14264 xml_namespace_el:
14265 b_expr AS ColLabel
14266 {
14272 }
14273 | DEFAULT b_expr
14274 {
14280 }
14281 ;
14283 json_table:
14284 JSON_TABLE '('
14285 json_value_expr ',' a_expr json_table_path_name_opt
14286 json_passing_clause_opt
14288 json_on_error_clause_opt
14289 ')'
14290 {
14308 }
14309 ;
14311 json_table_path_name_opt:
14314 ;
14316 json_table_column_definition_list:
14317 json_table_column_definition
14319 | json_table_column_definition_list ',' json_table_column_definition
14321 ;
14323 json_table_column_definition:
14324 ColId FOR ORDINALITY
14325 {
14332 }
14333 | ColId Typename
14334 json_table_column_path_clause_opt
14335 json_wrapper_behavior
14336 json_quotes_clause_opt
14337 json_behavior_clause_opt
14338 {
14352 }
14353 | ColId Typename json_format_clause
14354 json_table_column_path_clause_opt
14355 json_wrapper_behavior
14356 json_quotes_clause_opt
14357 json_behavior_clause_opt
14358 {
14372 }
14373 | ColId Typename
14374 EXISTS json_table_column_path_clause_opt
14375 json_on_error_clause_opt
14376 {
14390 }
14391 | NESTED path_opt Sconst
14393 {
14402 }
14403 | NESTED path_opt Sconst AS name
14405 {
14414 }
14415 ;
14417 path_opt:
14418 PATH
14419 | /* EMPTY */
14420 ;
14422 json_table_column_path_clause_opt:
14423 PATH Sconst
14425 | /* EMPTY */
14427 ;
14429 /*****************************************************************************
14430 *
14431 * Type syntax
14432 * SQL introduces a large amount of type-specific syntax.
14433 * Define individual clauses to handle these cases, and use
14434 * the generic case to handle regular type-extensible Postgres syntax.
14435 * - thomas 1997-10-10
14436 *
14437 *****************************************************************************/
14439 Typename: SimpleTypename opt_array_bounds
14440 {
14443 }
14444 | SETOF SimpleTypename opt_array_bounds
14445 {
14449 }
14450 /* SQL standard syntax, currently only one-dimensional */
14452 {
14455 }
14457 {
14461 }
14462 | SimpleTypename ARRAY
14463 {
14466 }
14467 | SETOF SimpleTypename ARRAY
14468 {
14472 }
14473 ;
14475 opt_array_bounds:
14480 | /*EMPTY*/
14482 ;
14484 SimpleTypename:
14490 | ConstInterval opt_interval
14491 {
14494 }
14496 {
14500 }
14502 ;
14504 /* We have a separate ConstTypename to allow defaulting fixed-length
14505 * types such as CHAR() and BIT() to an unspecified length.
14506 * SQL9x requires that these default to a length of one, but this
14507 * makes no sense for constructs like CHAR 'hi' and BIT '0101',
14508 * where there is an obvious better choice to make.
14509 * Note that ConstInterval is not included here since it must
14510 * be pushed up higher in the rules to accommodate the postfix
14511 * options (e.g. INTERVAL '1' YEAR). Likewise, we have to handle
14512 * the generic-type-name case in AexprConst to avoid premature
14513 * reduce/reduce conflicts against function names.
14514 */
14515 ConstTypename:
14521 ;
14523 /*
14524 * GenericType covers all type names that don't have special syntax mandated
14525 * by the standard, including qualified names. We also allow type modifiers.
14526 * To avoid parsing conflicts against function invocations, the modifiers
14527 * have to be shown as expr_list here, but parse analysis will only accept
14528 * constants for them.
14529 */
14530 GenericType:
14531 type_function_name opt_type_modifiers
14532 {
14536 }
14537 | type_function_name attrs opt_type_modifiers
14538 {
14542 }
14543 ;
14547 ;
14549 /*
14550 * SQL numeric data types
14551 */
14552 Numeric: INT_P
14553 {
14556 }
14557 | INTEGER
14558 {
14561 }
14562 | SMALLINT
14563 {
14566 }
14567 | BIGINT
14568 {
14571 }
14572 | REAL
14573 {
14576 }
14577 | FLOAT_P opt_float
14578 {
14581 }
14582 | DOUBLE_P PRECISION
14583 {
14586 }
14587 | DECIMAL_P opt_type_modifiers
14588 {
14592 }
14593 | DEC opt_type_modifiers
14594 {
14598 }
14599 | NUMERIC opt_type_modifiers
14600 {
14604 }
14605 | BOOLEAN_P
14606 {
14609 }
14610 ;
14613 {
14614 /*
14615 * Check FLOAT() precision limits assuming IEEE floating
14616 * types - thomas 1997-09-18
14617 */
14627 else
14632 }
14633 | /*EMPTY*/
14634 {
14636 }
14637 ;
14639 /*
14640 * SQL bit-field data types
14641 * The following implements BIT() and BIT VARYING().
14642 */
14643 Bit: BitWithLength
14644 {
14646 }
14647 | BitWithoutLength
14648 {
14650 }
14651 ;
14653 /* ConstBit is like Bit except "BIT" defaults to unspecified length */
14654 /* See notes for ConstCharacter, which addresses same issue for "CHAR" */
14655 ConstBit: BitWithLength
14656 {
14658 }
14659 | BitWithoutLength
14660 {
14663 }
14664 ;
14666 BitWithLength:
14668 {
14675 }
14676 ;
14678 BitWithoutLength:
14679 BIT opt_varying
14680 {
14681 /* bit defaults to bit(1), varbit to no limit */
14683 {
14685 }
14686 else
14687 {
14690 }
14692 }
14693 ;
14696 /*
14697 * SQL character data types
14698 * The following implements CHAR() and VARCHAR().
14699 */
14700 Character: CharacterWithLength
14701 {
14703 }
14704 | CharacterWithoutLength
14705 {
14707 }
14708 ;
14710 ConstCharacter: CharacterWithLength
14711 {
14713 }
14714 | CharacterWithoutLength
14715 {
14716 /* Length was not specified so allow to be unrestricted.
14717 * This handles problems with fixed-length (bpchar) strings
14718 * which in column definitions must default to a length
14719 * of one, but should not be constrained if the length
14720 * was not specified.
14721 */
14724 }
14725 ;
14728 {
14732 }
14733 ;
14735 CharacterWithoutLength: character
14736 {
14738 /* char defaults to char(1), varchar to no limit */
14742 }
14743 ;
14745 character: CHARACTER opt_varying
14747 | CHAR_P opt_varying
14749 | VARCHAR
14751 | NATIONAL CHARACTER opt_varying
14753 | NATIONAL CHAR_P opt_varying
14755 | NCHAR opt_varying
14757 ;
14759 opt_varying:
14762 ;
14764 /*
14765 * SQL date/time types
14766 */
14767 ConstDatetime:
14769 {
14772 else
14776 }
14777 | TIMESTAMP opt_timezone
14778 {
14781 else
14784 }
14786 {
14789 else
14793 }
14794 | TIME opt_timezone
14795 {
14798 else
14801 }
14802 ;
14804 ConstInterval:
14805 INTERVAL
14806 {
14809 }
14810 ;
14812 opt_timezone:
14816 ;
14818 opt_interval:
14819 YEAR_P
14821 | MONTH_P
14823 | DAY_P
14825 | HOUR_P
14827 | MINUTE_P
14829 | interval_second
14831 | YEAR_P TO MONTH_P
14832 {
14835 }
14836 | DAY_P TO HOUR_P
14837 {
14840 }
14841 | DAY_P TO MINUTE_P
14842 {
14846 }
14847 | DAY_P TO interval_second
14848 {
14854 }
14855 | HOUR_P TO MINUTE_P
14856 {
14859 }
14860 | HOUR_P TO interval_second
14861 {
14866 }
14867 | MINUTE_P TO interval_second
14868 {
14872 }
14873 | /*EMPTY*/
14875 ;
14877 interval_second:
14878 SECOND_P
14879 {
14881 }
14883 {
14886 }
14887 ;
14889 JsonType:
14890 JSON
14891 {
14894 }
14895 ;
14897 /*****************************************************************************
14898 *
14899 * expression grammar
14900 *
14901 *****************************************************************************/
14903 /*
14904 * General expressions
14905 * This is the heart of the expression syntax.
14906 *
14907 * We have two expression types: a_expr is the unrestricted kind, and
14908 * b_expr is a subset that must be used in some places to avoid shift/reduce
14909 * conflicts. For example, we can't do BETWEEN as "BETWEEN a_expr AND a_expr"
14910 * because that use of AND conflicts with AND as a boolean operator. So,
14911 * b_expr is used in BETWEEN and we remove boolean keywords from b_expr.
14912 *
14913 * Note that '(' a_expr ')' is a b_expr, so an unrestricted expression can
14914 * always be used by surrounding it with parens.
14915 *
14916 * c_expr is all the productions that are common to a_expr and b_expr;
14917 * it's factored out just to eliminate redundant coding.
14918 *
14919 * Be careful of productions involving more than one terminal token.
14920 * By default, bison will assign such productions the precedence of their
14921 * last terminal, but in nearly all cases you want it to be the precedence
14922 * of the first terminal instead; otherwise you will not get the behavior
14923 * you expect! So we use %prec annotations freely to set precedences.
14924 */
14926 | a_expr TYPECAST Typename
14928 | a_expr COLLATE any_name
14929 {
14936 }
14937 | a_expr AT TIME ZONE a_expr %prec AT
14938 {
14941 COERCE_SQL_SYNTAX,
14943 }
14944 | a_expr AT LOCAL %prec AT
14945 {
14948 COERCE_SQL_SYNTAX,
14950 }
14951 /*
14952 * These operators must be called out explicitly in order to make use
14953 * of bison's automatic operator-precedence handling. All other
14954 * operator names are handled by the generic productions using "Op",
14955 * below; and all those operators will have the same precedence.
14956 *
14957 * If you add more explicitly-known operators, be sure to add them
14958 * also to b_expr and to the MathOp list below.
14959 */
14960 | '+' a_expr %prec UMINUS
14962 | '-' a_expr %prec UMINUS
14964 | a_expr '+' a_expr
14966 | a_expr '-' a_expr
14968 | a_expr '*' a_expr
14970 | a_expr '/' a_expr
14972 | a_expr '%' a_expr
14974 | a_expr '^' a_expr
14976 | a_expr '<' a_expr
14978 | a_expr '>' a_expr
14980 | a_expr '=' a_expr
14982 | a_expr LESS_EQUALS a_expr
14984 | a_expr GREATER_EQUALS a_expr
14986 | a_expr NOT_EQUALS a_expr
14989 | a_expr qual_Op a_expr %prec Op
14991 | qual_Op a_expr %prec Op
14994 | a_expr AND a_expr
14996 | a_expr OR a_expr
14998 | NOT a_expr
15000 | NOT_LA a_expr %prec NOT
15003 | a_expr LIKE a_expr
15004 {
15007 }
15008 | a_expr LIKE a_expr ESCAPE a_expr %prec LIKE
15009 {
15012 COERCE_EXPLICIT_CALL,
15016 }
15017 | a_expr NOT_LA LIKE a_expr %prec NOT_LA
15018 {
15021 }
15022 | a_expr NOT_LA LIKE a_expr ESCAPE a_expr %prec NOT_LA
15023 {
15026 COERCE_EXPLICIT_CALL,
15030 }
15031 | a_expr ILIKE a_expr
15032 {
15035 }
15036 | a_expr ILIKE a_expr ESCAPE a_expr %prec ILIKE
15037 {
15040 COERCE_EXPLICIT_CALL,
15044 }
15045 | a_expr NOT_LA ILIKE a_expr %prec NOT_LA
15046 {
15049 }
15050 | a_expr NOT_LA ILIKE a_expr ESCAPE a_expr %prec NOT_LA
15051 {
15054 COERCE_EXPLICIT_CALL,
15058 }
15060 | a_expr SIMILAR TO a_expr %prec SIMILAR
15061 {
15064 COERCE_EXPLICIT_CALL,
15068 }
15069 | a_expr SIMILAR TO a_expr ESCAPE a_expr %prec SIMILAR
15070 {
15073 COERCE_EXPLICIT_CALL,
15077 }
15078 | a_expr NOT_LA SIMILAR TO a_expr %prec NOT_LA
15079 {
15082 COERCE_EXPLICIT_CALL,
15086 }
15087 | a_expr NOT_LA SIMILAR TO a_expr ESCAPE a_expr %prec NOT_LA
15088 {
15091 COERCE_EXPLICIT_CALL,
15095 }
15097 /* NullTest clause
15098 * Define SQL-style Null test clause.
15099 * Allow two forms described in the standard:
15100 * a IS NULL
15101 * a IS NOT NULL
15102 * Allow two SQL extensions
15103 * a ISNULL
15104 * a NOTNULL
15105 */
15106 | a_expr IS NULL_P %prec IS
15107 {
15114 }
15115 | a_expr ISNULL
15116 {
15123 }
15124 | a_expr IS NOT NULL_P %prec IS
15125 {
15132 }
15133 | a_expr NOTNULL
15134 {
15141 }
15142 | row OVERLAPS row
15143 {
15156 COERCE_SQL_SYNTAX,
15158 }
15159 | a_expr IS TRUE_P %prec IS
15160 {
15167 }
15168 | a_expr IS NOT TRUE_P %prec IS
15169 {
15176 }
15177 | a_expr IS FALSE_P %prec IS
15178 {
15185 }
15186 | a_expr IS NOT FALSE_P %prec IS
15187 {
15194 }
15195 | a_expr IS UNKNOWN %prec IS
15196 {
15203 }
15204 | a_expr IS NOT UNKNOWN %prec IS
15205 {
15212 }
15213 | a_expr IS DISTINCT FROM a_expr %prec IS
15214 {
15216 }
15217 | a_expr IS NOT DISTINCT FROM a_expr %prec IS
15218 {
15220 }
15221 | a_expr BETWEEN opt_asymmetric b_expr AND a_expr %prec BETWEEN
15222 {
15228 }
15229 | a_expr NOT_LA BETWEEN opt_asymmetric b_expr AND a_expr %prec NOT_LA
15230 {
15236 }
15237 | a_expr BETWEEN SYMMETRIC b_expr AND a_expr %prec BETWEEN
15238 {
15244 }
15245 | a_expr NOT_LA BETWEEN SYMMETRIC b_expr AND a_expr %prec NOT_LA
15246 {
15252 }
15253 | a_expr IN_P in_expr
15254 {
15255 /* in_expr returns a SubLink or a list of a_exprs */
15257 {
15258 /* generate foo = ANY (subquery) */
15267 }
15268 else
15269 {
15270 /* generate scalar IN expression */
15272 }
15273 }
15274 | a_expr NOT_LA IN_P in_expr %prec NOT_LA
15275 {
15276 /* in_expr returns a SubLink or a list of a_exprs */
15278 {
15279 /* generate NOT (foo = ANY (subquery)) */
15280 /* Make an = ANY node */
15288 /* Stick a NOT on top; must have same parse location */
15290 }
15291 else
15292 {
15293 /* generate scalar NOT IN expression */
15295 }
15296 }
15297 | a_expr subquery_Op sub_type select_with_parens %prec Op
15298 {
15308 }
15310 {
15313 else
15315 }
15316 | UNIQUE opt_unique_null_treatment select_with_parens
15317 {
15318 /* Not sure how to get rid of the parentheses
15319 * but there are lots of shift/reduce errors without them.
15320 *
15321 * Should be able to implement this by plopping the entire
15322 * select into a node, then transforming the target expressions
15323 * from whatever they are into count(*), and testing the
15324 * entire result equal to one.
15325 * But, will probably implement a separate node in the executor.
15326 */
15331 }
15332 | a_expr IS DOCUMENT_P %prec IS
15333 {
15336 }
15337 | a_expr IS NOT DOCUMENT_P %prec IS
15338 {
15342 }
15343 | a_expr IS NORMALIZED %prec IS
15344 {
15347 COERCE_SQL_SYNTAX,
15349 }
15350 | a_expr IS unicode_normal_form NORMALIZED %prec IS
15351 {
15354 COERCE_SQL_SYNTAX,
15356 }
15357 | a_expr IS NOT NORMALIZED %prec IS
15358 {
15361 COERCE_SQL_SYNTAX,
15364 }
15365 | a_expr IS NOT unicode_normal_form NORMALIZED %prec IS
15366 {
15369 COERCE_SQL_SYNTAX,
15372 }
15373 | a_expr IS json_predicate_type_constraint
15374 json_key_uniqueness_constraint_opt %prec IS
15375 {
15379 }
15380 /*
15381 * Required by SQL/JSON, but there are conflicts
15382 | a_expr
15383 json_format_clause
15384 IS json_predicate_type_constraint
15385 json_key_uniqueness_constraint_opt %prec IS
15386 {
15387 $$ = makeJsonIsPredicate($1, $2, $4, $5, @1);
15388 }
15389 */
15390 | a_expr IS NOT
15391 json_predicate_type_constraint
15392 json_key_uniqueness_constraint_opt %prec IS
15393 {
15397 }
15398 /*
15399 * Required by SQL/JSON, but there are conflicts
15400 | a_expr
15401 json_format_clause
15402 IS NOT
15403 json_predicate_type_constraint
15404 json_key_uniqueness_constraint_opt %prec IS
15405 {
15406 $$ = makeNotExpr(makeJsonIsPredicate($1, $2, $5, $6, @1), @1);
15407 }
15408 */
15409 | DEFAULT
15410 {
15411 /*
15412 * The SQL spec only allows DEFAULT in "contextually typed
15413 * expressions", but for us, it's easier to allow it in
15414 * any a_expr and then throw error during parse analysis
15415 * if it's in an inappropriate context. This way also
15416 * lets us say something smarter than "syntax error".
15417 */
15420 /* parse analysis will fill in the rest */
15423 }
15424 ;
15426 /*
15427 * Restricted expressions
15428 *
15429 * b_expr is a subset of the complete expression syntax defined by a_expr.
15430 *
15431 * Presently, AND, NOT, IS, and IN are the a_expr keywords that would
15432 * cause trouble in the places where b_expr is used. For simplicity, we
15433 * just eliminate all the boolean-keyword-operator productions from b_expr.
15434 */
15435 b_expr: c_expr
15437 | b_expr TYPECAST Typename
15439 | '+' b_expr %prec UMINUS
15441 | '-' b_expr %prec UMINUS
15443 | b_expr '+' b_expr
15445 | b_expr '-' b_expr
15447 | b_expr '*' b_expr
15449 | b_expr '/' b_expr
15451 | b_expr '%' b_expr
15453 | b_expr '^' b_expr
15455 | b_expr '<' b_expr
15457 | b_expr '>' b_expr
15459 | b_expr '=' b_expr
15461 | b_expr LESS_EQUALS b_expr
15463 | b_expr GREATER_EQUALS b_expr
15465 | b_expr NOT_EQUALS b_expr
15467 | b_expr qual_Op b_expr %prec Op
15469 | qual_Op b_expr %prec Op
15471 | b_expr IS DISTINCT FROM b_expr %prec IS
15472 {
15474 }
15475 | b_expr IS NOT DISTINCT FROM b_expr %prec IS
15476 {
15478 }
15479 | b_expr IS DOCUMENT_P %prec IS
15480 {
15483 }
15484 | b_expr IS NOT DOCUMENT_P %prec IS
15485 {
15489 }
15490 ;
15492 /*
15493 * Productions that can be used in both a_expr and b_expr.
15494 *
15495 * Note: productions that refer recursively to a_expr or b_expr mostly
15496 * cannot appear here. However, it's OK to refer to a_exprs that occur
15497 * inside parentheses, such as function arguments; that cannot introduce
15498 * ambiguity to the b_expr syntax.
15499 */
15502 | PARAM opt_indirection
15503 {
15509 {
15515 }
15516 else
15518 }
15520 {
15522 {
15528 }
15529 else
15531 }
15532 | case_expr
15534 | func_expr
15536 | select_with_parens %prec UMINUS
15537 {
15547 }
15548 | select_with_parens indirection
15549 {
15550 /*
15551 * Because the select_with_parens nonterminal is designed
15552 * to "eat" as many levels of parens as possible, the
15553 * '(' a_expr ')' opt_indirection production above will
15554 * fail to match a sub-SELECT with indirection decoration;
15555 * the sub-SELECT won't be regarded as an a_expr as long
15556 * as there are parens around it. To support applying
15557 * subscripting or field selection to a sub-SELECT result,
15558 * we need this redundant-looking production.
15559 */
15572 }
15573 | EXISTS select_with_parens
15574 {
15584 }
15585 | ARRAY select_with_parens
15586 {
15596 }
15597 | ARRAY array_expr
15598 {
15601 /* point outermost A_ArrayExpr to the ARRAY keyword */
15604 }
15605 | explicit_row
15606 {
15615 }
15616 | implicit_row
15617 {
15626 }
15628 {
15634 }
15635 ;
15638 {
15640 COERCE_EXPLICIT_CALL,
15642 }
15644 {
15646 COERCE_EXPLICIT_CALL,
15651 }
15653 {
15655 COERCE_EXPLICIT_CALL,
15661 }
15663 {
15665 COERCE_EXPLICIT_CALL,
15671 }
15673 {
15675 COERCE_EXPLICIT_CALL,
15679 /* Ideally we'd mark the FuncCall node to indicate
15680 * "must be an aggregate", but there's no provision
15681 * for that in FuncCall at the moment.
15682 */
15684 }
15686 {
15688 COERCE_EXPLICIT_CALL,
15694 }
15696 {
15697 /*
15698 * We consider AGGREGATE(*) to invoke a parameterless
15699 * aggregate. This does the right thing for COUNT(*),
15700 * and there are no other aggregates in SQL that accept
15701 * '*' as parameter.
15702 *
15703 * The FuncCall node is also marked agg_star = true,
15704 * so that later processing can detect what the argument
15705 * really was.
15706 */
15708 COERCE_EXPLICIT_CALL,
15713 }
15714 ;
15717 /*
15718 * func_expr and its cousin func_expr_windowless are split out from c_expr just
15719 * so that we have classifications for "everything that is a function call or
15720 * looks like one". This isn't very important, but it saves us having to
15721 * document which variants are legal in places like "FROM function()" or the
15722 * backwards-compatible functional-index syntax for CREATE INDEX.
15723 * (Note that many of the special SQL functions wouldn't actually make any
15724 * sense as functional index entries, but we ignore that consideration here.)
15725 */
15726 func_expr: func_application within_group_clause filter_clause over_clause
15727 {
15730 /*
15731 * The order clause for WITHIN GROUP and the one for
15732 * plain-aggregate ORDER BY share a field, so we have to
15733 * check here that at most one is present. We also check
15734 * for DISTINCT and VARIADIC here to give a better error
15735 * location. Other consistency checks are deferred to
15736 * parse analysis.
15737 */
15739 {
15757 }
15761 }
15762 | json_aggregate_func filter_clause over_clause
15763 {
15771 }
15772 | func_expr_common_subexpr
15774 ;
15776 /*
15777 * Like func_expr but does not accept WINDOW functions directly
15778 * (but they can still be contained in arguments for functions etc).
15779 * Use this when window expressions are not allowed, where needed to
15780 * disambiguate the grammar (e.g. in CREATE INDEX).
15781 */
15782 func_expr_windowless:
15786 ;
15788 /*
15789 * Special expressions that are considered to be functions.
15790 */
15791 func_expr_common_subexpr:
15793 {
15796 COERCE_SQL_SYNTAX,
15798 }
15799 | CURRENT_DATE
15800 {
15802 }
15803 | CURRENT_TIME
15804 {
15806 }
15808 {
15810 }
15811 | CURRENT_TIMESTAMP
15812 {
15814 }
15816 {
15818 }
15819 | LOCALTIME
15820 {
15822 }
15824 {
15826 }
15827 | LOCALTIMESTAMP
15828 {
15830 }
15832 {
15834 }
15835 | CURRENT_ROLE
15836 {
15838 }
15839 | CURRENT_USER
15840 {
15842 }
15843 | SESSION_USER
15844 {
15846 }
15847 | SYSTEM_USER
15848 {
15850 NIL,
15851 COERCE_SQL_SYNTAX,
15853 }
15854 | USER
15855 {
15857 }
15858 | CURRENT_CATALOG
15859 {
15861 }
15862 | CURRENT_SCHEMA
15863 {
15865 }
15869 {
15872 COERCE_SQL_SYNTAX,
15874 }
15876 {
15879 COERCE_SQL_SYNTAX,
15881 }
15883 {
15886 COERCE_SQL_SYNTAX,
15888 }
15890 {
15893 COERCE_SQL_SYNTAX,
15895 }
15897 {
15898 /*
15899 * allow functions named overlay() to be called without
15900 * special syntax
15901 */
15904 COERCE_EXPLICIT_CALL,
15906 }
15908 {
15909 /*
15910 * position(A in B) is converted to position(B, A)
15911 *
15912 * We deliberately don't offer a "plain syntax" option
15913 * for position(), because the reversal of the arguments
15914 * creates too much risk of confusion.
15915 */
15918 COERCE_SQL_SYNTAX,
15920 }
15922 {
15923 /* substring(A from B for C) is converted to
15924 * substring(A, B, C) - thomas 2000-11-28
15925 */
15928 COERCE_SQL_SYNTAX,
15930 }
15932 {
15933 /*
15934 * allow functions named substring() to be called without
15935 * special syntax
15936 */
15939 COERCE_EXPLICIT_CALL,
15941 }
15943 {
15944 /* TREAT(expr AS target) converts expr of a particular type to target,
15945 * which is defined to be a subtype of the original expression.
15946 * In SQL99, this is intended for use with structured UDTs,
15947 * but let's make this a generally useful form allowing stronger
15948 * coercions than are handled by implicit casting.
15949 *
15950 * Convert SystemTypeName() to SystemFuncName() even though
15951 * at the moment they result in the same thing.
15952 */
15955 COERCE_EXPLICIT_CALL,
15957 }
15959 {
15960 /* various trim expressions are defined in SQL
15961 * - thomas 1997-07-19
15962 */
15965 COERCE_SQL_SYNTAX,
15967 }
15969 {
15972 COERCE_SQL_SYNTAX,
15974 }
15976 {
15979 COERCE_SQL_SYNTAX,
15981 }
15983 {
15986 COERCE_SQL_SYNTAX,
15988 }
15990 {
15992 }
15994 {
16000 }
16002 {
16009 }
16011 {
16018 }
16020 {
16022 }
16024 {
16026 }
16028 {
16030 }
16032 {
16034 }
16036 {
16038 }
16040 {
16041 /* xmlexists(A PASSING [BY REF] B [BY REF]) is
16042 * converted to xmlexists(A, B)*/
16045 COERCE_SQL_SYNTAX,
16047 }
16049 {
16051 }
16053 {
16061 }
16063 {
16065 }
16067 {
16069 }
16071 {
16074 }
16076 {
16085 }
16087 {
16088 /* Support for legacy (non-standard) json_object() */
16091 }
16092 | JSON_OBJECT '(' json_name_and_value_list
16093 json_object_constructor_null_clause_opt
16094 json_key_uniqueness_constraint_opt
16095 json_returning_clause_opt ')'
16096 {
16105 }
16107 {
16116 }
16117 | JSON_ARRAY '('
16118 json_value_expr_list
16119 json_array_constructor_null_clause_opt
16120 json_returning_clause_opt
16121 ')'
16122 {
16130 }
16131 | JSON_ARRAY '('
16132 select_no_parens
16133 json_format_clause_opt
16134 /* json_array_constructor_null_clause_opt */
16135 json_returning_clause_opt
16136 ')'
16137 {
16146 }
16147 | JSON_ARRAY '('
16148 json_returning_clause_opt
16149 ')'
16150 {
16158 }
16160 {
16168 }
16170 {
16177 }
16179 {
16186 }
16188 {
16194 }
16195 | JSON_QUERY '('
16196 json_value_expr ',' a_expr json_passing_clause_opt
16197 json_returning_clause_opt
16198 json_wrapper_behavior
16199 json_quotes_clause_opt
16200 json_behavior_clause_opt
16201 ')'
16202 {
16216 }
16217 | JSON_EXISTS '('
16218 json_value_expr ',' a_expr json_passing_clause_opt
16219 json_on_error_clause_opt
16220 ')'
16221 {
16232 }
16233 | JSON_VALUE '('
16234 json_value_expr ',' a_expr json_passing_clause_opt
16235 json_returning_clause_opt
16236 json_behavior_clause_opt
16237 ')'
16238 {
16250 }
16251 ;
16254 /*
16255 * SQL/XML support
16256 */
16257 xml_root_version: VERSION_P a_expr
16259 | VERSION_P NO VALUE_P
16261 ;
16265 | ',' STANDALONE_P NO
16267 | ',' STANDALONE_P NO VALUE_P
16269 | /*EMPTY*/
16271 ;
16274 ;
16278 ;
16280 xml_attribute_el: a_expr AS ColLabel
16281 {
16287 }
16288 | a_expr
16289 {
16295 }
16296 ;
16300 ;
16305 ;
16310 ;
16312 /* We allow several variants for SQL and other compatibility. */
16313 xmlexists_argument:
16314 PASSING c_expr
16315 {
16317 }
16318 | PASSING c_expr xml_passing_mech
16319 {
16321 }
16322 | PASSING xml_passing_mech c_expr
16323 {
16325 }
16326 | PASSING xml_passing_mech c_expr xml_passing_mech
16327 {
16329 }
16330 ;
16332 xml_passing_mech:
16333 BY REF_P
16334 | BY VALUE_P
16335 ;
16338 /*
16339 * Aggregate decoration clauses
16340 */
16341 within_group_clause:
16344 ;
16346 filter_clause:
16349 ;
16352 /*
16353 * Window Definitions
16354 */
16355 window_clause:
16358 ;
16360 window_definition_list:
16362 | window_definition_list ',' window_definition
16364 ;
16366 window_definition:
16367 ColId AS window_specification
16368 {
16373 }
16374 ;
16376 over_clause: OVER window_specification
16378 | OVER ColId
16379 {
16391 }
16392 | /*EMPTY*/
16394 ;
16397 opt_sort_clause opt_frame_clause ')'
16398 {
16405 /* copy relevant fields of opt_frame_clause */
16411 }
16412 ;
16414 /*
16415 * If we see PARTITION, RANGE, ROWS or GROUPS as the first token after the '('
16416 * of a window_specification, we want the assumption to be that there is
16417 * no existing_window_name; but those keywords are unreserved and so could
16418 * be ColIds. We fix this by making them have the same precedence as IDENT
16419 * and giving the empty production here a slightly higher precedence, so
16420 * that the shift/reduce conflict is resolved in favor of reducing the rule.
16421 * These keywords are thus precluded from being an existing_window_name but
16422 * are not reserved for any other purpose.
16423 */
16426 ;
16430 ;
16432 /*
16433 * For frame clauses, we return a WindowDef, but only some fields are used:
16434 * frameOptions, startOffset, and endOffset.
16435 */
16436 opt_frame_clause:
16437 RANGE frame_extent opt_window_exclusion_clause
16438 {
16444 }
16445 | ROWS frame_extent opt_window_exclusion_clause
16446 {
16452 }
16453 | GROUPS frame_extent opt_window_exclusion_clause
16454 {
16460 }
16461 | /*EMPTY*/
16462 {
16469 }
16470 ;
16472 frame_extent: frame_bound
16473 {
16476 /* reject invalid cases */
16489 }
16490 | BETWEEN frame_bound AND frame_bound
16491 {
16495 /* form merged options */
16497 /* shift converts START_ options to END_ options */
16500 /* reject invalid cases */
16519 FRAMEOPTION_END_CURRENT_ROW)))
16527 }
16528 ;
16530 /*
16531 * This is used for both frame start and frame end, with output set up on
16532 * the assumption it's frame start; the frame_extent productions must reject
16533 * invalid cases.
16534 */
16535 frame_bound:
16536 UNBOUNDED PRECEDING
16537 {
16544 }
16545 | UNBOUNDED FOLLOWING
16546 {
16553 }
16554 | CURRENT_P ROW
16555 {
16562 }
16563 | a_expr PRECEDING
16564 {
16571 }
16572 | a_expr FOLLOWING
16573 {
16580 }
16581 ;
16583 opt_window_exclusion_clause:
16589 ;
16592 /*
16593 * Supporting nonterminals for expressions.
16594 */
16596 /* Explicit row production.
16597 *
16598 * SQL99 allows an optional ROW keyword, so we can now do single-element rows
16599 * without conflicting with the parenthesized a_expr production. Without the
16600 * ROW keyword, there must be more than one a_expr inside the parens.
16601 */
16605 ;
16609 ;
16612 ;
16617 ;
16621 ;
16635 ;
16637 qual_Op: Op
16641 ;
16643 qual_all_Op:
16644 all_Op
16648 ;
16650 subquery_Op:
16651 all_Op
16655 | LIKE
16657 | NOT_LA LIKE
16659 | ILIKE
16661 | NOT_LA ILIKE
16663 /* cannot put SIMILAR TO here, because SIMILAR TO is a hack.
16664 * the regular expression is preprocessed by a function (similar_to_escape),
16665 * and the ~ operator for posix regular expressions is used.
16666 * x SIMILAR TO y -> x ~ similar_to_escape(y)
16667 * this transformation is made on the fly by the parser upwards.
16668 * however the SubLink structure which handles any/some/all stuff
16669 * is not ready for such a thing.
16670 */
16671 ;
16673 expr_list: a_expr
16674 {
16676 }
16677 | expr_list ',' a_expr
16678 {
16680 }
16681 ;
16683 /* function arguments can have names */
16684 func_arg_list: func_arg_expr
16685 {
16687 }
16688 | func_arg_list ',' func_arg_expr
16689 {
16691 }
16692 ;
16694 func_arg_expr: a_expr
16695 {
16697 }
16698 | param_name COLON_EQUALS a_expr
16699 {
16707 }
16708 | param_name EQUALS_GREATER a_expr
16709 {
16717 }
16718 ;
16722 ;
16726 ;
16729 {
16731 }
16733 {
16735 }
16737 {
16739 }
16740 ;
16744 ;
16747 extract_list:
16748 extract_arg FROM a_expr
16749 {
16751 }
16752 ;
16754 /* Allow delimited string Sconst in extract_arg as an SQL extension.
16755 * - thomas 2001-04-12
16756 */
16757 extract_arg:
16766 ;
16768 unicode_normal_form:
16773 ;
16775 /* OVERLAY() arguments */
16776 overlay_list:
16777 a_expr PLACING a_expr FROM a_expr FOR a_expr
16778 {
16779 /* overlay(A PLACING B FROM C FOR D) is converted to overlay(A, B, C, D) */
16781 }
16782 | a_expr PLACING a_expr FROM a_expr
16783 {
16784 /* overlay(A PLACING B FROM C) is converted to overlay(A, B, C) */
16786 }
16787 ;
16789 /* position_list uses b_expr not a_expr to avoid conflict with general IN */
16790 position_list:
16792 ;
16794 /*
16795 * SUBSTRING() arguments
16796 *
16797 * Note that SQL:1999 has both
16798 * text FROM int FOR int
16799 * and
16800 * text FROM pattern FOR escape
16801 *
16802 * In the parser we map them both to a call to the substring() function and
16803 * rely on type resolution to pick the right one.
16804 *
16805 * In SQL:2003, the second variant was changed to
16806 * text SIMILAR pattern ESCAPE escape
16807 * We could in theory map that to a different function internally, but
16808 * since we still support the SQL:1999 version, we don't. However,
16809 * ruleutils.c will reverse-list the call in the newer style.
16810 */
16811 substr_list:
16812 a_expr FROM a_expr FOR a_expr
16813 {
16815 }
16816 | a_expr FOR a_expr FROM a_expr
16817 {
16818 /* not legal per SQL, but might as well allow it */
16820 }
16821 | a_expr FROM a_expr
16822 {
16823 /*
16824 * Because we aren't restricting data types here, this
16825 * syntax can end up resolving to textregexsubstr().
16826 * We've historically allowed that to happen, so continue
16827 * to accept it. However, ruleutils.c will reverse-list
16828 * such a call in regular function call syntax.
16829 */
16831 }
16832 | a_expr FOR a_expr
16833 {
16834 /* not legal per SQL */
16836 /*
16837 * Since there are no cases where this syntax allows
16838 * a textual FOR value, we forcibly cast the argument
16839 * to int4. The possible matches in pg_proc are
16840 * substring(text,int4) and substring(text,text),
16841 * and we don't want the parser to choose the latter,
16842 * which it is likely to do if the second argument
16843 * is unknown or doesn't have an implicit cast to int4.
16844 */
16848 }
16849 | a_expr SIMILAR a_expr ESCAPE a_expr
16850 {
16852 }
16853 ;
16858 ;
16860 in_expr: select_with_parens
16861 {
16865 /* other fields will be filled later */
16867 }
16869 ;
16871 /*
16872 * Define SQL-style CASE clause.
16873 * - Full specification
16874 * CASE WHEN a = b THEN c ... ELSE d END
16875 * - Implicit argument
16876 * CASE a WHEN b THEN c ... ELSE d END
16877 */
16878 case_expr: CASE case_arg when_clause_list case_default END_P
16879 {
16888 }
16889 ;
16891 when_clause_list:
16892 /* There must be at least one */
16895 ;
16897 when_clause:
16898 WHEN a_expr THEN a_expr
16899 {
16906 }
16907 ;
16909 case_default:
16912 ;
16916 ;
16918 columnref: ColId
16919 {
16921 }
16922 | ColId indirection
16923 {
16925 }
16926 ;
16928 indirection_el:
16929 '.' attr_name
16930 {
16932 }
16934 {
16936 }
16938 {
16945 }
16947 {
16954 }
16955 ;
16957 opt_slice_bound:
16960 ;
16962 indirection:
16965 ;
16967 opt_indirection:
16970 ;
16972 opt_asymmetric: ASYMMETRIC
16973 | /*EMPTY*/
16974 ;
16976 /* SQL/JSON support */
16977 json_passing_clause_opt:
16980 ;
16982 json_arguments:
16985 ;
16987 json_argument:
16988 json_value_expr AS ColLabel
16989 {
16995 }
16996 ;
16998 /* ARRAY is a noise word */
16999 json_wrapper_behavior:
17009 ;
17011 json_behavior:
17012 DEFAULT a_expr
17014 | json_behavior_type
17016 ;
17018 json_behavior_type:
17026 /* non-standard, for Oracle compatibility only */
17028 ;
17030 json_behavior_clause_opt:
17031 json_behavior ON EMPTY_P
17033 | json_behavior ON ERROR_P
17035 | json_behavior ON EMPTY_P json_behavior ON ERROR_P
17037 | /* EMPTY */
17039 ;
17041 json_on_error_clause_opt:
17042 json_behavior ON ERROR_P
17044 | /* EMPTY */
17046 ;
17048 json_value_expr:
17049 a_expr json_format_clause_opt
17050 {
17051 /* formatted_expr will be set during parse-analysis. */
17054 }
17055 ;
17057 json_format_clause:
17058 FORMAT_LA JSON ENCODING name
17059 {
17068 else
17075 }
17076 | FORMAT_LA JSON
17077 {
17079 }
17080 ;
17082 json_format_clause_opt:
17083 json_format_clause
17084 {
17086 }
17087 | /* EMPTY */
17088 {
17090 }
17091 ;
17093 json_quotes_clause_opt:
17099 ;
17101 json_returning_clause_opt:
17102 RETURNING Typename json_format_clause_opt
17103 {
17110 }
17112 ;
17114 /*
17115 * We must assign the only-JSON production a precedence less than IDENT in
17116 * order to favor shifting over reduction when JSON is followed by VALUE_P,
17117 * OBJECT_P, or SCALAR. (ARRAY doesn't need that treatment, because it's a
17118 * fully reserved word.) Because json_predicate_type_constraint is always
17119 * followed by json_key_uniqueness_constraint_opt, we also need the only-JSON
17120 * production to have precedence less than WITH and WITHOUT. UNBOUNDED isn't
17121 * really related to this syntax, but it's a convenient choice because it
17122 * already has a precedence less than IDENT for other reasons.
17123 */
17124 json_predicate_type_constraint:
17130 ;
17132 /*
17133 * KEYS is a noise word here. To avoid shift/reduce conflicts, assign the
17134 * KEYS-less productions a precedence less than IDENT (i.e., less than KEYS).
17135 * This prevents reducing them when the next token is KEYS.
17136 */
17137 json_key_uniqueness_constraint_opt:
17143 ;
17145 json_name_and_value_list:
17146 json_name_and_value
17148 | json_name_and_value_list ',' json_name_and_value
17150 ;
17152 json_name_and_value:
17153 /* Supporting this syntax seems to require major surgery
17154 KEY c_expr VALUE_P json_value_expr
17155 { $$ = makeJsonKeyValue($2, $4); }
17156 |
17157 */
17158 c_expr VALUE_P json_value_expr
17160 |
17161 a_expr ':' json_value_expr
17163 ;
17165 /* empty means false for objects, true for arrays */
17166 json_object_constructor_null_clause_opt:
17170 ;
17172 json_array_constructor_null_clause_opt:
17176 ;
17178 json_value_expr_list:
17181 ;
17183 json_aggregate_func:
17184 JSON_OBJECTAGG '('
17185 json_name_and_value
17186 json_object_constructor_null_clause_opt
17187 json_key_uniqueness_constraint_opt
17188 json_returning_clause_opt
17189 ')'
17190 {
17201 }
17202 | JSON_ARRAYAGG '('
17203 json_value_expr
17204 json_array_aggregate_order_by_clause_opt
17205 json_array_constructor_null_clause_opt
17206 json_returning_clause_opt
17207 ')'
17208 {
17218 }
17219 ;
17221 json_array_aggregate_order_by_clause_opt:
17224 ;
17226 /*****************************************************************************
17227 *
17228 * target list for SELECT
17229 *
17230 *****************************************************************************/
17234 ;
17236 target_list:
17239 ;
17241 target_el: a_expr AS ColLabel
17242 {
17248 }
17249 | a_expr BareColLabel
17250 {
17256 }
17257 | a_expr
17258 {
17264 }
17265 | '*'
17266 {
17277 }
17278 ;
17281 /*****************************************************************************
17282 *
17283 * Names and constants
17284 *
17285 *****************************************************************************/
17287 qualified_name_list:
17290 ;
17292 /*
17293 * The production for a qualified relation name has to exactly match the
17294 * production for a qualified func_name, because in a FROM clause we cannot
17295 * tell which we are parsing until we see what comes after it ('(' for a
17296 * func_name, something else for a relation). Therefore we allow 'indirection'
17297 * which may contain subscripts, and reject that case in the C code.
17298 */
17299 qualified_name:
17300 ColId
17301 {
17303 }
17304 | ColId indirection
17305 {
17307 }
17308 ;
17310 name_list: name
17312 | name_list ',' name
17314 ;
17323 /*
17324 * The production for a qualified func_name has to exactly match the
17325 * production for a qualified columnref, because we cannot tell which we
17326 * are parsing until we see what comes after it ('(' or Sconst for a func_name,
17327 * anything else for a columnref). Therefore we allow 'indirection' which
17328 * may contain subscripts, and reject that case in the C code. (If we
17329 * ever implement SQL99-like methods, such syntax may actually become legal!)
17330 */
17331 func_name: type_function_name
17333 | ColId indirection
17334 {
17336 yyscanner);
17337 }
17338 ;
17341 /*
17342 * Constants
17343 */
17344 AexprConst: Iconst
17345 {
17347 }
17348 | FCONST
17349 {
17351 }
17352 | Sconst
17353 {
17355 }
17356 | BCONST
17357 {
17359 }
17360 | XCONST
17361 {
17362 /* This is a bit constant per SQL99:
17363 * Without Feature F511, "BIT data type",
17364 * a <general literal> shall not be a
17365 * <bit string literal> or a <hex string literal>.
17366 */
17368 }
17369 | func_name Sconst
17370 {
17371 /* generic type 'literal' syntax */
17376 }
17378 {
17379 /* generic syntax with a type modifier */
17383 /*
17384 * We must use func_arg_list and opt_sort_clause in the
17385 * production to avoid reduce/reduce conflicts, but we
17386 * don't actually wish to allow NamedArgExpr in this
17387 * context, nor ORDER BY.
17388 */
17390 {
17398 }
17408 }
17409 | ConstTypename Sconst
17410 {
17412 }
17413 | ConstInterval Sconst opt_interval
17414 {
17419 }
17421 {
17427 }
17428 | TRUE_P
17429 {
17431 }
17432 | FALSE_P
17433 {
17435 }
17436 | NULL_P
17437 {
17439 }
17440 ;
17448 ;
17450 /* Role specifications */
17451 RoleId: RoleSpec
17452 {
17456 {
17457 case ROLESPEC_CSTRING:
17459 break;
17460 case ROLESPEC_PUBLIC:
17466 break;
17467 case ROLESPEC_SESSION_USER:
17473 break;
17474 case ROLESPEC_CURRENT_USER:
17480 break;
17481 case ROLESPEC_CURRENT_ROLE:
17487 break;
17488 }
17489 }
17490 ;
17492 RoleSpec: NonReservedWord
17493 {
17494 /*
17495 * "public" and "none" are not keywords, but they must
17496 * be treated specially here.
17497 */
17501 {
17504 }
17506 {
17512 }
17513 else
17514 {
17517 }
17519 }
17520 | CURRENT_ROLE
17521 {
17523 }
17524 | CURRENT_USER
17525 {
17527 }
17528 | SESSION_USER
17529 {
17531 }
17532 ;
17534 role_list: RoleSpec
17536 | role_list ',' RoleSpec
17538 ;
17541 /*****************************************************************************
17542 *
17543 * PL/pgSQL extensions
17544 *
17545 * You'd think a PL/pgSQL "expression" should be just an a_expr, but
17546 * historically it can include just about anything that can follow SELECT.
17547 * Therefore the returned struct is a SelectStmt.
17548 *****************************************************************************/
17550 PLpgSQL_Expr: opt_distinct_clause opt_target_list
17551 from_clause where_clause
17552 group_clause having_clause window_clause
17553 opt_sort_clause opt_select_limit opt_for_locking_clause
17554 {
17567 {
17577 }
17580 }
17581 ;
17583 /*
17584 * PL/pgSQL Assignment statement: name opt_indirection := PLpgSQL_Expr
17585 */
17587 PLAssignStmt: plassign_target opt_indirection plassign_equals PLpgSQL_Expr
17588 {
17593 /* nnames will be filled by calling production */
17597 }
17598 ;
17602 ;
17604 plassign_equals: COLON_EQUALS
17605 | '='
17606 ;
17609 /*
17610 * Name classification hierarchy.
17611 *
17612 * IDENT is the lexeme returned by the lexer for identifiers that match
17613 * no known keyword. In most cases, we can accept certain keywords as
17614 * names, not only IDENTs. We prefer to accept as many such keywords
17615 * as possible to minimize the impact of "reserved words" on programmers.
17616 * So, we divide names into several possible classes. The classification
17617 * is chosen in part to make keywords acceptable as names wherever possible.
17618 */
17620 /* Column identifier --- names that can be column, table, etc names.
17621 */
17625 ;
17627 /* Type/function identifier --- names that can be type or function names.
17628 */
17632 ;
17634 /* Any not-fully-reserved word --- these names can be, eg, role names.
17635 */
17640 ;
17642 /* Column label --- allowed labels in "AS" clauses.
17643 * This presently includes *all* Postgres keywords.
17644 */
17650 ;
17652 /* Bare column label --- names that can be column labels without writing "AS".
17653 * This classification is orthogonal to the other keyword categories.
17654 */
17657 ;
17660 /*
17661 * Keyword category lists. Generally, every keyword present in
17662 * the Postgres grammar should appear in exactly one of these lists.
17663 *
17664 * Put a new keyword into the first list that it can go into without causing
17665 * shift or reduce conflicts. The earlier lists define "less reserved"
17666 * categories of keywords.
17667 *
17668 * Make sure that each keyword's category in kwlist.h matches where
17669 * it is listed here. (Someday we may be able to generate these lists and
17670 * kwlist.h's table from one source of truth.)
17671 */
17673 /* "Unreserved" keywords --- available for use as any kind of name.
17674 */
17675 unreserved_keyword:
17676 ABORT_P
17677 | ABSENT
17678 | ABSOLUTE_P
17679 | ACCESS
17680 | ACTION
17681 | ADD_P
17682 | ADMIN
17683 | AFTER
17684 | AGGREGATE
17685 | ALSO
17686 | ALTER
17687 | ALWAYS
17688 | ASENSITIVE
17689 | ASSERTION
17690 | ASSIGNMENT
17691 | AT
17692 | ATOMIC
17693 | ATTACH
17694 | ATTRIBUTE
17695 | BACKWARD
17696 | BEFORE
17697 | BEGIN_P
17698 | BREADTH
17699 | BY
17700 | CACHE
17701 | CALL
17702 | CALLED
17703 | CASCADE
17704 | CASCADED
17705 | CATALOG_P
17706 | CHAIN
17707 | CHARACTERISTICS
17708 | CHECKPOINT
17709 | CLASS
17710 | CLOSE
17711 | CLUSTER
17712 | COLUMNS
17713 | COMMENT
17714 | COMMENTS
17715 | COMMIT
17716 | COMMITTED
17717 | COMPRESSION
17718 | CONDITIONAL
17719 | CONFIGURATION
17720 | CONFLICT
17721 | CONNECTION
17722 | CONSTRAINTS
17723 | CONTENT_P
17724 | CONTINUE_P
17725 | CONVERSION_P
17726 | COPY
17727 | COST
17728 | CSV
17729 | CUBE
17730 | CURRENT_P
17731 | CURSOR
17732 | CYCLE
17733 | DATA_P
17734 | DATABASE
17735 | DAY_P
17736 | DEALLOCATE
17737 | DECLARE
17738 | DEFAULTS
17739 | DEFERRED
17740 | DEFINER
17741 | DELETE_P
17742 | DELIMITER
17743 | DELIMITERS
17744 | DEPENDS
17745 | DEPTH
17746 | DETACH
17747 | DICTIONARY
17748 | DISABLE_P
17749 | DISCARD
17750 | DOCUMENT_P
17751 | DOMAIN_P
17752 | DOUBLE_P
17753 | DROP
17754 | EACH
17755 | EMPTY_P
17756 | ENABLE_P
17757 | ENCODING
17758 | ENCRYPTED
17759 | ENFORCED
17760 | ENUM_P
17761 | ERROR_P
17762 | ESCAPE
17763 | EVENT
17764 | EXCLUDE
17765 | EXCLUDING
17766 | EXCLUSIVE
17767 | EXECUTE
17768 | EXPLAIN
17769 | EXPRESSION
17770 | EXTENSION
17771 | EXTERNAL
17772 | FAMILY
17773 | FILTER
17774 | FINALIZE
17775 | FIRST_P
17776 | FOLLOWING
17777 | FORCE
17778 | FORMAT
17779 | FORWARD
17780 | FUNCTION
17781 | FUNCTIONS
17782 | GENERATED
17783 | GLOBAL
17784 | GRANTED
17785 | GROUPS
17786 | HANDLER
17787 | HEADER_P
17788 | HOLD
17789 | HOUR_P
17790 | IDENTITY_P
17791 | IF_P
17792 | IMMEDIATE
17793 | IMMUTABLE
17794 | IMPLICIT_P
17795 | IMPORT_P
17796 | INCLUDE
17797 | INCLUDING
17798 | INCREMENT
17799 | INDENT
17800 | INDEX
17801 | INDEXES
17802 | INHERIT
17803 | INHERITS
17804 | INLINE_P
17805 | INPUT_P
17806 | INSENSITIVE
17807 | INSERT
17808 | INSTEAD
17809 | INVOKER
17810 | ISOLATION
17811 | KEEP
17812 | KEY
17813 | KEYS
17814 | LABEL
17815 | LANGUAGE
17816 | LARGE_P
17817 | LAST_P
17818 | LEAKPROOF
17819 | LEVEL
17820 | LISTEN
17821 | LOAD
17822 | LOCAL
17823 | LOCATION
17824 | LOCK_P
17825 | LOCKED
17826 | LOGGED
17827 | MAPPING
17828 | MATCH
17829 | MATCHED
17830 | MATERIALIZED
17831 | MAXVALUE
17832 | MERGE
17833 | METHOD
17834 | MINUTE_P
17835 | MINVALUE
17836 | MODE
17837 | MONTH_P
17838 | MOVE
17839 | NAME_P
17840 | NAMES
17841 | NESTED
17842 | NEW
17843 | NEXT
17844 | NFC
17845 | NFD
17846 | NFKC
17847 | NFKD
17848 | NO
17849 | NORMALIZED
17850 | NOTHING
17851 | NOTIFY
17852 | NOWAIT
17853 | NULLS_P
17854 | OBJECT_P
17855 | OF
17856 | OFF
17857 | OIDS
17858 | OLD
17859 | OMIT
17860 | OPERATOR
17861 | OPTION
17862 | OPTIONS
17863 | ORDINALITY
17864 | OTHERS
17865 | OVER
17866 | OVERRIDING
17867 | OWNED
17868 | OWNER
17869 | PARALLEL
17870 | PARAMETER
17871 | PARSER
17872 | PARTIAL
17873 | PARTITION
17874 | PASSING
17875 | PASSWORD
17876 | PATH
17877 | PERIOD
17878 | PLAN
17879 | PLANS
17880 | POLICY
17881 | PRECEDING
17882 | PREPARE
17883 | PREPARED
17884 | PRESERVE
17885 | PRIOR
17886 | PRIVILEGES
17887 | PROCEDURAL
17888 | PROCEDURE
17889 | PROCEDURES
17890 | PROGRAM
17891 | PUBLICATION
17892 | QUOTE
17893 | QUOTES
17894 | RANGE
17895 | READ
17896 | REASSIGN
17897 | RECURSIVE
17898 | REF_P
17899 | REFERENCING
17900 | REFRESH
17901 | REINDEX
17902 | RELATIVE_P
17903 | RELEASE
17904 | RENAME
17905 | REPEATABLE
17906 | REPLACE
17907 | REPLICA
17908 | RESET
17909 | RESTART
17910 | RESTRICT
17911 | RETURN
17912 | RETURNS
17913 | REVOKE
17914 | ROLE
17915 | ROLLBACK
17916 | ROLLUP
17917 | ROUTINE
17918 | ROUTINES
17919 | ROWS
17920 | RULE
17921 | SAVEPOINT
17922 | SCALAR
17923 | SCHEMA
17924 | SCHEMAS
17925 | SCROLL
17926 | SEARCH
17927 | SECOND_P
17928 | SECURITY
17929 | SEQUENCE
17930 | SEQUENCES
17931 | SERIALIZABLE
17932 | SERVER
17933 | SESSION
17934 | SET
17935 | SETS
17936 | SHARE
17937 | SHOW
17938 | SIMPLE
17939 | SKIP
17940 | SNAPSHOT
17941 | SOURCE
17942 | SQL_P
17943 | STABLE
17944 | STANDALONE_P
17945 | START
17946 | STATEMENT
17947 | STATISTICS
17948 | STDIN
17949 | STDOUT
17950 | STORAGE
17951 | STORED
17952 | STRICT_P
17953 | STRING_P
17954 | STRIP_P
17955 | SUBSCRIPTION
17956 | SUPPORT
17957 | SYSID
17958 | SYSTEM_P
17959 | TABLES
17960 | TABLESPACE
17961 | TARGET
17962 | TEMP
17963 | TEMPLATE
17964 | TEMPORARY
17965 | TEXT_P
17966 | TIES
17967 | TRANSACTION
17968 | TRANSFORM
17969 | TRIGGER
17970 | TRUNCATE
17971 | TRUSTED
17972 | TYPE_P
17973 | TYPES_P
17974 | UESCAPE
17975 | UNBOUNDED
17976 | UNCOMMITTED
17977 | UNCONDITIONAL
17978 | UNENCRYPTED
17979 | UNKNOWN
17980 | UNLISTEN
17981 | UNLOGGED
17982 | UNTIL
17983 | UPDATE
17984 | VACUUM
17985 | VALID
17986 | VALIDATE
17987 | VALIDATOR
17988 | VALUE_P
17989 | VARYING
17990 | VERSION_P
17991 | VIEW
17992 | VIEWS
17993 | VOLATILE
17994 | WHITESPACE_P
17995 | WITHIN
17996 | WITHOUT
17997 | WORK
17998 | WRAPPER
17999 | WRITE
18000 | XML_P
18001 | YEAR_P
18002 | YES_P
18003 | ZONE
18004 ;
18006 /* Column identifier --- keywords that can be column, table, etc names.
18007 *
18008 * Many of these keywords will in fact be recognized as type or function
18009 * names too; but they have special productions for the purpose, and so
18010 * can't be treated as "generic" type or function names.
18011 *
18012 * The type names appearing here are not usable as function names
18013 * because they can be followed by '(' in typename productions, which
18014 * looks too much like a function call for an LR(1) parser.
18015 */
18016 col_name_keyword:
18017 BETWEEN
18018 | BIGINT
18019 | BIT
18020 | BOOLEAN_P
18021 | CHAR_P
18022 | CHARACTER
18023 | COALESCE
18024 | DEC
18025 | DECIMAL_P
18026 | EXISTS
18027 | EXTRACT
18028 | FLOAT_P
18029 | GREATEST
18030 | GROUPING
18031 | INOUT
18032 | INT_P
18033 | INTEGER
18034 | INTERVAL
18035 | JSON
18036 | JSON_ARRAY
18037 | JSON_ARRAYAGG
18038 | JSON_EXISTS
18039 | JSON_OBJECT
18040 | JSON_OBJECTAGG
18041 | JSON_QUERY
18042 | JSON_SCALAR
18043 | JSON_SERIALIZE
18044 | JSON_TABLE
18045 | JSON_VALUE
18046 | LEAST
18047 | MERGE_ACTION
18048 | NATIONAL
18049 | NCHAR
18050 | NONE
18051 | NORMALIZE
18052 | NULLIF
18053 | NUMERIC
18054 | OUT_P
18055 | OVERLAY
18056 | POSITION
18057 | PRECISION
18058 | REAL
18059 | ROW
18060 | SETOF
18061 | SMALLINT
18062 | SUBSTRING
18063 | TIME
18064 | TIMESTAMP
18065 | TREAT
18066 | TRIM
18067 | VALUES
18068 | VARCHAR
18069 | XMLATTRIBUTES
18070 | XMLCONCAT
18071 | XMLELEMENT
18072 | XMLEXISTS
18073 | XMLFOREST
18074 | XMLNAMESPACES
18075 | XMLPARSE
18076 | XMLPI
18077 | XMLROOT
18078 | XMLSERIALIZE
18079 | XMLTABLE
18080 ;
18082 /* Type/function identifier --- keywords that can be type or function names.
18083 *
18084 * Most of these are keywords that are used as operators in expressions;
18085 * in general such keywords can't be column names because they would be
18086 * ambiguous with variables, but they are unambiguous as function identifiers.
18087 *
18088 * Do not include POSITION, SUBSTRING, etc here since they have explicit
18089 * productions in a_expr to support the goofy SQL9x argument syntax.
18090 * - thomas 2000-11-28
18091 */
18092 type_func_name_keyword:
18093 AUTHORIZATION
18094 | BINARY
18095 | COLLATION
18096 | CONCURRENTLY
18097 | CROSS
18098 | CURRENT_SCHEMA
18099 | FREEZE
18100 | FULL
18101 | ILIKE
18102 | INNER_P
18103 | IS
18104 | ISNULL
18105 | JOIN
18106 | LEFT
18107 | LIKE
18108 | NATURAL
18109 | NOTNULL
18110 | OUTER_P
18111 | OVERLAPS
18112 | RIGHT
18113 | SIMILAR
18114 | TABLESAMPLE
18115 | VERBOSE
18116 ;
18118 /* Reserved keyword --- these keywords are usable only as a ColLabel.
18119 *
18120 * Keywords appear here if they could not be distinguished from variable,
18121 * type, or function names in some contexts. Don't put things here unless
18122 * forced to.
18123 */
18124 reserved_keyword:
18125 ALL
18126 | ANALYSE
18127 | ANALYZE
18128 | AND
18129 | ANY
18130 | ARRAY
18131 | AS
18132 | ASC
18133 | ASYMMETRIC
18134 | BOTH
18135 | CASE
18136 | CAST
18137 | CHECK
18138 | COLLATE
18139 | COLUMN
18140 | CONSTRAINT
18141 | CREATE
18142 | CURRENT_CATALOG
18143 | CURRENT_DATE
18144 | CURRENT_ROLE
18145 | CURRENT_TIME
18146 | CURRENT_TIMESTAMP
18147 | CURRENT_USER
18148 | DEFAULT
18149 | DEFERRABLE
18150 | DESC
18151 | DISTINCT
18152 | DO
18153 | ELSE
18154 | END_P
18155 | EXCEPT
18156 | FALSE_P
18157 | FETCH
18158 | FOR
18159 | FOREIGN
18160 | FROM
18161 | GRANT
18162 | GROUP_P
18163 | HAVING
18164 | IN_P
18165 | INITIALLY
18166 | INTERSECT
18167 | INTO
18168 | LATERAL_P
18169 | LEADING
18170 | LIMIT
18171 | LOCALTIME
18172 | LOCALTIMESTAMP
18173 | NOT
18174 | NULL_P
18175 | OFFSET
18176 | ON
18177 | ONLY
18178 | OR
18179 | ORDER
18180 | PLACING
18181 | PRIMARY
18182 | REFERENCES
18183 | RETURNING
18184 | SELECT
18185 | SESSION_USER
18186 | SOME
18187 | SYMMETRIC
18188 | SYSTEM_USER
18189 | TABLE
18190 | THEN
18191 | TO
18192 | TRAILING
18193 | TRUE_P
18194 | UNION
18195 | UNIQUE
18196 | USER
18197 | USING
18198 | VARIADIC
18199 | WHEN
18200 | WHERE
18201 | WINDOW
18202 | WITH
18203 ;
18205 /*
18206 * While all keywords can be used as column labels when preceded by AS,
18207 * not all of them can be used as a "bare" column label without AS.
18208 * Those that can be used as a bare label must be listed here,
18209 * in addition to appearing in one of the category lists above.
18210 *
18211 * Always add a new keyword to this list if possible. Mark it BARE_LABEL
18212 * in kwlist.h if it is included here, or AS_LABEL if it is not.
18213 */
18214 bare_label_keyword:
18215 ABORT_P
18216 | ABSENT
18217 | ABSOLUTE_P
18218 | ACCESS
18219 | ACTION
18220 | ADD_P
18221 | ADMIN
18222 | AFTER
18223 | AGGREGATE
18224 | ALL
18225 | ALSO
18226 | ALTER
18227 | ALWAYS
18228 | ANALYSE
18229 | ANALYZE
18230 | AND
18231 | ANY
18232 | ASC
18233 | ASENSITIVE
18234 | ASSERTION
18235 | ASSIGNMENT
18236 | ASYMMETRIC
18237 | AT
18238 | ATOMIC
18239 | ATTACH
18240 | ATTRIBUTE
18241 | AUTHORIZATION
18242 | BACKWARD
18243 | BEFORE
18244 | BEGIN_P
18245 | BETWEEN
18246 | BIGINT
18247 | BINARY
18248 | BIT
18249 | BOOLEAN_P
18250 | BOTH
18251 | BREADTH
18252 | BY
18253 | CACHE
18254 | CALL
18255 | CALLED
18256 | CASCADE
18257 | CASCADED
18258 | CASE
18259 | CAST
18260 | CATALOG_P
18261 | CHAIN
18262 | CHARACTERISTICS
18263 | CHECK
18264 | CHECKPOINT
18265 | CLASS
18266 | CLOSE
18267 | CLUSTER
18268 | COALESCE
18269 | COLLATE
18270 | COLLATION
18271 | COLUMN
18272 | COLUMNS
18273 | COMMENT
18274 | COMMENTS
18275 | COMMIT
18276 | COMMITTED
18277 | COMPRESSION
18278 | CONCURRENTLY
18279 | CONDITIONAL
18280 | CONFIGURATION
18281 | CONFLICT
18282 | CONNECTION
18283 | CONSTRAINT
18284 | CONSTRAINTS
18285 | CONTENT_P
18286 | CONTINUE_P
18287 | CONVERSION_P
18288 | COPY
18289 | COST
18290 | CROSS
18291 | CSV
18292 | CUBE
18293 | CURRENT_P
18294 | CURRENT_CATALOG
18295 | CURRENT_DATE
18296 | CURRENT_ROLE
18297 | CURRENT_SCHEMA
18298 | CURRENT_TIME
18299 | CURRENT_TIMESTAMP
18300 | CURRENT_USER
18301 | CURSOR
18302 | CYCLE
18303 | DATA_P
18304 | DATABASE
18305 | DEALLOCATE
18306 | DEC
18307 | DECIMAL_P
18308 | DECLARE
18309 | DEFAULT
18310 | DEFAULTS
18311 | DEFERRABLE
18312 | DEFERRED
18313 | DEFINER
18314 | DELETE_P
18315 | DELIMITER
18316 | DELIMITERS
18317 | DEPENDS
18318 | DEPTH
18319 | DESC
18320 | DETACH
18321 | DICTIONARY
18322 | DISABLE_P
18323 | DISCARD
18324 | DISTINCT
18325 | DO
18326 | DOCUMENT_P
18327 | DOMAIN_P
18328 | DOUBLE_P
18329 | DROP
18330 | EACH
18331 | ELSE
18332 | EMPTY_P
18333 | ENABLE_P
18334 | ENCODING
18335 | ENCRYPTED
18336 | END_P
18337 | ENFORCED
18338 | ENUM_P
18339 | ERROR_P
18340 | ESCAPE
18341 | EVENT
18342 | EXCLUDE
18343 | EXCLUDING
18344 | EXCLUSIVE
18345 | EXECUTE
18346 | EXISTS
18347 | EXPLAIN
18348 | EXPRESSION
18349 | EXTENSION
18350 | EXTERNAL
18351 | EXTRACT
18352 | FALSE_P
18353 | FAMILY
18354 | FINALIZE
18355 | FIRST_P
18356 | FLOAT_P
18357 | FOLLOWING
18358 | FORCE
18359 | FOREIGN
18360 | FORMAT
18361 | FORWARD
18362 | FREEZE
18363 | FULL
18364 | FUNCTION
18365 | FUNCTIONS
18366 | GENERATED
18367 | GLOBAL
18368 | GRANTED
18369 | GREATEST
18370 | GROUPING
18371 | GROUPS
18372 | HANDLER
18373 | HEADER_P
18374 | HOLD
18375 | IDENTITY_P
18376 | IF_P
18377 | ILIKE
18378 | IMMEDIATE
18379 | IMMUTABLE
18380 | IMPLICIT_P
18381 | IMPORT_P
18382 | IN_P
18383 | INCLUDE
18384 | INCLUDING
18385 | INCREMENT
18386 | INDENT
18387 | INDEX
18388 | INDEXES
18389 | INHERIT
18390 | INHERITS
18391 | INITIALLY
18392 | INLINE_P
18393 | INNER_P
18394 | INOUT
18395 | INPUT_P
18396 | INSENSITIVE
18397 | INSERT
18398 | INSTEAD
18399 | INT_P
18400 | INTEGER
18401 | INTERVAL
18402 | INVOKER
18403 | IS
18404 | ISOLATION
18405 | JOIN
18406 | JSON
18407 | JSON_ARRAY
18408 | JSON_ARRAYAGG
18409 | JSON_EXISTS
18410 | JSON_OBJECT
18411 | JSON_OBJECTAGG
18412 | JSON_QUERY
18413 | JSON_SCALAR
18414 | JSON_SERIALIZE
18415 | JSON_TABLE
18416 | JSON_VALUE
18417 | KEEP
18418 | KEY
18419 | KEYS
18420 | LABEL
18421 | LANGUAGE
18422 | LARGE_P
18423 | LAST_P
18424 | LATERAL_P
18425 | LEADING
18426 | LEAKPROOF
18427 | LEAST
18428 | LEFT
18429 | LEVEL
18430 | LIKE
18431 | LISTEN
18432 | LOAD
18433 | LOCAL
18434 | LOCALTIME
18435 | LOCALTIMESTAMP
18436 | LOCATION
18437 | LOCK_P
18438 | LOCKED
18439 | LOGGED
18440 | MAPPING
18441 | MATCH
18442 | MATCHED
18443 | MATERIALIZED
18444 | MAXVALUE
18445 | MERGE
18446 | MERGE_ACTION
18447 | METHOD
18448 | MINVALUE
18449 | MODE
18450 | MOVE
18451 | NAME_P
18452 | NAMES
18453 | NATIONAL
18454 | NATURAL
18455 | NCHAR
18456 | NESTED
18457 | NEW
18458 | NEXT
18459 | NFC
18460 | NFD
18461 | NFKC
18462 | NFKD
18463 | NO
18464 | NONE
18465 | NORMALIZE
18466 | NORMALIZED
18467 | NOT
18468 | NOTHING
18469 | NOTIFY
18470 | NOWAIT
18471 | NULL_P
18472 | NULLIF
18473 | NULLS_P
18474 | NUMERIC
18475 | OBJECT_P
18476 | OF
18477 | OFF
18478 | OIDS
18479 | OLD
18480 | OMIT
18481 | ONLY
18482 | OPERATOR
18483 | OPTION
18484 | OPTIONS
18485 | OR
18486 | ORDINALITY
18487 | OTHERS
18488 | OUT_P
18489 | OUTER_P
18490 | OVERLAY
18491 | OVERRIDING
18492 | OWNED
18493 | OWNER
18494 | PARALLEL
18495 | PARAMETER
18496 | PARSER
18497 | PARTIAL
18498 | PARTITION
18499 | PASSING
18500 | PASSWORD
18501 | PATH
18502 | PERIOD
18503 | PLACING
18504 | PLAN
18505 | PLANS
18506 | POLICY
18507 | POSITION
18508 | PRECEDING
18509 | PREPARE
18510 | PREPARED
18511 | PRESERVE
18512 | PRIMARY
18513 | PRIOR
18514 | PRIVILEGES
18515 | PROCEDURAL
18516 | PROCEDURE
18517 | PROCEDURES
18518 | PROGRAM
18519 | PUBLICATION
18520 | QUOTE
18521 | QUOTES
18522 | RANGE
18523 | READ
18524 | REAL
18525 | REASSIGN
18526 | RECURSIVE
18527 | REF_P
18528 | REFERENCES
18529 | REFERENCING
18530 | REFRESH
18531 | REINDEX
18532 | RELATIVE_P
18533 | RELEASE
18534 | RENAME
18535 | REPEATABLE
18536 | REPLACE
18537 | REPLICA
18538 | RESET
18539 | RESTART
18540 | RESTRICT
18541 | RETURN
18542 | RETURNS
18543 | REVOKE
18544 | RIGHT
18545 | ROLE
18546 | ROLLBACK
18547 | ROLLUP
18548 | ROUTINE
18549 | ROUTINES
18550 | ROW
18551 | ROWS
18552 | RULE
18553 | SAVEPOINT
18554 | SCALAR
18555 | SCHEMA
18556 | SCHEMAS
18557 | SCROLL
18558 | SEARCH
18559 | SECURITY
18560 | SELECT
18561 | SEQUENCE
18562 | SEQUENCES
18563 | SERIALIZABLE
18564 | SERVER
18565 | SESSION
18566 | SESSION_USER
18567 | SET
18568 | SETOF
18569 | SETS
18570 | SHARE
18571 | SHOW
18572 | SIMILAR
18573 | SIMPLE
18574 | SKIP
18575 | SMALLINT
18576 | SNAPSHOT
18577 | SOME
18578 | SOURCE
18579 | SQL_P
18580 | STABLE
18581 | STANDALONE_P
18582 | START
18583 | STATEMENT
18584 | STATISTICS
18585 | STDIN
18586 | STDOUT
18587 | STORAGE
18588 | STORED
18589 | STRICT_P
18590 | STRING_P
18591 | STRIP_P
18592 | SUBSCRIPTION
18593 | SUBSTRING
18594 | SUPPORT
18595 | SYMMETRIC
18596 | SYSID
18597 | SYSTEM_P
18598 | SYSTEM_USER
18599 | TABLE
18600 | TABLES
18601 | TABLESAMPLE
18602 | TABLESPACE
18603 | TARGET
18604 | TEMP
18605 | TEMPLATE
18606 | TEMPORARY
18607 | TEXT_P
18608 | THEN
18609 | TIES
18610 | TIME
18611 | TIMESTAMP
18612 | TRAILING
18613 | TRANSACTION
18614 | TRANSFORM
18615 | TREAT
18616 | TRIGGER
18617 | TRIM
18618 | TRUE_P
18619 | TRUNCATE
18620 | TRUSTED
18621 | TYPE_P
18622 | TYPES_P
18623 | UESCAPE
18624 | UNBOUNDED
18625 | UNCOMMITTED
18626 | UNCONDITIONAL
18627 | UNENCRYPTED
18628 | UNIQUE
18629 | UNKNOWN
18630 | UNLISTEN
18631 | UNLOGGED
18632 | UNTIL
18633 | UPDATE
18634 | USER
18635 | USING
18636 | VACUUM
18637 | VALID
18638 | VALIDATE
18639 | VALIDATOR
18640 | VALUE_P
18641 | VALUES
18642 | VARCHAR
18643 | VARIADIC
18644 | VERBOSE
18645 | VERSION_P
18646 | VIEW
18647 | VIEWS
18648 | VOLATILE
18649 | WHEN
18650 | WHITESPACE_P
18651 | WORK
18652 | WRAPPER
18653 | WRITE
18654 | XML_P
18655 | XMLATTRIBUTES
18656 | XMLCONCAT
18657 | XMLELEMENT
18658 | XMLEXISTS
18659 | XMLFOREST
18660 | XMLNAMESPACES
18661 | XMLPARSE
18662 | XMLPI
18663 | XMLROOT
18664 | XMLSERIALIZE
18665 | XMLTABLE
18666 | YES_P
18667 | ZONE
18668 ;
18670 %%
18672 /*
18673 * The signature of this function is required by bison. However, we
18674 * ignore the passed yylloc and instead use the last token position
18675 * available from the scanner.
18676 */
18677 static void
18679 {
18681 }
18685 {
18691 return rs;
18692 }
18694 /* Adjust a RawStmt to reflect that it doesn't run to the end of the string */
18695 static void
18697 {
18698 /*
18699 * If we already set the length, don't change it. This is for situations
18700 * like "select foo ;; select bar" where the same statement will be last
18701 * in the string for more than one semicolon.
18702 */
18704 return;
18706 /* OK, update length of RawStmt */
18708 }
18710 /*
18711 * Adjust a PreparableStmt to reflect that it doesn't run to the end of the
18712 * string.
18713 */
18714 static void
18716 {
18718 {
18722 }
18724 {
18728 }
18730 {
18734 }
18736 {
18740 }
18742 {
18746 }
18747 else
18749 }
18754 {
18755 /*
18756 * Generate a ColumnRef node, with an A_Indirection node added if there is
18757 * any subscripting in the specified indirection list. However, any field
18758 * selection at the start of the indirection list must be transposed into
18759 * the "fields" part of the ColumnRef node.
18760 */
18767 {
18769 {
18773 {
18774 /* easy case - all indirection goes to A_Indirection */
18777 }
18778 else
18779 {
18780 /* got to split the list in two */
18782 nfields),
18783 yyscanner);
18786 }
18789 }
18791 {
18792 /* We only allow '*' at the end of a ColumnRef */
18795 }
18796 nfields++;
18797 }
18798 /* No subscripting, so all indirection gets added to field list */
18801 }
18805 {
18812 }
18816 {
18820 }
18824 {
18832 }
18836 {
18844 }
18848 {
18856 }
18860 {
18868 }
18872 {
18879 }
18883 {
18887 {
18888 case T_Float:
18890 break;
18892 case T_Integer:
18894 break;
18896 default:
18897 /* currently not used */
18900 }
18902 return n;
18903 }
18905 /* makeRoleSpec
18906 * Create a RoleSpec with the given type
18907 */
18910 {
18916 return spec;
18917 }
18919 /* check_qualified_name --- check the result of qualified_name production
18920 *
18921 * It's easiest to let the grammar production for qualified_name allow
18922 * subscripts and '*', which we then must reject here.
18923 */
18924 static void
18926 {
18930 {
18933 }
18934 }
18936 /* check_func_name --- check the result of func_name production
18937 *
18938 * It's easiest to let the grammar production for func_name allow subscripts
18939 * and '*', which we then must reject here.
18940 */
18943 {
18947 {
18950 }
18951 return names;
18952 }
18954 /* check_indirection --- check the result of indirection production
18955 *
18956 * We only allow '*' at the end of the list, but it's hard to enforce that
18957 * in the grammar, so do it here.
18958 */
18961 {
18965 {
18967 {
18970 }
18971 }
18972 return indirection;
18973 }
18975 /* extractArgTypes()
18976 * Given a list of FunctionParameter nodes, extract a list of just the
18977 * argument types (TypeNames) for input parameters only. This is what
18978 * is needed to look up an existing function, which is what is wanted by
18979 * the productions that use this call.
18980 */
18983 {
18988 {
18993 }
18994 return result;
18995 }
18997 /* extractAggrArgTypes()
18998 * As above, but work from the output of the aggr_args production.
18999 */
19002 {
19005 }
19007 /* makeOrderedSetArgs()
19008 * Build the result of the aggr_args production (which see the comments for).
19009 * This handles only the case where both given lists are nonempty, so that
19010 * we have to deal with multiple VARIADIC arguments.
19011 */
19014 core_yyscan_t yyscanner)
19015 {
19019 /* No restriction unless last direct arg is VARIADIC */
19021 {
19024 /*
19025 * We ignore the names, though the aggr_arg production allows them; it
19026 * doesn't allow default values, so those need not be checked.
19027 */
19033 errmsg("an ordered-set aggregate with a VARIADIC direct argument must have one VARIADIC aggregated argument of the same data type"),
19036 /* OK, drop the duplicate VARIADIC argument from the internal form */
19038 }
19040 /* don't merge into the next line, as list_concat changes directargs */
19044 ndirectargs);
19045 }
19047 /* insertSelectOptions()
19048 * Insert ORDER BY, etc into an already-constructed SelectStmt.
19049 *
19050 * This routine is just to avoid duplicating code in SelectStmt productions.
19051 */
19052 static void
19057 core_yyscan_t yyscanner)
19058 {
19061 /*
19062 * Tests here are to reject constructs like
19063 * (SELECT foo ORDER BY bar) ORDER BY baz
19064 */
19066 {
19073 }
19074 /* We can handle multiple locking clauses, though */
19077 {
19084 }
19086 {
19093 }
19095 {
19096 /* If there was a conflict, we must have detected it above */
19104 {
19108 {
19117 }
19118 }
19120 }
19122 {
19130 /* Update SelectStmt's location to the start of the WITH clause */
19132 }
19133 }
19137 {
19146 }
19148 /* SystemFuncName()
19149 * Build a properly-qualified reference to a built-in function.
19150 */
19151 List *
19153 {
19155 }
19157 /* SystemTypeName()
19158 * Build a properly-qualified reference to a built-in type.
19159 *
19160 * typmod is defaulted, but may be changed afterwards by caller.
19161 * Likewise for the location.
19162 */
19163 TypeName *
19165 {
19168 }
19170 /* doNegate()
19171 * Handle negation of a numeric constant.
19172 *
19173 * Formerly, we did this here because the optimizer couldn't cope with
19174 * indexquals that looked like "var = -4" --- it wants "var = const"
19175 * and a unary minus operator applied to a constant didn't qualify.
19176 * As of Postgres 7.0, that problem doesn't exist anymore because there
19177 * is a constant-subexpression simplifier in the optimizer. However,
19178 * there's still a good reason for doing this here, which is that we can
19179 * postpone committing to a particular internal representation for simple
19180 * negative constants. It's better to leave "-123.456" in string form
19181 * until we know what the desired type is.
19182 */
19185 {
19187 {
19190 /* report the constant's location as that of the '-' sign */
19194 {
19196 return n;
19197 }
19199 {
19201 return n;
19202 }
19203 }
19206 }
19208 static void
19210 {
19214 oldval++;
19217 else
19219 }
19223 {
19224 /* Flatten "a AND b AND c ..." to a single BoolExpr on sight */
19226 {
19230 {
19233 }
19234 }
19236 }
19240 {
19241 /* Flatten "a OR b OR c ..." to a single BoolExpr on sight */
19243 {
19247 {
19250 }
19251 }
19253 }
19257 {
19259 }
19263 {
19269 }
19273 {
19277 /* svf->type will be filled during parse analysis */
19281 }
19286 {
19292 /*
19293 * named_args is a list of ResTarget; it'll be split apart into separate
19294 * expression and name lists in transformXmlExpr().
19295 */
19299 /* xmloption, if relevant, must be filled in by caller */
19300 /* type and typmod will be filled in during parse analysis */
19304 }
19306 /*
19307 * Merge the input and output parameters of a table function.
19308 */
19311 {
19314 /* Explicit OUT and INOUT parameters shouldn't be used in this syntax */
19316 {
19326 }
19329 }
19331 /*
19332 * Determine return type of a TABLE function. A single result column
19333 * returns setof that column's type; otherwise return setof record.
19334 */
19337 {
19341 {
19345 }
19346 else
19351 return result;
19352 }
19354 /*
19355 * Convert a list of (dotted) names to a RangeVar (like
19356 * makeRangeVarFromNameList, but with position support). The
19357 * "AnyName" refers to the any_name production in the grammar.
19358 */
19361 {
19365 {
19370 break;
19375 break;
19380 break;
19381 default:
19387 break;
19388 }
19393 return r;
19394 }
19396 /*
19397 * Convert a relation_name with name and namelist to a RangeVar using
19398 * makeRangeVar.
19399 */
19402 core_yyscan_t yyscanner)
19403 {
19410 {
19415 break;
19420 break;
19421 default:
19427 break;
19428 }
19430 return r;
19431 }
19433 /* Separate Constraint nodes from COLLATE clauses in a ColQualList */
19434 static void
19437 core_yyscan_t yyscanner)
19438 {
19443 {
19447 {
19448 /* keep it in list */
19449 continue;
19450 }
19452 {
19461 }
19462 else
19464 /* remove non-Constraint nodes from qualList */
19466 }
19468 }
19470 /*
19471 * Process result of ConstraintAttributeSpec, and set appropriate bool flags
19472 * in the output command node. Pass NULL for any flags the particular
19473 * command doesn't support.
19474 */
19475 static void
19479 {
19480 /* defaults */
19491 {
19494 else
19497 /* translator: %s is CHECK, UNIQUE, or similar */
19499 constrType),
19501 }
19504 {
19507 else
19510 /* translator: %s is CHECK, UNIQUE, or similar */
19512 constrType),
19514 }
19517 {
19520 else
19523 /* translator: %s is CHECK, UNIQUE, or similar */
19525 constrType),
19527 }
19530 {
19533 else
19536 /* translator: %s is CHECK, UNIQUE, or similar */
19538 constrType),
19540 }
19543 {
19546 else
19549 /* translator: %s is CHECK, UNIQUE, or similar */
19551 constrType),
19554 /*
19555 * NB: The validated status is irrelevant when the constraint is set to
19556 * NOT ENFORCED, but for consistency, it should be set accordingly.
19557 * This ensures that if the constraint is later changed to ENFORCED, it
19558 * will automatically be in the correct NOT VALIDATED state.
19559 */
19562 }
19565 {
19568 else
19571 /* translator: %s is CHECK, UNIQUE, or similar */
19573 constrType),
19575 }
19576 }
19578 /*
19579 * Parse a user-supplied partition strategy string into parse node
19580 * PartitionStrategy representation, or die trying.
19581 */
19582 static PartitionStrategy
19584 {
19586 return PARTITION_STRATEGY_LIST;
19588 return PARTITION_STRATEGY_RANGE;
19590 return PARTITION_STRATEGY_HASH;
19598 }
19600 /*
19601 * Process pubobjspec_list to check for errors in any of the objects and
19602 * convert PUBLICATIONOBJ_CONTINUATION into appropriate PublicationObjSpecType.
19603 */
19604 static void
19606 {
19612 return;
19619 errdetail("One of TABLE or TABLES IN SCHEMA must be specified before a standalone table or schema name."),
19623 {
19630 {
19631 /* relation name or pubtable must be set for this type of object */
19639 {
19640 /* convert it to PublicationTable */
19647 }
19648 }
19651 {
19652 /* WHERE clause is not allowed on a schema object */
19659 /* Column list is not allowed on a schema object */
19666 /*
19667 * We can distinguish between the different type of schema objects
19668 * based on whether name and pubtable is set.
19669 */
19674 else
19679 }
19682 }
19683 }
19685 /*----------
19686 * Recursive view transformation
19687 *
19688 * Convert
19689 *
19690 * CREATE RECURSIVE VIEW relname (aliases) AS query
19691 *
19692 * to
19693 *
19694 * CREATE VIEW relname (aliases) AS
19695 * WITH RECURSIVE relname (aliases) AS (query)
19696 * SELECT aliases FROM relname
19697 *
19698 * Actually, just the WITH ... part, which is then inserted into the original
19699 * view definition as the query.
19700 * ----------
19701 */
19704 {
19711 /* create common table expression */
19718 /* create WITH clause and attach CTE */
19723 /*
19724 * create target list for the new SELECT from the alias list of the
19725 * recursive view specification
19726 */
19728 {
19737 }
19739 /*
19740 * create new SELECT combining WITH clause, target list, and fake FROM
19741 * clause
19742 */
19748 }
19750 /* parser_init()
19751 * Initialize to parse one query string
19752 */
19753 void
19755 {
19757 }