{
"nodes/parsenodes": {
"QuerySource": {
"values": [
{
"comment": ""
},
{
"name": "QSRC_ORIGINAL",
"value": 0,
"comment": "/* original parsetree (explicit query) */"
},
{
"name": "QSRC_PARSER",
"value": 1,
"comment": "/* added by parse analysis (now unused) */"
},
{
"name": "QSRC_INSTEAD_RULE",
"value": 2,
"comment": "/* added by unconditional INSTEAD rule */"
},
{
"name": "QSRC_QUAL_INSTEAD_RULE",
"value": 3,
"comment": "/* added by conditional INSTEAD rule */"
},
{
"name": "QSRC_NON_INSTEAD_RULE",
"value": 4,
"comment": "/* added by non-INSTEAD rule */"
}
],
"comment": "/* Possible sources of a Query */\n"
},
"SortByDir": {
"values": [
{
"comment": ""
},
{
"name": "SORTBY_DEFAULT",
"value": 0
},
{
"name": "SORTBY_ASC",
"value": 1
},
{
"name": "SORTBY_DESC",
"value": 2
},
{
"name": "SORTBY_USING",
"value": 3,
"comment": "/* not allowed in CREATE INDEX ... */"
}
],
"comment": "/* Sort ordering options for ORDER BY and CREATE INDEX */\n"
},
"SortByNulls": {
"values": [
{
"comment": ""
},
{
"name": "SORTBY_NULLS_DEFAULT",
"value": 0
},
{
"name": "SORTBY_NULLS_FIRST",
"value": 1
},
{
"name": "SORTBY_NULLS_LAST",
"value": 2
}
],
"comment": null
},
"SetQuantifier": {
"values": [
{
"comment": ""
},
{
"name": "SET_QUANTIFIER_DEFAULT",
"value": 0
},
{
"name": "SET_QUANTIFIER_ALL",
"value": 1
},
{
"name": "SET_QUANTIFIER_DISTINCT",
"value": 2
}
],
"comment": "/* Options for [ ALL | DISTINCT ] */\n"
},
"A_Expr_Kind": {
"values": [
{
"comment": ""
},
{
"name": "AEXPR_OP",
"value": 0,
"comment": "/* normal operator */"
},
{
"name": "AEXPR_OP_ANY",
"value": 1,
"comment": "/* scalar op ANY (array) */"
},
{
"name": "AEXPR_OP_ALL",
"value": 2,
"comment": "/* scalar op ALL (array) */"
},
{
"name": "AEXPR_DISTINCT",
"value": 3,
"comment": "/* IS DISTINCT FROM - name must be \"=\" */"
},
{
"name": "AEXPR_NOT_DISTINCT",
"value": 4,
"comment": "/* IS NOT DISTINCT FROM - name must be \"=\" */"
},
{
"name": "AEXPR_NULLIF",
"value": 5,
"comment": "/* NULLIF - name must be \"=\" */"
},
{
"name": "AEXPR_IN",
"value": 6,
"comment": "/* [NOT] IN - name must be \"=\" or \"<>\" */"
},
{
"name": "AEXPR_LIKE",
"value": 7,
"comment": "/* [NOT] LIKE - name must be \"~~\" or \"!~~\" */"
},
{
"name": "AEXPR_ILIKE",
"value": 8,
"comment": "/* [NOT] ILIKE - name must be \"~~*\" or \"!~~*\" */"
},
{
"name": "AEXPR_SIMILAR",
"value": 9,
"comment": "/* [NOT] SIMILAR - name must be \"~\" or \"!~\" */"
},
{
"name": "AEXPR_BETWEEN",
"value": 10,
"comment": "/* name must be \"BETWEEN\" */"
},
{
"name": "AEXPR_NOT_BETWEEN",
"value": 11,
"comment": "/* name must be \"NOT BETWEEN\" */"
},
{
"name": "AEXPR_BETWEEN_SYM",
"value": 12,
"comment": "/* name must be \"BETWEEN SYMMETRIC\" */"
},
{
"name": "AEXPR_NOT_BETWEEN_SYM",
"value": 13,
"comment": "/* name must be \"NOT BETWEEN SYMMETRIC\" */"
}
],
"comment": "/*\n * A_Expr - infix, prefix, and postfix expressions\n */\n"
},
"RoleSpecType": {
"values": [
{
"comment": ""
},
{
"name": "ROLESPEC_CSTRING",
"value": 0,
"comment": "/* role name is stored as a C string */"
},
{
"name": "ROLESPEC_CURRENT_ROLE",
"value": 1,
"comment": "/* role spec is CURRENT_ROLE */"
},
{
"name": "ROLESPEC_CURRENT_USER",
"value": 2,
"comment": "/* role spec is CURRENT_USER */"
},
{
"name": "ROLESPEC_SESSION_USER",
"value": 3,
"comment": "/* role spec is SESSION_USER */"
},
{
"name": "ROLESPEC_PUBLIC",
"value": 4,
"comment": "/* role name is \"public\" */"
}
],
"comment": "/*\n * RoleSpec - a role name or one of a few special values.\n */\n"
},
"TableLikeOption": {
"values": [
{
"comment": ""
},
{
"name": "CREATE_TABLE_LIKE_COMMENTS",
"value": 1
},
{
"name": "CREATE_TABLE_LIKE_COMPRESSION",
"value": 2
},
{
"name": "CREATE_TABLE_LIKE_CONSTRAINTS",
"value": 4
},
{
"name": "CREATE_TABLE_LIKE_DEFAULTS",
"value": 8
},
{
"name": "CREATE_TABLE_LIKE_GENERATED",
"value": 16
},
{
"name": "CREATE_TABLE_LIKE_IDENTITY",
"value": 32
},
{
"name": "CREATE_TABLE_LIKE_INDEXES",
"value": 64
},
{
"name": "CREATE_TABLE_LIKE_STATISTICS",
"value": 128
},
{
"name": "CREATE_TABLE_LIKE_STORAGE",
"value": 256
},
{
"name": "CREATE_TABLE_LIKE_ALL",
"value": 2147483647
}
],
"comment": null
},
"DefElemAction": {
"values": [
{
"comment": ""
},
{
"name": "DEFELEM_UNSPEC",
"value": 0,
"comment": "/* no action given */"
},
{
"name": "DEFELEM_SET",
"value": 1
},
{
"name": "DEFELEM_ADD",
"value": 2
},
{
"name": "DEFELEM_DROP",
"value": 3
}
],
"comment": "/*\n * DefElem - a generic \"name = value\" option definition\n *\n * In some contexts the name can be qualified. Also, certain SQL commands\n * allow a SET/ADD/DROP action to be attached to option settings, so it's\n * convenient to carry a field for that too. (Note: currently, it is our\n * practice that the grammar allows namespace and action only in statements\n * where they are relevant; C code can just ignore those fields in other\n * statements.)\n */\n"
},
"PartitionStrategy": {
"values": [
{
"comment": ""
},
{
"name": "PARTITION_STRATEGY_LIST",
"value": 108
},
{
"name": "PARTITION_STRATEGY_RANGE",
"value": 114
},
{
"name": "PARTITION_STRATEGY_HASH",
"value": 104
}
],
"comment": null
},
"PartitionRangeDatumKind": {
"values": [
{
"comment": ""
},
{
"name": "PARTITION_RANGE_DATUM_MINVALUE",
"value": 0
},
{
"name": "PARTITION_RANGE_DATUM_VALUE",
"value": 0,
"comment": "/* a specific (bounded) value */"
},
{
"name": "PARTITION_RANGE_DATUM_MAXVALUE",
"value": 1,
"comment": "/* greater than any other value */"
}
],
"comment": "/*\n * PartitionRangeDatum - one of the values in a range partition bound\n *\n * This can be MINVALUE, MAXVALUE or a specific bounded value.\n */\n"
},
"RTEKind": {
"values": [
{
"comment": ""
},
{
"name": "RTE_RELATION",
"value": 0,
"comment": "/* ordinary relation reference */"
},
{
"name": "RTE_SUBQUERY",
"value": 1,
"comment": "/* subquery in FROM */"
},
{
"name": "RTE_JOIN",
"value": 2,
"comment": "/* join */"
},
{
"name": "RTE_FUNCTION",
"value": 3,
"comment": "/* function in FROM */"
},
{
"name": "RTE_TABLEFUNC",
"value": 4,
"comment": "/* TableFunc(.., column list) */"
},
{
"name": "RTE_VALUES",
"value": 5,
"comment": "/* VALUES (<exprlist>), (<exprlist>), ... */"
},
{
"name": "RTE_CTE",
"value": 6,
"comment": "/* common table expr (WITH list element) */"
},
{
"name": "RTE_NAMEDTUPLESTORE",
"value": 7,
"comment": "/* tuplestore, e.g. for AFTER triggers */"
},
{
"name": "RTE_RESULT",
"value": 8,
"comment": "/* RTE represents an empty FROM clause; such\n\t\t\t\t\t\t\t\t * RTEs are added by the planner, they're not\n\t\t\t\t\t\t\t\t * present during parsing or rewriting */\n"
}
],
"comment": "/*--------------------\n * RangeTblEntry -\n *\t A range table is a List of RangeTblEntry nodes.\n *\n *\t A range table entry may represent a plain relation, a sub-select in\n *\t FROM, or the result of a JOIN clause. (Only explicit JOIN syntax\n *\t produces an RTE, not the implicit join resulting from multiple FROM\n *\t items. This is because we only need the RTE to deal with SQL features\n *\t like outer joins and join-output-column aliasing.) Other special\n *\t RTE types also exist, as indicated by RTEKind.\n *\n *\t Note that we consider RTE_RELATION to cover anything that has a pg_class\n *\t entry. relkind distinguishes the sub-cases.\n *\n *\t alias is an Alias node representing the AS alias-clause attached to the\n *\t FROM expression, or NULL if no clause.\n *\n *\t eref is the table reference name and column reference names (either\n *\t real or aliases). Note that system columns (OID etc) are not included\n *\t in the column list.\n *\t eref->aliasname is required to be present, and should generally be used\n *\t to identify the RTE for error messages etc.\n *\n *\t In RELATION RTEs, the colnames in both alias and eref are indexed by\n *\t physical attribute number; this means there must be colname entries for\n *\t dropped columns. When building an RTE we insert empty strings (\"\") for\n *\t dropped columns. Note however that a stored rule may have nonempty\n *\t colnames for columns dropped since the rule was created (and for that\n *\t matter the colnames might be out of date due to column renamings).\n *\t The same comments apply to FUNCTION RTEs when a function's return type\n *\t is a named composite type.\n *\n *\t In JOIN RTEs, the colnames in both alias and eref are one-to-one with\n *\t joinaliasvars entries. A JOIN RTE will omit columns of its inputs when\n *\t those columns are known to be dropped at parse time. Again, however,\n *\t a stored rule might contain entries for columns dropped since the rule\n *\t was created. (This is only possible for columns not actually referenced\n *\t in the rule.) When loading a stored rule, we replace the joinaliasvars\n *\t items for any such columns with null pointers. (We can't simply delete\n *\t them from the joinaliasvars list, because that would affect the attnums\n *\t of Vars referencing the rest of the list.)\n *\n *\t inFromCl marks those range variables that are listed in the FROM clause.\n *\t It's false for RTEs that are added to a query behind the scenes, such\n *\t as the NEW and OLD variables for a rule, or the subqueries of a UNION.\n *\t This flag is not used during parsing (except in transformLockingClause,\n *\t q.v.); the parser now uses a separate \"namespace\" data structure to\n *\t control visibility. But it is needed by ruleutils.c to determine\n *\t whether RTEs should be shown in decompiled queries.\n *\n *\t securityQuals is a list of security barrier quals (boolean expressions),\n *\t to be tested in the listed order before returning a row from the\n *\t relation. It is always NIL in parser output. Entries are added by the\n *\t rewriter to implement security-barrier views and/or row-level security.\n *\t Note that the planner turns each boolean expression into an implicitly\n *\t AND'ed sublist, as is its usual habit with qualification expressions.\n *--------------------\n */\n"
},
"WCOKind": {
"values": [
{
"comment": ""
},
{
"name": "WCO_VIEW_CHECK",
"value": 0,
"comment": "/* WCO on an auto-updatable view */"
},
{
"name": "WCO_RLS_INSERT_CHECK",
"value": 1,
"comment": "/* RLS INSERT WITH CHECK policy */"
},
{
"name": "WCO_RLS_UPDATE_CHECK",
"value": 2,
"comment": "/* RLS UPDATE WITH CHECK policy */"
},
{
"name": "WCO_RLS_CONFLICT_CHECK",
"value": 3,
"comment": "/* RLS ON CONFLICT DO UPDATE USING policy */"
},
{
"name": "WCO_RLS_MERGE_UPDATE_CHECK",
"value": 4,
"comment": "/* RLS MERGE UPDATE USING policy */"
},
{
"name": "WCO_RLS_MERGE_DELETE_CHECK",
"value": 5,
"comment": "/* RLS MERGE DELETE USING policy */"
}
],
"comment": "/*\n * WithCheckOption -\n *\t\trepresentation of WITH CHECK OPTION checks to be applied to new tuples\n *\t\twhen inserting/updating an auto-updatable view, or RLS WITH CHECK\n *\t\tpolicies to be applied when inserting/updating a relation with RLS.\n */\n"
},
"GroupingSetKind": {
"values": [
{
"comment": ""
},
{
"name": "GROUPING_SET_EMPTY",
"value": 0
},
{
"name": "GROUPING_SET_SIMPLE",
"value": 1
},
{
"name": "GROUPING_SET_ROLLUP",
"value": 2
},
{
"name": "GROUPING_SET_CUBE",
"value": 3
},
{
"name": "GROUPING_SET_SETS",
"value": 4
}
],
"comment": "/*\n * GroupingSet -\n *\t\trepresentation of CUBE, ROLLUP and GROUPING SETS clauses\n *\n * In a Query with grouping sets, the groupClause contains a flat list of\n * SortGroupClause nodes for each distinct expression used. The actual\n * structure of the GROUP BY clause is given by the groupingSets tree.\n *\n * In the raw parser output, GroupingSet nodes (of all types except SIMPLE\n * which is not used) are potentially mixed in with the expressions in the\n * groupClause of the SelectStmt. (An expression can't contain a GroupingSet,\n * but a list may mix GroupingSet and expression nodes.) At this stage, the\n * content of each node is a list of expressions, some of which may be RowExprs\n * which represent sublists rather than actual row constructors, and nested\n * GroupingSet nodes where legal in the grammar. The structure directly\n * reflects the query syntax.\n *\n * In parse analysis, the transformed expressions are used to build the tlist\n * and groupClause list (of SortGroupClause nodes), and the groupingSets tree\n * is eventually reduced to a fixed format:\n *\n * EMPTY nodes represent (), and obviously have no content\n *\n * SIMPLE nodes represent a list of one or more expressions to be treated as an\n * atom by the enclosing structure; the content is an integer list of\n * ressortgroupref values (see SortGroupClause)\n *\n * CUBE and ROLLUP nodes contain a list of one or more SIMPLE nodes.\n *\n * SETS nodes contain a list of EMPTY, SIMPLE, CUBE or ROLLUP nodes, but after\n * parse analysis they cannot contain more SETS nodes; enough of the syntactic\n * transforms of the spec have been applied that we no longer have arbitrarily\n * deep nesting (though we still preserve the use of cube/rollup).\n *\n * Note that if the groupingSets tree contains no SIMPLE nodes (only EMPTY\n * nodes at the leaves), then the groupClause will be empty, but this is still\n * an aggregation query (similar to using aggs or HAVING without GROUP BY).\n *\n * As an example, the following clause:\n *\n * GROUP BY GROUPING SETS ((a,b), CUBE(c,(d,e)))\n *\n * looks like this after raw parsing:\n *\n * SETS( RowExpr(a,b) , CUBE( c, RowExpr(d,e) ) )\n *\n * and parse analysis converts it to:\n *\n * SETS( SIMPLE(1,2), CUBE( SIMPLE(3), SIMPLE(4,5) ) )\n */\n"
},
"CTEMaterialize": {
"values": [
{
"comment": ""
},
{
"name": "CTEMaterializeDefault",
"value": 0,
"comment": "/* no option specified */"
},
{
"name": "CTEMaterializeAlways",
"value": 1,
"comment": "/* MATERIALIZED */"
},
{
"name": "CTEMaterializeNever",
"value": 2,
"comment": "/* NOT MATERIALIZED */"
}
],
"comment": "/*\n * CommonTableExpr -\n *\t representation of WITH list element\n */\n"
},
"JsonQuotes": {
"values": [
{
"comment": ""
},
{
"name": "JS_QUOTES_UNSPEC",
"value": 0,
"comment": "/* unspecified */"
},
{
"name": "JS_QUOTES_KEEP",
"value": 1,
"comment": "/* KEEP QUOTES */"
},
{
"name": "JS_QUOTES_OMIT",
"value": 2,
"comment": "/* OMIT QUOTES */"
}
],
"comment": "/*\n * JsonQuotes -\n *\t\trepresentation of [KEEP|OMIT] QUOTES clause for JSON_QUERY()\n */\n"
},
"JsonTableColumnType": {
"values": [
{
"comment": ""
},
{
"name": "JTC_FOR_ORDINALITY",
"value": 0
},
{
"name": "JTC_REGULAR",
"value": 1
},
{
"name": "JTC_EXISTS",
"value": 2
},
{
"name": "JTC_FORMATTED",
"value": 3
},
{
"name": "JTC_NESTED",
"value": 4
}
],
"comment": "/*\n * JsonTableColumnType -\n *\t\tenumeration of JSON_TABLE column types\n */\n"
},
"SetOperation": {
"values": [
{
"comment": ""
},
{
"name": "SETOP_NONE",
"value": 0
},
{
"name": "SETOP_UNION",
"value": 1
},
{
"name": "SETOP_INTERSECT",
"value": 2
},
{
"name": "SETOP_EXCEPT",
"value": 3
}
],
"comment": "/* ----------------------\n *\t\tSelect Statement\n *\n * A \"simple\" SELECT is represented in the output of gram.y by a single\n * SelectStmt node; so is a VALUES construct. A query containing set\n * operators (UNION, INTERSECT, EXCEPT) is represented by a tree of SelectStmt\n * nodes, in which the leaf nodes are component SELECTs and the internal nodes\n * represent UNION, INTERSECT, or EXCEPT operators. Using the same node\n * type for both leaf and internal nodes allows gram.y to stick ORDER BY,\n * LIMIT, etc, clause values into a SELECT statement without worrying\n * whether it is a simple or compound SELECT.\n * ----------------------\n */\n"
},
"ObjectType": {
"values": [
{
"comment": ""
},
{
"name": "OBJECT_ACCESS_METHOD",
"value": 0
},
{
"name": "OBJECT_AGGREGATE",
"value": 1
},
{
"name": "OBJECT_AMOP",
"value": 2
},
{
"name": "OBJECT_AMPROC",
"value": 3
},
{
"name": "OBJECT_ATTRIBUTE",
"value": 4,
"comment": "/* type's attribute, when distinct from column */"
},
{
"name": "OBJECT_CAST",
"value": 5
},
{
"name": "OBJECT_COLUMN",
"value": 6
},
{
"name": "OBJECT_COLLATION",
"value": 7
},
{
"name": "OBJECT_CONVERSION",
"value": 8
},
{
"name": "OBJECT_DATABASE",
"value": 9
},
{
"name": "OBJECT_DEFAULT",
"value": 10
},
{
"name": "OBJECT_DEFACL",
"value": 11
},
{
"name": "OBJECT_DOMAIN",
"value": 12
},
{
"name": "OBJECT_DOMCONSTRAINT",
"value": 13
},
{
"name": "OBJECT_EVENT_TRIGGER",
"value": 14
},
{
"name": "OBJECT_EXTENSION",
"value": 15
},
{
"name": "OBJECT_FDW",
"value": 16
},
{
"name": "OBJECT_FOREIGN_SERVER",
"value": 17
},
{
"name": "OBJECT_FOREIGN_TABLE",
"value": 18
},
{
"name": "OBJECT_FUNCTION",
"value": 19
},
{
"name": "OBJECT_INDEX",
"value": 20
},
{
"name": "OBJECT_LANGUAGE",
"value": 21
},
{
"name": "OBJECT_LARGEOBJECT",
"value": 22
},
{
"name": "OBJECT_MATVIEW",
"value": 23
},
{
"name": "OBJECT_OPCLASS",
"value": 24
},
{
"name": "OBJECT_OPERATOR",
"value": 25
},
{
"name": "OBJECT_OPFAMILY",
"value": 26
},
{
"name": "OBJECT_PARAMETER_ACL",
"value": 27
},
{
"name": "OBJECT_POLICY",
"value": 28
},
{
"name": "OBJECT_PROCEDURE",
"value": 29
},
{
"name": "OBJECT_PUBLICATION",
"value": 30
},
{
"name": "OBJECT_PUBLICATION_NAMESPACE",
"value": 31
},
{
"name": "OBJECT_PUBLICATION_REL",
"value": 32
},
{
"name": "OBJECT_ROLE",
"value": 33
},
{
"name": "OBJECT_ROUTINE",
"value": 34
},
{
"name": "OBJECT_RULE",
"value": 35
},
{
"name": "OBJECT_SCHEMA",
"value": 36
},
{
"name": "OBJECT_SEQUENCE",
"value": 37
},
{
"name": "OBJECT_SUBSCRIPTION",
"value": 38
},
{
"name": "OBJECT_STATISTIC_EXT",
"value": 39
},
{
"name": "OBJECT_TABCONSTRAINT",
"value": 40
},
{
"name": "OBJECT_TABLE",
"value": 41
},
{
"name": "OBJECT_TABLESPACE",
"value": 42
},
{
"name": "OBJECT_TRANSFORM",
"value": 43
},
{
"name": "OBJECT_TRIGGER",
"value": 44
},
{
"name": "OBJECT_TSCONFIGURATION",
"value": 45
},
{
"name": "OBJECT_TSDICTIONARY",
"value": 46
},
{
"name": "OBJECT_TSPARSER",
"value": 47
},
{
"name": "OBJECT_TSTEMPLATE",
"value": 48
},
{
"name": "OBJECT_TYPE",
"value": 49
},
{
"name": "OBJECT_USER_MAPPING",
"value": 50
},
{
"name": "OBJECT_VIEW",
"value": 51
}
],
"comment": "/*\n * When a command can act on several kinds of objects with only one\n * parse structure required, use these constants to designate the\n * object type. Note that commands typically don't support all the types.\n */\n"
},
"DropBehavior": {
"values": [
{
"comment": ""
},
{
"name": "DROP_RESTRICT",
"value": 0,
"comment": "/* drop fails if any dependent objects */"
},
{
"name": "DROP_CASCADE",
"value": 1,
"comment": "/* remove dependent objects too */"
}
],
"comment": null
},
"AlterTableType": {
"values": [
{
"comment": ""
},
{
"name": "AT_AddColumn",
"value": 0,
"comment": "/* add column */"
},
{
"name": "AT_AddColumnToView",
"value": 1,
"comment": "/* implicitly via CREATE OR REPLACE VIEW */"
},
{
"name": "AT_ColumnDefault",
"value": 2,
"comment": "/* alter column default */"
},
{
"name": "AT_CookedColumnDefault",
"value": 3,
"comment": "/* add a pre-cooked column default */"
},
{
"name": "AT_DropNotNull",
"value": 4,
"comment": "/* alter column drop not null */"
},
{
"name": "AT_SetNotNull",
"value": 5,
"comment": "/* alter column set not null */"
},
{
"name": "AT_SetExpression",
"value": 6,
"comment": "/* alter column set expression */"
},
{
"name": "AT_DropExpression",
"value": 7,
"comment": "/* alter column drop expression */"
},
{
"name": "AT_CheckNotNull",
"value": 8,
"comment": "/* check column is already marked not null */"
},
{
"name": "AT_SetStatistics",
"value": 9,
"comment": "/* alter column set statistics */"
},
{
"name": "AT_SetOptions",
"value": 10,
"comment": "/* alter column set ( options ) */"
},
{
"name": "AT_ResetOptions",
"value": 11,
"comment": "/* alter column reset ( options ) */"
},
{
"name": "AT_SetStorage",
"value": 12,
"comment": "/* alter column set storage */"
},
{
"name": "AT_SetCompression",
"value": 13,
"comment": "/* alter column set compression */"
},
{
"name": "AT_DropColumn",
"value": 14,
"comment": "/* drop column */"
},
{
"name": "AT_AddIndex",
"value": 15,
"comment": "/* add index */"
},
{
"name": "AT_ReAddIndex",
"value": 16,
"comment": "/* internal to commands/tablecmds.c */"
},
{
"name": "AT_AddConstraint",
"value": 17,
"comment": "/* add constraint */"
},
{
"name": "AT_ReAddConstraint",
"value": 18,
"comment": "/* internal to commands/tablecmds.c */"
},
{
"name": "AT_ReAddDomainConstraint",
"value": 19,
"comment": "/* internal to commands/tablecmds.c */"
},
{
"name": "AT_AlterConstraint",
"value": 20,
"comment": "/* alter constraint */"
},
{
"name": "AT_ValidateConstraint",
"value": 21,
"comment": "/* validate constraint */"
},
{
"name": "AT_AddIndexConstraint",
"value": 22,
"comment": "/* add constraint using existing index */"
},
{
"name": "AT_DropConstraint",
"value": 23,
"comment": "/* drop constraint */"
},
{
"name": "AT_ReAddComment",
"value": 24,
"comment": "/* internal to commands/tablecmds.c */"
},
{
"name": "AT_AlterColumnType",
"value": 25,
"comment": "/* alter column type */"
},
{
"name": "AT_AlterColumnGenericOptions",
"value": 26,
"comment": "/* alter column OPTIONS (...) */"
},
{
"name": "AT_ChangeOwner",
"value": 27,
"comment": "/* change owner */"
},
{
"name": "AT_ClusterOn",
"value": 28,
"comment": "/* CLUSTER ON */"
},
{
"name": "AT_DropCluster",
"value": 29,
"comment": "/* SET WITHOUT CLUSTER */"
},
{
"name": "AT_SetLogged",
"value": 30,
"comment": "/* SET LOGGED */"
},
{
"name": "AT_SetUnLogged",
"value": 31,
"comment": "/* SET UNLOGGED */"
},
{
"name": "AT_DropOids",
"value": 32,
"comment": "/* SET WITHOUT OIDS */"
},
{
"name": "AT_SetAccessMethod",
"value": 33,
"comment": "/* SET ACCESS METHOD */"
},
{
"name": "AT_SetTableSpace",
"value": 34,
"comment": "/* SET TABLESPACE */"
},
{
"name": "AT_SetRelOptions",
"value": 35,
"comment": "/* SET (...) -- AM specific parameters */"
},
{
"name": "AT_ResetRelOptions",
"value": 36,
"comment": "/* RESET (...) -- AM specific parameters */"
},
{
"name": "AT_ReplaceRelOptions",
"value": 37,
"comment": "/* replace reloption list in its entirety */"
},
{
"name": "AT_EnableTrig",
"value": 38,
"comment": "/* ENABLE TRIGGER name */"
},
{
"name": "AT_EnableAlwaysTrig",
"value": 39,
"comment": "/* ENABLE ALWAYS TRIGGER name */"
},
{
"name": "AT_EnableReplicaTrig",
"value": 40,
"comment": "/* ENABLE REPLICA TRIGGER name */"
},
{
"name": "AT_DisableTrig",
"value": 41,
"comment": "/* DISABLE TRIGGER name */"
},
{
"name": "AT_EnableTrigAll",
"value": 42,
"comment": "/* ENABLE TRIGGER ALL */"
},
{
"name": "AT_DisableTrigAll",
"value": 43,
"comment": "/* DISABLE TRIGGER ALL */"
},
{
"name": "AT_EnableTrigUser",
"value": 44,
"comment": "/* ENABLE TRIGGER USER */"
},
{
"name": "AT_DisableTrigUser",
"value": 45,
"comment": "/* DISABLE TRIGGER USER */"
},
{
"name": "AT_EnableRule",
"value": 46,
"comment": "/* ENABLE RULE name */"
},
{
"name": "AT_EnableAlwaysRule",
"value": 47,
"comment": "/* ENABLE ALWAYS RULE name */"
},
{
"name": "AT_EnableReplicaRule",
"value": 48,
"comment": "/* ENABLE REPLICA RULE name */"
},
{
"name": "AT_DisableRule",
"value": 49,
"comment": "/* DISABLE RULE name */"
},
{
"name": "AT_AddInherit",
"value": 50,
"comment": "/* INHERIT parent */"
},
{
"name": "AT_DropInherit",
"value": 51,
"comment": "/* NO INHERIT parent */"
},
{
"name": "AT_AddOf",
"value": 52,
"comment": "/* OF <type_name> */"
},
{
"name": "AT_DropOf",
"value": 53,
"comment": "/* NOT OF */"
},
{
"name": "AT_ReplicaIdentity",
"value": 54,
"comment": "/* REPLICA IDENTITY */"
},
{
"name": "AT_EnableRowSecurity",
"value": 55,
"comment": "/* ENABLE ROW SECURITY */"
},
{
"name": "AT_DisableRowSecurity",
"value": 56,
"comment": "/* DISABLE ROW SECURITY */"
},
{
"name": "AT_ForceRowSecurity",
"value": 57,
"comment": "/* FORCE ROW SECURITY */"
},
{
"name": "AT_NoForceRowSecurity",
"value": 58,
"comment": "/* NO FORCE ROW SECURITY */"
},
{
"name": "AT_GenericOptions",
"value": 59,
"comment": "/* OPTIONS (...) */"
},
{
"name": "AT_AttachPartition",
"value": 60,
"comment": "/* ATTACH PARTITION */"
},
{
"name": "AT_DetachPartition",
"value": 61,
"comment": "/* DETACH PARTITION */"
},
{
"name": "AT_DetachPartitionFinalize",
"value": 62,
"comment": "/* DETACH PARTITION FINALIZE */"
},
{
"name": "AT_AddIdentity",
"value": 63,
"comment": "/* ADD IDENTITY */"
},
{
"name": "AT_SetIdentity",
"value": 64,
"comment": "/* SET identity column options */"
},
{
"name": "AT_DropIdentity",
"value": 65,
"comment": "/* DROP IDENTITY */"
},
{
"name": "AT_ReAddStatistics",
"value": 66,
"comment": "/* internal to commands/tablecmds.c */"
}
],
"comment": null
},
"GrantTargetType": {
"values": [
{
"comment": ""
},
{
"name": "ACL_TARGET_OBJECT",
"value": 0,
"comment": "/* grant on specific named object(s) */"
},
{
"name": "ACL_TARGET_ALL_IN_SCHEMA",
"value": 1,
"comment": "/* grant on all objects in given schema(s) */"
},
{
"name": "ACL_TARGET_DEFAULTS",
"value": 2,
"comment": "/* ALTER DEFAULT PRIVILEGES */"
}
],
"comment": "/* ----------------------\n *\t\tGrant|Revoke Statement\n * ----------------------\n */\n"
},
"VariableSetKind": {
"values": [
{
"comment": ""
},
{
"name": "VAR_SET_VALUE",
"value": 0,
"comment": "/* SET var = value */"
},
{
"name": "VAR_SET_DEFAULT",
"value": 1,
"comment": "/* SET var TO DEFAULT */"
},
{
"name": "VAR_SET_CURRENT",
"value": 2,
"comment": "/* SET var FROM CURRENT */"
},
{
"name": "VAR_SET_MULTI",
"value": 3,
"comment": "/* special case for SET TRANSACTION ... */"
},
{
"name": "VAR_RESET",
"value": 4,
"comment": "/* RESET var */"
},
{
"name": "VAR_RESET_ALL",
"value": 5,
"comment": "/* RESET ALL */"
}
],
"comment": "/* ----------------------\n * SET Statement (includes RESET)\n *\n * \"SET var TO DEFAULT\" and \"RESET var\" are semantically equivalent, but we\n * preserve the distinction in VariableSetKind for CreateCommandTag().\n * ----------------------\n */\n"
},
"ConstrType": {
"values": [
{
"comment": ""
},
{
"name": "CONSTR_NULL",
"value": 0,
"comment": "/* not standard SQL, but a lot of people\n\t\t\t\t\t\t\t\t * expect it */\n"
},
{
"name": "CONSTR_NOTNULL",
"value": 1
},
{
"name": "CONSTR_DEFAULT",
"value": 2
},
{
"name": "CONSTR_IDENTITY",
"value": 3
},
{
"name": "CONSTR_GENERATED",
"value": 4
},
{
"name": "CONSTR_CHECK",
"value": 5
},
{
"name": "CONSTR_PRIMARY",
"value": 6
},
{
"name": "CONSTR_UNIQUE",
"value": 7
},
{
"name": "CONSTR_EXCLUSION",
"value": 8
},
{
"name": "CONSTR_FOREIGN",
"value": 9
},
{
"name": "CONSTR_ATTR_DEFERRABLE",
"value": 10,
"comment": "/* attributes for previous constraint node */"
},
{
"name": "CONSTR_ATTR_NOT_DEFERRABLE",
"value": 11
},
{
"name": "CONSTR_ATTR_DEFERRED",
"value": 12
},
{
"name": "CONSTR_ATTR_IMMEDIATE",
"value": 13
}
],
"comment": "/* ----------\n * Definitions for constraints in CreateStmt\n *\n * Note that column defaults are treated as a type of constraint,\n * even though that's a bit odd semantically.\n *\n * For constraints that use expressions (CONSTR_CHECK, CONSTR_DEFAULT)\n * we may have the expression in either \"raw\" form (an untransformed\n * parse tree) or \"cooked\" form (the nodeToString representation of\n * an executable expression tree), depending on how this Constraint\n * node was created (by parsing, or by inheritance from an existing\n * relation). We should never have both in the same node!\n *\n * FKCONSTR_ACTION_xxx values are stored into pg_constraint.confupdtype\n * and pg_constraint.confdeltype columns; FKCONSTR_MATCH_xxx values are\n * stored into pg_constraint.confmatchtype. Changing the code values may\n * require an initdb!\n *\n * If skip_validation is true then we skip checking that the existing rows\n * in the table satisfy the constraint, and just install the catalog entries\n * for the constraint. A new FK constraint is marked as valid iff\n * initially_valid is true. (Usually skip_validation and initially_valid\n * are inverses, but we can set both true if the table is known empty.)\n *\n * Constraint attributes (DEFERRABLE etc) are initially represented as\n * separate Constraint nodes for simplicity of parsing. parse_utilcmd.c makes\n * a pass through the constraints list to insert the info into the appropriate\n * Constraint node.\n * ----------\n */\n"
},
"ImportForeignSchemaType": {
"values": [
{
"comment": ""
},
{
"name": "FDW_IMPORT_SCHEMA_ALL",
"value": 0,
"comment": "/* all relations wanted */"
},
{
"name": "FDW_IMPORT_SCHEMA_LIMIT_TO",
"value": 1,
"comment": "/* include only listed tables in import */"
},
{
"name": "FDW_IMPORT_SCHEMA_EXCEPT",
"value": 2,
"comment": "/* exclude listed tables from import */"
}
],
"comment": "/* ----------------------\n *\t\tImport Foreign Schema Statement\n * ----------------------\n */\n"
},
"RoleStmtType": {
"values": [
{
"comment": ""
},
{
"name": "ROLESTMT_ROLE",
"value": 0
},
{
"name": "ROLESTMT_USER",
"value": 1
},
{
"name": "ROLESTMT_GROUP",
"value": 2
}
],
"comment": "/* ----------------------\n *\tCreate/Alter/Drop Role Statements\n *\n * Note: these node types are also used for the backwards-compatible\n * Create/Alter/Drop User/Group statements. In the ALTER and DROP cases\n * there's really no need to distinguish what the original spelling was,\n * but for CREATE we mark the type because the defaults vary.\n * ----------------------\n */\n"
},
"FetchDirection": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* for these, howMany is how many rows to fetch; FETCH_ALL means ALL */\n"
},
{
"name": "FETCH_FORWARD",
"value": 0
},
{
"name": "FETCH_BACKWARD",
"value": 1
},
{
"comment": "\t/* for these, howMany indicates a position; only one row is fetched */\n"
},
{
"name": "FETCH_ABSOLUTE",
"value": 2
},
{
"name": "FETCH_RELATIVE",
"value": 3
}
],
"comment": "/* ----------------------\n *\t\tFetch Statement (also Move)\n * ----------------------\n */\n"
},
"FunctionParameterMode": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* the assigned enum values appear in pg_proc, don't change 'em! */\n"
},
{
"name": "FUNC_PARAM_IN",
"value": 105,
"comment": "/* input only */"
},
{
"name": "FUNC_PARAM_OUT",
"value": 111,
"comment": "/* output only */"
},
{
"name": "FUNC_PARAM_INOUT",
"value": 98,
"comment": "/* both */"
},
{
"name": "FUNC_PARAM_VARIADIC",
"value": 118,
"comment": "/* variadic (always input) */"
},
{
"name": "FUNC_PARAM_TABLE",
"value": 116,
"comment": "/* table function output column */"
},
{
"comment": "\t/* this is not used in pg_proc: */\n"
},
{
"name": "FUNC_PARAM_DEFAULT",
"value": 100,
"comment": "/* default; effectively same as IN */"
}
],
"comment": null
},
"TransactionStmtKind": {
"values": [
{
"comment": ""
},
{
"name": "TRANS_STMT_BEGIN",
"value": 0
},
{
"name": "TRANS_STMT_START",
"value": 1,
"comment": "/* semantically identical to BEGIN */"
},
{
"name": "TRANS_STMT_COMMIT",
"value": 2
},
{
"name": "TRANS_STMT_ROLLBACK",
"value": 3
},
{
"name": "TRANS_STMT_SAVEPOINT",
"value": 4
},
{
"name": "TRANS_STMT_RELEASE",
"value": 5
},
{
"name": "TRANS_STMT_ROLLBACK_TO",
"value": 6
},
{
"name": "TRANS_STMT_PREPARE",
"value": 7
},
{
"name": "TRANS_STMT_COMMIT_PREPARED",
"value": 8
},
{
"name": "TRANS_STMT_ROLLBACK_PREPARED",
"value": 9
}
],
"comment": "/* ----------------------\n *\t\t{Begin|Commit|Rollback} Transaction Statement\n * ----------------------\n */\n"
},
"ViewCheckOption": {
"values": [
{
"comment": ""
},
{
"name": "NO_CHECK_OPTION",
"value": 0
},
{
"name": "LOCAL_CHECK_OPTION",
"value": 1
},
{
"name": "CASCADED_CHECK_OPTION",
"value": 2
}
],
"comment": "/* ----------------------\n *\t\tCreate View Statement\n * ----------------------\n */\n"
},
"DiscardMode": {
"values": [
{
"comment": ""
},
{
"name": "DISCARD_ALL",
"value": 0
},
{
"name": "DISCARD_PLANS",
"value": 1
},
{
"name": "DISCARD_SEQUENCES",
"value": 2
},
{
"name": "DISCARD_TEMP",
"value": 3
}
],
"comment": "/* ----------------------\n * Discard Statement\n * ----------------------\n */\n"
},
"ReindexObjectType": {
"values": [
{
"comment": ""
},
{
"name": "REINDEX_OBJECT_INDEX",
"value": 0,
"comment": "/* index */"
},
{
"name": "REINDEX_OBJECT_TABLE",
"value": 1,
"comment": "/* table or materialized view */"
},
{
"name": "REINDEX_OBJECT_SCHEMA",
"value": 2,
"comment": "/* schema */"
},
{
"name": "REINDEX_OBJECT_SYSTEM",
"value": 3,
"comment": "/* system catalogs */"
},
{
"name": "REINDEX_OBJECT_DATABASE",
"value": 4,
"comment": "/* database */"
}
],
"comment": "/* ----------------------\n *\t\tREINDEX Statement\n * ----------------------\n */\n"
},
"AlterTSConfigType": {
"values": [
{
"comment": ""
},
{
"name": "ALTER_TSCONFIG_ADD_MAPPING",
"value": 0
},
{
"name": "ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN",
"value": 1
},
{
"name": "ALTER_TSCONFIG_REPLACE_DICT",
"value": 2
},
{
"name": "ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN",
"value": 3
},
{
"name": "ALTER_TSCONFIG_DROP_MAPPING",
"value": 4
}
],
"comment": "/*\n * TS Configuration stmts: DefineStmt, RenameStmt and DropStmt are default\n */\n"
},
"PublicationObjSpecType": {
"values": [
{
"comment": ""
},
{
"name": "PUBLICATIONOBJ_TABLE",
"value": 0,
"comment": "/* A table */"
},
{
"name": "PUBLICATIONOBJ_TABLES_IN_SCHEMA",
"value": 1,
"comment": "/* All tables in schema */"
},
{
"name": "PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA",
"value": 2,
"comment": "/* All tables in first element of\n\t\t\t\t\t\t\t\t\t\t\t * search_path */\n"
},
{
"name": "PUBLICATIONOBJ_CONTINUATION",
"value": 3,
"comment": "/* Continuation of previous type */"
}
],
"comment": "/*\n * Publication object type\n */\n"
},
"AlterPublicationAction": {
"values": [
{
"comment": ""
},
{
"name": "AP_AddObjects",
"value": 0,
"comment": "/* add objects to publication */"
},
{
"name": "AP_DropObjects",
"value": 1,
"comment": "/* remove objects from publication */"
},
{
"name": "AP_SetObjects",
"value": 2,
"comment": "/* set list of objects */"
}
],
"comment": null
},
"AlterSubscriptionType": {
"values": [
{
"comment": ""
},
{
"name": "ALTER_SUBSCRIPTION_OPTIONS",
"value": 0
},
{
"name": "ALTER_SUBSCRIPTION_CONNECTION",
"value": 1
},
{
"name": "ALTER_SUBSCRIPTION_SET_PUBLICATION",
"value": 2
},
{
"name": "ALTER_SUBSCRIPTION_ADD_PUBLICATION",
"value": 3
},
{
"name": "ALTER_SUBSCRIPTION_DROP_PUBLICATION",
"value": 4
},
{
"name": "ALTER_SUBSCRIPTION_REFRESH",
"value": 5
},
{
"name": "ALTER_SUBSCRIPTION_ENABLED",
"value": 6
},
{
"name": "ALTER_SUBSCRIPTION_SKIP",
"value": 7
}
],
"comment": null
}
},
"nodes/primnodes": {
"OverridingKind": {
"values": [
{
"comment": ""
},
{
"name": "OVERRIDING_NOT_SET",
"value": 0
},
{
"name": "OVERRIDING_USER_VALUE",
"value": 1
},
{
"name": "OVERRIDING_SYSTEM_VALUE",
"value": 2
}
],
"comment": "/*-------------------------------------------------------------------------\n *\n * primnodes.h\n *\t Definitions for \"primitive\" node types, those that are used in more\n *\t than one of the parse/plan/execute stages of the query pipeline.\n *\t Currently, these are mostly nodes for executable expressions\n *\t and join trees.\n *\n *\n * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group\n * Portions Copyright (c) 1994, Regents of the University of California\n *\n * src/include/nodes/primnodes.h\n *\n *-------------------------------------------------------------------------\n */\n"
},
"OnCommitAction": {
"values": [
{
"comment": ""
},
{
"name": "ONCOMMIT_NOOP",
"value": 0,
"comment": "/* No ON COMMIT clause (do nothing) */"
},
{
"name": "ONCOMMIT_PRESERVE_ROWS",
"value": 1,
"comment": "/* ON COMMIT PRESERVE ROWS (do nothing) */"
},
{
"name": "ONCOMMIT_DELETE_ROWS",
"value": 2,
"comment": "/* ON COMMIT DELETE ROWS */"
},
{
"name": "ONCOMMIT_DROP",
"value": 3,
"comment": "/* ON COMMIT DROP */"
}
],
"comment": "/* What to do at commit time for temporary relations */\n"
},
"TableFuncType": {
"values": [
{
"comment": ""
},
{
"name": "TFT_XMLTABLE",
"value": 0
},
{
"name": "TFT_JSON_TABLE",
"value": 1
}
],
"comment": null
},
"ParamKind": {
"values": [
{
"comment": ""
},
{
"name": "PARAM_EXTERN",
"value": 0
},
{
"name": "PARAM_EXEC",
"value": 1
},
{
"name": "PARAM_SUBLINK",
"value": 2
},
{
"name": "PARAM_MULTIEXPR",
"value": 3
}
],
"comment": "/*\n * Param\n *\n *\t\tparamkind specifies the kind of parameter. The possible values\n *\t\tfor this field are:\n *\n *\t\tPARAM_EXTERN: The parameter value is supplied from outside the plan.\n *\t\t\t\tSuch parameters are numbered from 1 to n.\n *\n *\t\tPARAM_EXEC: The parameter is an internal executor parameter, used\n *\t\t\t\tfor passing values into and out of sub-queries or from\n *\t\t\t\tnestloop joins to their inner scans.\n *\t\t\t\tFor historical reasons, such parameters are numbered from 0.\n *\t\t\t\tThese numbers are independent of PARAM_EXTERN numbers.\n *\n *\t\tPARAM_SUBLINK:\tThe parameter represents an output column of a SubLink\n *\t\t\t\tnode's sub-select. The column number is contained in the\n *\t\t\t\t`paramid' field. (This type of Param is converted to\n *\t\t\t\tPARAM_EXEC during planning.)\n *\n *\t\tPARAM_MULTIEXPR: Like PARAM_SUBLINK, the parameter represents an\n *\t\t\t\toutput column of a SubLink node's sub-select, but here, the\n *\t\t\t\tSubLink is always a MULTIEXPR SubLink. The high-order 16 bits\n *\t\t\t\tof the `paramid' field contain the SubLink's subLinkId, and\n *\t\t\t\tthe low-order 16 bits contain the column number. (This type\n *\t\t\t\tof Param is also converted to PARAM_EXEC during planning.)\n */\n"
},
"CoercionContext": {
"values": [
{
"comment": ""
},
{
"name": "COERCION_IMPLICIT",
"value": 0,
"comment": "/* coercion in context of expression */"
},
{
"name": "COERCION_ASSIGNMENT",
"value": 1,
"comment": "/* coercion in context of assignment */"
},
{
"name": "COERCION_PLPGSQL",
"value": 2,
"comment": "/* if no assignment cast, use CoerceViaIO */"
},
{
"name": "COERCION_EXPLICIT",
"value": 3,
"comment": "/* explicit cast operation */"
}
],
"comment": "/*\n * CoercionContext - distinguishes the allowed set of type casts\n *\n * NB: ordering of the alternatives is significant; later (larger) values\n * allow more casts than earlier ones.\n */\n"
},
"CoercionForm": {
"values": [
{
"comment": ""
},
{
"name": "COERCE_EXPLICIT_CALL",
"value": 0,
"comment": "/* display as a function call */"
},
{
"name": "COERCE_EXPLICIT_CAST",
"value": 1,
"comment": "/* display as an explicit cast */"
},
{
"name": "COERCE_IMPLICIT_CAST",
"value": 2,
"comment": "/* implicit cast, so hide it */"
},
{
"name": "COERCE_SQL_SYNTAX",
"value": 3,
"comment": "/* display with SQL-mandated special syntax */"
}
],
"comment": "/*\n * CoercionForm - how to display a FuncExpr or related node\n *\n * \"Coercion\" is a bit of a misnomer, since this value records other\n * special syntaxes besides casts, but for now we'll keep this naming.\n *\n * NB: equal() ignores CoercionForm fields, therefore this *must* not carry\n * any semantically significant information. We need that behavior so that\n * the planner will consider equivalent implicit and explicit casts to be\n * equivalent. In cases where those actually behave differently, the coercion\n * function's arguments will be different.\n */\n"
},
"BoolExprType": {
"values": [
{
"comment": ""
},
{
"name": "AND_EXPR",
"value": 0
},
{
"name": "OR_EXPR"
},
{
"name": "NOT_EXPR"
}
],
"comment": "/*\n * BoolExpr - expression node for the basic Boolean operators AND, OR, NOT\n *\n * Notice the arguments are given as a List. For NOT, of course the list\n * must always have exactly one element. For AND and OR, there can be two\n * or more arguments.\n */\n"
},
"SubLinkType": {
"values": [
{
"comment": ""
},
{
"name": "EXISTS_SUBLINK",
"value": 0
},
{
"name": "ALL_SUBLINK",
"value": 1
},
{
"name": "ANY_SUBLINK",
"value": 2
},
{
"name": "ROWCOMPARE_SUBLINK",
"value": 3
},
{
"name": "EXPR_SUBLINK",
"value": 4
},
{
"name": "MULTIEXPR_SUBLINK",
"value": 5
},
{
"name": "ARRAY_SUBLINK",
"value": 6
},
{
"name": "CTE_SUBLINK",
"value": 7,
"comment": "/* for SubPlans only */"
}
],
"comment": "/*\n * SubLink\n *\n * A SubLink represents a subselect appearing in an expression, and in some\n * cases also the combining operator(s) just above it. The subLinkType\n * indicates the form of the expression represented:\n *\tEXISTS_SUBLINK\t\tEXISTS(SELECT ...)\n *\tALL_SUBLINK\t\t\t(lefthand) op ALL (SELECT ...)\n *\tANY_SUBLINK\t\t\t(lefthand) op ANY (SELECT ...)\n *\tROWCOMPARE_SUBLINK\t(lefthand) op (SELECT ...)\n *\tEXPR_SUBLINK\t\t(SELECT with single targetlist item ...)\n *\tMULTIEXPR_SUBLINK\t(SELECT with multiple targetlist items ...)\n *\tARRAY_SUBLINK\t\tARRAY(SELECT with single targetlist item ...)\n *\tCTE_SUBLINK\t\t\tWITH query (never actually part of an expression)\n * For ALL, ANY, and ROWCOMPARE, the lefthand is a list of expressions of the\n * same length as the subselect's targetlist. ROWCOMPARE will *always* have\n * a list with more than one entry; if the subselect has just one target\n * then the parser will create an EXPR_SUBLINK instead (and any operator\n * above the subselect will be represented separately).\n * ROWCOMPARE, EXPR, and MULTIEXPR require the subselect to deliver at most\n * one row (if it returns no rows, the result is NULL).\n * ALL, ANY, and ROWCOMPARE require the combining operators to deliver boolean\n * results. ALL and ANY combine the per-row results using AND and OR\n * semantics respectively.\n * ARRAY requires just one target column, and creates an array of the target\n * column's type using any number of rows resulting from the subselect.\n *\n * SubLink is classed as an Expr node, but it is not actually executable;\n * it must be replaced in the expression tree by a SubPlan node during\n * planning.\n *\n * NOTE: in the raw output of gram.y, testexpr contains just the raw form\n * of the lefthand expression (if any), and operName is the String name of\n * the combining operator. Also, subselect is a raw parsetree. During parse\n * analysis, the parser transforms testexpr into a complete boolean expression\n * that compares the lefthand value(s) to PARAM_SUBLINK nodes representing the\n * output columns of the subselect. And subselect is transformed to a Query.\n * This is the representation seen in saved rules and in the rewriter.\n *\n * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName\n * are unused and are always null.\n *\n * subLinkId is currently used only for MULTIEXPR SubLinks, and is zero in\n * other SubLinks. This number identifies different multiple-assignment\n * subqueries within an UPDATE statement's SET list. It is unique only\n * within a particular targetlist. The output column(s) of the MULTIEXPR\n * are referenced by PARAM_MULTIEXPR Params appearing elsewhere in the tlist.\n *\n * The CTE_SUBLINK case never occurs in actual SubLink nodes, but it is used\n * in SubPlans generated for WITH subqueries.\n */\n"
},
"RowCompareType": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* Values of this enum are chosen to match btree strategy numbers */\n"
},
{
"name": "ROWCOMPARE_LT",
"value": 1,
"comment": "/* BTLessStrategyNumber */"
},
{
"name": "ROWCOMPARE_LE",
"value": 2,
"comment": "/* BTLessEqualStrategyNumber */"
},
{
"name": "ROWCOMPARE_EQ",
"value": 3,
"comment": "/* BTEqualStrategyNumber */"
},
{
"name": "ROWCOMPARE_GE",
"value": 4,
"comment": "/* BTGreaterEqualStrategyNumber */"
},
{
"name": "ROWCOMPARE_GT",
"value": 5,
"comment": "/* BTGreaterStrategyNumber */"
},
{
"name": "ROWCOMPARE_NE",
"value": 6,
"comment": "/* no such btree strategy */"
}
],
"comment": "/*\n * RowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)\n *\n * We support row comparison for any operator that can be determined to\n * act like =, <>, <, <=, >, or >= (we determine this by looking for the\n * operator in btree opfamilies). Note that the same operator name might\n * map to a different operator for each pair of row elements, since the\n * element datatypes can vary.\n *\n * A RowCompareExpr node is only generated for the < <= > >= cases;\n * the = and <> cases are translated to simple AND or OR combinations\n * of the pairwise comparisons. However, we include = and <> in the\n * RowCompareType enum for the convenience of parser logic.\n */\n"
},
"MinMaxOp": {
"values": [
{
"comment": ""
},
{
"name": "IS_GREATEST",
"value": 0
},
{
"name": "IS_LEAST",
"value": 1
}
],
"comment": "/*\n * MinMaxExpr - a GREATEST or LEAST function\n */\n"
},
"SQLValueFunctionOp": {
"values": [
{
"comment": ""
},
{
"name": "SVFOP_CURRENT_DATE",
"value": 0
},
{
"name": "SVFOP_CURRENT_TIME",
"value": 1
},
{
"name": "SVFOP_CURRENT_TIME_N",
"value": 2
},
{
"name": "SVFOP_CURRENT_TIMESTAMP",
"value": 3
},
{
"name": "SVFOP_CURRENT_TIMESTAMP_N",
"value": 4
},
{
"name": "SVFOP_LOCALTIME",
"value": 5
},
{
"name": "SVFOP_LOCALTIME_N",
"value": 6
},
{
"name": "SVFOP_LOCALTIMESTAMP",
"value": 7
},
{
"name": "SVFOP_LOCALTIMESTAMP_N",
"value": 8
},
{
"name": "SVFOP_CURRENT_ROLE",
"value": 9
},
{
"name": "SVFOP_CURRENT_USER",
"value": 10
},
{
"name": "SVFOP_USER",
"value": 11
},
{
"name": "SVFOP_SESSION_USER",
"value": 12
},
{
"name": "SVFOP_CURRENT_CATALOG",
"value": 13
},
{
"name": "SVFOP_CURRENT_SCHEMA",
"value": 14
}
],
"comment": "/*\n * SQLValueFunction - parameterless functions with special grammar productions\n *\n * The SQL standard categorizes some of these as <datetime value function>\n * and others as <general value specification>. We call 'em SQLValueFunctions\n * for lack of a better term. We store type and typmod of the result so that\n * some code doesn't need to know each function individually, and because\n * we would need to store typmod anyway for some of the datetime functions.\n * Note that currently, all variants return non-collating datatypes, so we do\n * not need a collation field; also, all these functions are stable.\n */\n"
},
"XmlExprOp": {
"values": [
{
"comment": ""
},
{
"name": "IS_XMLCONCAT",
"value": 0,
"comment": "/* XMLCONCAT(args) */"
},
{
"name": "IS_XMLELEMENT",
"value": 1,
"comment": "/* XMLELEMENT(name, xml_attributes, args) */"
},
{
"name": "IS_XMLFOREST",
"value": 2,
"comment": "/* XMLFOREST(xml_attributes) */"
},
{
"name": "IS_XMLPARSE",
"value": 3,
"comment": "/* XMLPARSE(text, is_doc, preserve_ws) */"
},
{
"name": "IS_XMLPI",
"value": 4,
"comment": "/* XMLPI(name [, args]) */"
},
{
"name": "IS_XMLROOT",
"value": 5,
"comment": "/* XMLROOT(xml, version, standalone) */"
},
{
"name": "IS_XMLSERIALIZE",
"value": 6,
"comment": "/* XMLSERIALIZE(is_document, xmlval, indent) */"
},
{
"name": "IS_DOCUMENT",
"value": 7,
"comment": "/* xmlval IS DOCUMENT */"
}
],
"comment": "/*\n * XmlExpr - various SQL/XML functions requiring special grammar productions\n *\n * 'name' carries the \"NAME foo\" argument (already XML-escaped).\n * 'named_args' and 'arg_names' represent an xml_attribute list.\n * 'args' carries all other arguments.\n *\n * Note: result type/typmod/collation are not stored, but can be deduced\n * from the XmlExprOp. The type/typmod fields are just used for display\n * purposes, and are NOT necessarily the true result type of the node.\n */\n"
},
"XmlOptionType": {
"values": [
{
"comment": ""
},
{
"name": "XMLOPTION_DOCUMENT",
"value": 0
},
{
"name": "XMLOPTION_CONTENT",
"value": 1
}
],
"comment": null
},
"JsonEncoding": {
"values": [
{
"comment": ""
},
{
"name": "JS_ENC_DEFAULT",
"value": 0,
"comment": "/* unspecified */"
},
{
"name": "JS_ENC_UTF8",
"value": 1
},
{
"name": "JS_ENC_UTF16",
"value": 2
},
{
"name": "JS_ENC_UTF32",
"value": 3
}
],
"comment": "/*\n * JsonEncoding -\n *\t\trepresentation of JSON ENCODING clause\n */\n"
},
"JsonFormatType": {
"values": [
{
"comment": ""
},
{
"name": "JS_FORMAT_DEFAULT",
"value": 0,
"comment": "/* unspecified */"
},
{
"name": "JS_FORMAT_JSON",
"value": 1,
"comment": "/* FORMAT JSON [ENCODING ...] */"
},
{
"name": "JS_FORMAT_JSONB",
"value": 2,
"comment": "/* implicit internal format for RETURNING\n\t\t\t\t\t\t\t\t * jsonb */\n"
}
],
"comment": "/*\n * JsonFormatType -\n *\t\tenumeration of JSON formats used in JSON FORMAT clause\n */\n"
},
"JsonConstructorType": {
"values": [
{
"comment": ""
},
{
"name": "JSCTOR_JSON_OBJECT",
"value": 1
},
{
"name": "JSCTOR_JSON_ARRAY",
"value": 2
},
{
"name": "JSCTOR_JSON_OBJECTAGG",
"value": 3
},
{
"name": "JSCTOR_JSON_ARRAYAGG",
"value": 4
},
{
"name": "JSCTOR_JSON_PARSE",
"value": 5
},
{
"name": "JSCTOR_JSON_SCALAR",
"value": 6
},
{
"name": "JSCTOR_JSON_SERIALIZE",
"value": 7
}
],
"comment": null
},
"JsonValueType": {
"values": [
{
"comment": ""
},
{
"name": "JS_TYPE_ANY",
"value": 0,
"comment": "/* IS JSON [VALUE] */"
},
{
"name": "JS_TYPE_OBJECT",
"value": 1,
"comment": "/* IS JSON OBJECT */"
},
{
"name": "JS_TYPE_ARRAY",
"value": 2,
"comment": "/* IS JSON ARRAY */"
},
{
"name": "JS_TYPE_SCALAR",
"value": 3,
"comment": "/* IS JSON SCALAR */"
}
],
"comment": "/*\n * JsonValueType -\n *\t\trepresentation of JSON item type in IS JSON predicate\n */\n"
},
"JsonWrapper": {
"values": [
{
"comment": ""
},
{
"name": "JSW_UNSPEC",
"value": 0
},
{
"name": "JSW_NONE",
"value": 1
},
{
"name": "JSW_CONDITIONAL",
"value": 2
},
{
"name": "JSW_UNCONDITIONAL",
"value": 3
}
],
"comment": "/*\n * JsonWrapper -\n *\t\trepresentation of WRAPPER clause for JSON_QUERY()\n */\n"
},
"JsonBehaviorType": {
"values": [
{
"comment": ""
},
{
"name": "JSON_BEHAVIOR_NULL",
"value": 0
},
{
"name": "JSON_BEHAVIOR_ERROR",
"value": 1
},
{
"name": "JSON_BEHAVIOR_EMPTY",
"value": 2
},
{
"name": "JSON_BEHAVIOR_TRUE",
"value": 3
},
{
"name": "JSON_BEHAVIOR_FALSE",
"value": 4
},
{
"name": "JSON_BEHAVIOR_UNKNOWN",
"value": 5
},
{
"name": "JSON_BEHAVIOR_EMPTY_ARRAY",
"value": 6
},
{
"name": "JSON_BEHAVIOR_EMPTY_OBJECT",
"value": 7
},
{
"name": "JSON_BEHAVIOR_DEFAULT",
"value": 8
}
],
"comment": "/*\n * JsonBehaviorType -\n *\t\tenumeration of behavior types used in SQL/JSON ON ERROR/EMPTY clauses\n *\n * \t\tIf enum members are reordered, get_json_behavior() from ruleutils.c\n * \t\tmust be updated accordingly.\n */\n"
},
"JsonExprOp": {
"values": [
{
"comment": ""
},
{
"name": "JSON_EXISTS_OP",
"value": 0,
"comment": "/* JSON_EXISTS() */"
},
{
"name": "JSON_QUERY_OP",
"value": 1,
"comment": "/* JSON_QUERY() */"
},
{
"name": "JSON_VALUE_OP",
"value": 2,
"comment": "/* JSON_VALUE() */"
},
{
"name": "JSON_TABLE_OP",
"value": 3,
"comment": "/* JSON_TABLE() */"
}
],
"comment": "/*\n * JsonExprOp -\n *\t\tenumeration of SQL/JSON query function types\n */\n"
},
"NullTestType": {
"values": [
{
"comment": ""
},
{
"name": "IS_NULL",
"value": 0
},
{
"name": "IS_NOT_NULL"
}
],
"comment": "/* ----------------\n * NullTest\n *\n * NullTest represents the operation of testing a value for NULLness.\n * The appropriate test is performed and returned as a boolean Datum.\n *\n * When argisrow is false, this simply represents a test for the null value.\n *\n * When argisrow is true, the input expression must yield a rowtype, and\n * the node implements \"row IS [NOT] NULL\" per the SQL standard. This\n * includes checking individual fields for NULLness when the row datum\n * itself isn't NULL.\n *\n * NOTE: the combination of a rowtype input and argisrow==false does NOT\n * correspond to the SQL notation \"row IS [NOT] NULL\"; instead, this case\n * represents the SQL notation \"row IS [NOT] DISTINCT FROM NULL\".\n * ----------------\n */\n"
},
"BoolTestType": {
"values": [
{
"comment": ""
},
{
"name": "IS_TRUE",
"value": 0
},
{
"name": "IS_NOT_TRUE"
},
{
"name": "IS_FALSE"
},
{
"name": "IS_NOT_FALSE"
},
{
"name": "IS_UNKNOWN"
},
{
"name": "IS_NOT_UNKNOWN"
}
],
"comment": "/*\n * BooleanTest\n *\n * BooleanTest represents the operation of determining whether a boolean\n * is TRUE, FALSE, or UNKNOWN (ie, NULL). All six meaningful combinations\n * are supported. Note that a NULL input does *not* cause a NULL result.\n * The appropriate test is performed and returned as a boolean Datum.\n */\n"
},
"MergeMatchKind": {
"values": [
{
"comment": ""
},
{
"name": "MERGE_WHEN_MATCHED",
"value": 0
},
{
"name": "MERGE_WHEN_NOT_MATCHED_BY_SOURCE",
"value": 1
},
{
"name": "MERGE_WHEN_NOT_MATCHED_BY_TARGET",
"value": 2
}
],
"comment": "/*\n * MergeAction\n *\n * Transformed representation of a WHEN clause in a MERGE statement\n */\n"
}
},
"nodes/lockoptions": {
"LockClauseStrength": {
"values": [
{
"comment": ""
},
{
"name": "LCS_NONE",
"value": 0,
"comment": "/* no such clause - only used in PlanRowMark */"
},
{
"name": "LCS_FORKEYSHARE",
"value": 1,
"comment": "/* FOR KEY SHARE */"
},
{
"name": "LCS_FORSHARE",
"value": 2,
"comment": "/* FOR SHARE */"
},
{
"name": "LCS_FORNOKEYUPDATE",
"value": 3,
"comment": "/* FOR NO KEY UPDATE */"
},
{
"name": "LCS_FORUPDATE",
"value": 4,
"comment": "/* FOR UPDATE */"
}
],
"comment": "/*\n * This enum represents the different strengths of FOR UPDATE/SHARE clauses.\n * The ordering here is important, because the highest numerical value takes\n * precedence when a RTE is specified multiple ways. See applyLockingClause.\n */\n"
},
"LockWaitPolicy": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* Wait for the lock to become available (default behavior) */\n"
},
{
"name": "LockWaitBlock",
"value": 0
},
{
"comment": "\t/* Skip rows that can't be locked (SKIP LOCKED) */\n"
},
{
"name": "LockWaitSkip",
"value": 1
},
{
"comment": "\t/* Raise an error if a row cannot be locked (NOWAIT) */\n"
},
{
"name": "LockWaitError",
"value": 2
}
],
"comment": "/*\n * This enum controls how to deal with rows being locked by FOR UPDATE/SHARE\n * clauses (i.e., it represents the NOWAIT and SKIP LOCKED options).\n * The ordering here is important, because the highest numerical value takes\n * precedence when a RTE is specified multiple ways. See applyLockingClause.\n */\n"
},
"LockTupleMode": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* SELECT FOR KEY SHARE */\n"
},
{
"name": "LockTupleKeyShare",
"value": 0
},
{
"comment": "\t/* SELECT FOR SHARE */\n"
},
{
"name": "LockTupleShare",
"value": 1
},
{
"comment": "\t/* SELECT FOR NO KEY UPDATE, and UPDATEs that don't modify key columns */\n"
},
{
"name": "LockTupleNoKeyExclusive",
"value": 2
},
{
"comment": "\t/* SELECT FOR UPDATE, UPDATEs that modify key columns, and DELETE */\n"
},
{
"name": "LockTupleExclusive",
"value": 3
}
],
"comment": "/*\n * Possible lock modes for a tuple.\n */\n"
}
},
"nodes/nodes": {
"NodeTag": {
"values": [
{
"comment": ""
},
{
"name": "T_Invalid",
"value": 0
},
{
"comment": ""
},
{
"comment": ""
},
{
"name": "T_List",
"value": 1
},
{
"name": "T_Alias",
"value": 2
},
{
"name": "T_RangeVar",
"value": 3
},
{
"name": "T_TableFunc",
"value": 4
},
{
"name": "T_IntoClause",
"value": 5
},
{
"name": "T_Var",
"value": 6
},
{
"name": "T_Const",
"value": 7
},
{
"name": "T_Param",
"value": 8
},
{
"name": "T_Aggref",
"value": 9
},
{
"name": "T_GroupingFunc",
"value": 10
},
{
"name": "T_WindowFunc",
"value": 11
},
{
"name": "T_WindowFuncRunCondition",
"value": 12
},
{
"name": "T_MergeSupportFunc",
"value": 13
},
{
"name": "T_SubscriptingRef",
"value": 14
},
{
"name": "T_FuncExpr",
"value": 15
},
{
"name": "T_NamedArgExpr",
"value": 16
},
{
"name": "T_OpExpr",
"value": 17
},
{
"name": "T_DistinctExpr",
"value": 18
},
{
"name": "T_NullIfExpr",
"value": 19
},
{
"name": "T_ScalarArrayOpExpr",
"value": 20
},
{
"name": "T_BoolExpr",
"value": 21
},
{
"name": "T_SubLink",
"value": 22
},
{
"name": "T_SubPlan",
"value": 23
},
{
"name": "T_AlternativeSubPlan",
"value": 24
},
{
"name": "T_FieldSelect",
"value": 25
},
{
"name": "T_FieldStore",
"value": 26
},
{
"name": "T_RelabelType",
"value": 27
},
{
"name": "T_CoerceViaIO",
"value": 28
},
{
"name": "T_ArrayCoerceExpr",
"value": 29
},
{
"name": "T_ConvertRowtypeExpr",
"value": 30
},
{
"name": "T_CollateExpr",
"value": 31
},
{
"name": "T_CaseExpr",
"value": 32
},
{
"name": "T_CaseWhen",
"value": 33
},
{
"name": "T_CaseTestExpr",
"value": 34
},
{
"name": "T_ArrayExpr",
"value": 35
},
{
"name": "T_RowExpr",
"value": 36
},
{
"name": "T_RowCompareExpr",
"value": 37
},
{
"name": "T_CoalesceExpr",
"value": 38
},
{
"name": "T_MinMaxExpr",
"value": 39
},
{
"name": "T_SQLValueFunction",
"value": 40
},
{
"name": "T_XmlExpr",
"value": 41
},
{
"name": "T_JsonFormat",
"value": 42
},
{
"name": "T_JsonReturning",
"value": 43
},
{
"name": "T_JsonValueExpr",
"value": 44
},
{
"name": "T_JsonConstructorExpr",
"value": 45
},
{
"name": "T_JsonIsPredicate",
"value": 46
},
{
"name": "T_JsonBehavior",
"value": 47
},
{
"name": "T_JsonExpr",
"value": 48
},
{
"name": "T_JsonTablePath",
"value": 49
},
{
"name": "T_JsonTablePathScan",
"value": 50
},
{
"name": "T_JsonTableSiblingJoin",
"value": 51
},
{
"name": "T_NullTest",
"value": 52
},
{
"name": "T_BooleanTest",
"value": 53
},
{
"name": "T_MergeAction",
"value": 54
},
{
"name": "T_CoerceToDomain",
"value": 55
},
{
"name": "T_CoerceToDomainValue",
"value": 56
},
{
"name": "T_SetToDefault",
"value": 57
},
{
"name": "T_CurrentOfExpr",
"value": 58
},
{
"name": "T_NextValueExpr",
"value": 59
},
{
"name": "T_InferenceElem",
"value": 60
},
{
"name": "T_TargetEntry",
"value": 61
},
{
"name": "T_RangeTblRef",
"value": 62
},
{
"name": "T_JoinExpr",
"value": 63
},
{
"name": "T_FromExpr",
"value": 64
},
{
"name": "T_OnConflictExpr",
"value": 65
},
{
"name": "T_Query",
"value": 66
},
{
"name": "T_TypeName",
"value": 67
},
{
"name": "T_ColumnRef",
"value": 68
},
{
"name": "T_ParamRef",
"value": 69
},
{
"name": "T_A_Expr",
"value": 70
},
{
"name": "T_A_Const",
"value": 71
},
{
"name": "T_TypeCast",
"value": 72
},
{
"name": "T_CollateClause",
"value": 73
},
{
"name": "T_RoleSpec",
"value": 74
},
{
"name": "T_FuncCall",
"value": 75
},
{
"name": "T_A_Star",
"value": 76
},
{
"name": "T_A_Indices",
"value": 77
},
{
"name": "T_A_Indirection",
"value": 78
},
{
"name": "T_A_ArrayExpr",
"value": 79
},
{
"name": "T_ResTarget",
"value": 80
},
{
"name": "T_MultiAssignRef",
"value": 81
},
{
"name": "T_SortBy",
"value": 82
},
{
"name": "T_WindowDef",
"value": 83
},
{
"name": "T_RangeSubselect",
"value": 84
},
{
"name": "T_RangeFunction",
"value": 85
},
{
"name": "T_RangeTableFunc",
"value": 86
},
{
"name": "T_RangeTableFuncCol",
"value": 87
},
{
"name": "T_RangeTableSample",
"value": 88
},
{
"name": "T_ColumnDef",
"value": 89
},
{
"name": "T_TableLikeClause",
"value": 90
},
{
"name": "T_IndexElem",
"value": 91
},
{
"name": "T_DefElem",
"value": 92
},
{
"name": "T_LockingClause",
"value": 93
},
{
"name": "T_XmlSerialize",
"value": 94
},
{
"name": "T_PartitionElem",
"value": 95
},
{
"name": "T_PartitionSpec",
"value": 96
},
{
"name": "T_PartitionBoundSpec",
"value": 97
},
{
"name": "T_PartitionRangeDatum",
"value": 98
},
{
"name": "T_SinglePartitionSpec",
"value": 99
},
{
"name": "T_PartitionCmd",
"value": 100
},
{
"name": "T_RangeTblEntry",
"value": 101
},
{
"name": "T_RTEPermissionInfo",
"value": 102
},
{
"name": "T_RangeTblFunction",
"value": 103
},
{
"name": "T_TableSampleClause",
"value": 104
},
{
"name": "T_WithCheckOption",
"value": 105
},
{
"name": "T_SortGroupClause",
"value": 106
},
{
"name": "T_GroupingSet",
"value": 107
},
{
"name": "T_WindowClause",
"value": 108
},
{
"name": "T_RowMarkClause",
"value": 109
},
{
"name": "T_WithClause",
"value": 110
},
{
"name": "T_InferClause",
"value": 111
},
{
"name": "T_OnConflictClause",
"value": 112
},
{
"name": "T_CTESearchClause",
"value": 113
},
{
"name": "T_CTECycleClause",
"value": 114
},
{
"name": "T_CommonTableExpr",
"value": 115
},
{
"name": "T_MergeWhenClause",
"value": 116
},
{
"name": "T_TriggerTransition",
"value": 117
},
{
"name": "T_JsonOutput",
"value": 118
},
{
"name": "T_JsonArgument",
"value": 119
},
{
"name": "T_JsonFuncExpr",
"value": 120
},
{
"name": "T_JsonTablePathSpec",
"value": 121
},
{
"name": "T_JsonTable",
"value": 122
},
{
"name": "T_JsonTableColumn",
"value": 123
},
{
"name": "T_JsonKeyValue",
"value": 124
},
{
"name": "T_JsonParseExpr",
"value": 125
},
{
"name": "T_JsonScalarExpr",
"value": 126
},
{
"name": "T_JsonSerializeExpr",
"value": 127
},
{
"name": "T_JsonObjectConstructor",
"value": 128
},
{
"name": "T_JsonArrayConstructor",
"value": 129
},
{
"name": "T_JsonArrayQueryConstructor",
"value": 130
},
{
"name": "T_JsonAggConstructor",
"value": 131
},
{
"name": "T_JsonObjectAgg",
"value": 132
},
{
"name": "T_JsonArrayAgg",
"value": 133
},
{
"name": "T_RawStmt",
"value": 134
},
{
"name": "T_InsertStmt",
"value": 135
},
{
"name": "T_DeleteStmt",
"value": 136
},
{
"name": "T_UpdateStmt",
"value": 137
},
{
"name": "T_MergeStmt",
"value": 138
},
{
"name": "T_SelectStmt",
"value": 139
},
{
"name": "T_SetOperationStmt",
"value": 140
},
{
"name": "T_ReturnStmt",
"value": 141
},
{
"name": "T_PLAssignStmt",
"value": 142
},
{
"name": "T_CreateSchemaStmt",
"value": 143
},
{
"name": "T_AlterTableStmt",
"value": 144
},
{
"name": "T_ReplicaIdentityStmt",
"value": 145
},
{
"name": "T_AlterTableCmd",
"value": 146
},
{
"name": "T_AlterCollationStmt",
"value": 147
},
{
"name": "T_AlterDomainStmt",
"value": 148
},
{
"name": "T_GrantStmt",
"value": 149
},
{
"name": "T_ObjectWithArgs",
"value": 150
},
{
"name": "T_AccessPriv",
"value": 151
},
{
"name": "T_GrantRoleStmt",
"value": 152
},
{
"name": "T_AlterDefaultPrivilegesStmt",
"value": 153
},
{
"name": "T_CopyStmt",
"value": 154
},
{
"name": "T_VariableSetStmt",
"value": 155
},
{
"name": "T_VariableShowStmt",
"value": 156
},
{
"name": "T_CreateStmt",
"value": 157
},
{
"name": "T_Constraint",
"value": 158
},
{
"name": "T_CreateTableSpaceStmt",
"value": 159
},
{
"name": "T_DropTableSpaceStmt",
"value": 160
},
{
"name": "T_AlterTableSpaceOptionsStmt",
"value": 161
},
{
"name": "T_AlterTableMoveAllStmt",
"value": 162
},
{
"name": "T_CreateExtensionStmt",
"value": 163
},
{
"name": "T_AlterExtensionStmt",
"value": 164
},
{
"name": "T_AlterExtensionContentsStmt",
"value": 165
},
{
"name": "T_CreateFdwStmt",
"value": 166
},
{
"name": "T_AlterFdwStmt",
"value": 167
},
{
"name": "T_CreateForeignServerStmt",
"value": 168
},
{
"name": "T_AlterForeignServerStmt",
"value": 169
},
{
"name": "T_CreateForeignTableStmt",
"value": 170
},
{
"name": "T_CreateUserMappingStmt",
"value": 171
},
{
"name": "T_AlterUserMappingStmt",
"value": 172
},
{
"name": "T_DropUserMappingStmt",
"value": 173
},
{
"name": "T_ImportForeignSchemaStmt",
"value": 174
},
{
"name": "T_CreatePolicyStmt",
"value": 175
},
{
"name": "T_AlterPolicyStmt",
"value": 176
},
{
"name": "T_CreateAmStmt",
"value": 177
},
{
"name": "T_CreateTrigStmt",
"value": 178
},
{
"name": "T_CreateEventTrigStmt",
"value": 179
},
{
"name": "T_AlterEventTrigStmt",
"value": 180
},
{
"name": "T_CreatePLangStmt",
"value": 181
},
{
"name": "T_CreateRoleStmt",
"value": 182
},
{
"name": "T_AlterRoleStmt",
"value": 183
},
{
"name": "T_AlterRoleSetStmt",
"value": 184
},
{
"name": "T_DropRoleStmt",
"value": 185
},
{
"name": "T_CreateSeqStmt",
"value": 186
},
{
"name": "T_AlterSeqStmt",
"value": 187
},
{
"name": "T_DefineStmt",
"value": 188
},
{
"name": "T_CreateDomainStmt",
"value": 189
},
{
"name": "T_CreateOpClassStmt",
"value": 190
},
{
"name": "T_CreateOpClassItem",
"value": 191
},
{
"name": "T_CreateOpFamilyStmt",
"value": 192
},
{
"name": "T_AlterOpFamilyStmt",
"value": 193
},
{
"name": "T_DropStmt",
"value": 194
},
{
"name": "T_TruncateStmt",
"value": 195
},
{
"name": "T_CommentStmt",
"value": 196
},
{
"name": "T_SecLabelStmt",
"value": 197
},
{
"name": "T_DeclareCursorStmt",
"value": 198
},
{
"name": "T_ClosePortalStmt",
"value": 199
},
{
"name": "T_FetchStmt",
"value": 200
},
{
"name": "T_IndexStmt",
"value": 201
},
{
"name": "T_CreateStatsStmt",
"value": 202
},
{
"name": "T_StatsElem",
"value": 203
},
{
"name": "T_AlterStatsStmt",
"value": 204
},
{
"name": "T_CreateFunctionStmt",
"value": 205
},
{
"name": "T_FunctionParameter",
"value": 206
},
{
"name": "T_AlterFunctionStmt",
"value": 207
},
{
"name": "T_DoStmt",
"value": 208
},
{
"name": "T_InlineCodeBlock",
"value": 209
},
{
"name": "T_CallStmt",
"value": 210
},
{
"name": "T_CallContext",
"value": 211
},
{
"name": "T_RenameStmt",
"value": 212
},
{
"name": "T_AlterObjectDependsStmt",
"value": 213
},
{
"name": "T_AlterObjectSchemaStmt",
"value": 214
},
{
"name": "T_AlterOwnerStmt",
"value": 215
},
{
"name": "T_AlterOperatorStmt",
"value": 216
},
{
"name": "T_AlterTypeStmt",
"value": 217
},
{
"name": "T_RuleStmt",
"value": 218
},
{
"name": "T_NotifyStmt",
"value": 219
},
{
"name": "T_ListenStmt",
"value": 220
},
{
"name": "T_UnlistenStmt",
"value": 221
},
{
"name": "T_TransactionStmt",
"value": 222
},
{
"name": "T_CompositeTypeStmt",
"value": 223
},
{
"name": "T_CreateEnumStmt",
"value": 224
},
{
"name": "T_CreateRangeStmt",
"value": 225
},
{
"name": "T_AlterEnumStmt",
"value": 226
},
{
"name": "T_ViewStmt",
"value": 227
},
{
"name": "T_LoadStmt",
"value": 228
},
{
"name": "T_CreatedbStmt",
"value": 229
},
{
"name": "T_AlterDatabaseStmt",
"value": 230
},
{
"name": "T_AlterDatabaseRefreshCollStmt",
"value": 231
},
{
"name": "T_AlterDatabaseSetStmt",
"value": 232
},
{
"name": "T_DropdbStmt",
"value": 233
},
{
"name": "T_AlterSystemStmt",
"value": 234
},
{
"name": "T_ClusterStmt",
"value": 235
},
{
"name": "T_VacuumStmt",
"value": 236
},
{
"name": "T_VacuumRelation",
"value": 237
},
{
"name": "T_ExplainStmt",
"value": 238
},
{
"name": "T_CreateTableAsStmt",
"value": 239
},
{
"name": "T_RefreshMatViewStmt",
"value": 240
},
{
"name": "T_CheckPointStmt",
"value": 241
},
{
"name": "T_DiscardStmt",
"value": 242
},
{
"name": "T_LockStmt",
"value": 243
},
{
"name": "T_ConstraintsSetStmt",
"value": 244
},
{
"name": "T_ReindexStmt",
"value": 245
},
{
"name": "T_CreateConversionStmt",
"value": 246
},
{
"name": "T_CreateCastStmt",
"value": 247
},
{
"name": "T_CreateTransformStmt",
"value": 248
},
{
"name": "T_PrepareStmt",
"value": 249
},
{
"name": "T_ExecuteStmt",
"value": 250
},
{
"name": "T_DeallocateStmt",
"value": 251
},
{
"name": "T_DropOwnedStmt",
"value": 252
},
{
"name": "T_ReassignOwnedStmt",
"value": 253
},
{
"name": "T_AlterTSDictionaryStmt",
"value": 254
},
{
"name": "T_AlterTSConfigurationStmt",
"value": 255
},
{
"name": "T_PublicationTable",
"value": 256
},
{
"name": "T_PublicationObjSpec",
"value": 257
},
{
"name": "T_CreatePublicationStmt",
"value": 258
},
{
"name": "T_AlterPublicationStmt",
"value": 259
},
{
"name": "T_CreateSubscriptionStmt",
"value": 260
},
{
"name": "T_AlterSubscriptionStmt",
"value": 261
},
{
"name": "T_DropSubscriptionStmt",
"value": 262
},
{
"name": "T_PlannerGlobal",
"value": 263
},
{
"name": "T_PlannerInfo",
"value": 264
},
{
"name": "T_RelOptInfo",
"value": 265
},
{
"name": "T_IndexOptInfo",
"value": 266
},
{
"name": "T_ForeignKeyOptInfo",
"value": 267
},
{
"name": "T_StatisticExtInfo",
"value": 268
},
{
"name": "T_JoinDomain",
"value": 269
},
{
"name": "T_EquivalenceClass",
"value": 270
},
{
"name": "T_EquivalenceMember",
"value": 271
},
{
"name": "T_PathKey",
"value": 272
},
{
"name": "T_GroupByOrdering",
"value": 273
},
{
"name": "T_PathTarget",
"value": 274
},
{
"name": "T_ParamPathInfo",
"value": 275
},
{
"name": "T_Path",
"value": 276
},
{
"name": "T_IndexPath",
"value": 277
},
{
"name": "T_IndexClause",
"value": 278
},
{
"name": "T_BitmapHeapPath",
"value": 279
},
{
"name": "T_BitmapAndPath",
"value": 280
},
{
"name": "T_BitmapOrPath",
"value": 281
},
{
"name": "T_TidPath",
"value": 282
},
{
"name": "T_TidRangePath",
"value": 283
},
{
"name": "T_SubqueryScanPath",
"value": 284
},
{
"name": "T_ForeignPath",
"value": 285
},
{
"name": "T_CustomPath",
"value": 286
},
{
"name": "T_AppendPath",
"value": 287
},
{
"name": "T_MergeAppendPath",
"value": 288
},
{
"name": "T_GroupResultPath",
"value": 289
},
{
"name": "T_MaterialPath",
"value": 290
},
{
"name": "T_MemoizePath",
"value": 291
},
{
"name": "T_UniquePath",
"value": 292
},
{
"name": "T_GatherPath",
"value": 293
},
{
"name": "T_GatherMergePath",
"value": 294
},
{
"name": "T_NestPath",
"value": 295
},
{
"name": "T_MergePath",
"value": 296
},
{
"name": "T_HashPath",
"value": 297
},
{
"name": "T_ProjectionPath",
"value": 298
},
{
"name": "T_ProjectSetPath",
"value": 299
},
{
"name": "T_SortPath",
"value": 300
},
{
"name": "T_IncrementalSortPath",
"value": 301
},
{
"name": "T_GroupPath",
"value": 302
},
{
"name": "T_UpperUniquePath",
"value": 303
},
{
"name": "T_AggPath",
"value": 304
},
{
"name": "T_GroupingSetData",
"value": 305
},
{
"name": "T_RollupData",
"value": 306
},
{
"name": "T_GroupingSetsPath",
"value": 307
},
{
"name": "T_MinMaxAggPath",
"value": 308
},
{
"name": "T_WindowAggPath",
"value": 309
},
{
"name": "T_SetOpPath",
"value": 310
},
{
"name": "T_RecursiveUnionPath",
"value": 311
},
{
"name": "T_LockRowsPath",
"value": 312
},
{
"name": "T_ModifyTablePath",
"value": 313
},
{
"name": "T_LimitPath",
"value": 314
},
{
"name": "T_RestrictInfo",
"value": 315
},
{
"name": "T_PlaceHolderVar",
"value": 316
},
{
"name": "T_SpecialJoinInfo",
"value": 317
},
{
"name": "T_OuterJoinClauseInfo",
"value": 318
},
{
"name": "T_AppendRelInfo",
"value": 319
},
{
"name": "T_RowIdentityVarInfo",
"value": 320
},
{
"name": "T_PlaceHolderInfo",
"value": 321
},
{
"name": "T_MinMaxAggInfo",
"value": 322
},
{
"name": "T_PlannerParamItem",
"value": 323
},
{
"name": "T_AggInfo",
"value": 324
},
{
"name": "T_AggTransInfo",
"value": 325
},
{
"name": "T_PlannedStmt",
"value": 326
},
{
"name": "T_Result",
"value": 327
},
{
"name": "T_ProjectSet",
"value": 328
},
{
"name": "T_ModifyTable",
"value": 329
},
{
"name": "T_Append",
"value": 330
},
{
"name": "T_MergeAppend",
"value": 331
},
{
"name": "T_RecursiveUnion",
"value": 332
},
{
"name": "T_BitmapAnd",
"value": 333
},
{
"name": "T_BitmapOr",
"value": 334
},
{
"name": "T_SeqScan",
"value": 335
},
{
"name": "T_SampleScan",
"value": 336
},
{
"name": "T_IndexScan",
"value": 337
},
{
"name": "T_IndexOnlyScan",
"value": 338
},
{
"name": "T_BitmapIndexScan",
"value": 339
},
{
"name": "T_BitmapHeapScan",
"value": 340
},
{
"name": "T_TidScan",
"value": 341
},
{
"name": "T_TidRangeScan",
"value": 342
},
{
"name": "T_SubqueryScan",
"value": 343
},
{
"name": "T_FunctionScan",
"value": 344
},
{
"name": "T_ValuesScan",
"value": 345
},
{
"name": "T_TableFuncScan",
"value": 346
},
{
"name": "T_CteScan",
"value": 347
},
{
"name": "T_NamedTuplestoreScan",
"value": 348
},
{
"name": "T_WorkTableScan",
"value": 349
},
{
"name": "T_ForeignScan",
"value": 350
},
{
"name": "T_CustomScan",
"value": 351
},
{
"name": "T_NestLoop",
"value": 352
},
{
"name": "T_NestLoopParam",
"value": 353
},
{
"name": "T_MergeJoin",
"value": 354
},
{
"name": "T_HashJoin",
"value": 355
},
{
"name": "T_Material",
"value": 356
},
{
"name": "T_Memoize",
"value": 357
},
{
"name": "T_Sort",
"value": 358
},
{
"name": "T_IncrementalSort",
"value": 359
},
{
"name": "T_Group",
"value": 360
},
{
"name": "T_Agg",
"value": 361
},
{
"name": "T_WindowAgg",
"value": 362
},
{
"name": "T_Unique",
"value": 363
},
{
"name": "T_Gather",
"value": 364
},
{
"name": "T_GatherMerge",
"value": 365
},
{
"name": "T_Hash",
"value": 366
},
{
"name": "T_SetOp",
"value": 367
},
{
"name": "T_LockRows",
"value": 368
},
{
"name": "T_Limit",
"value": 369
},
{
"name": "T_PlanRowMark",
"value": 370
},
{
"name": "T_PartitionPruneInfo",
"value": 371
},
{
"name": "T_PartitionedRelPruneInfo",
"value": 372
},
{
"name": "T_PartitionPruneStepOp",
"value": 373
},
{
"name": "T_PartitionPruneStepCombine",
"value": 374
},
{
"name": "T_PlanInvalItem",
"value": 375
},
{
"name": "T_ExprState",
"value": 376
},
{
"name": "T_IndexInfo",
"value": 377
},
{
"name": "T_ExprContext",
"value": 378
},
{
"name": "T_ReturnSetInfo",
"value": 379
},
{
"name": "T_ProjectionInfo",
"value": 380
},
{
"name": "T_JunkFilter",
"value": 381
},
{
"name": "T_OnConflictSetState",
"value": 382
},
{
"name": "T_MergeActionState",
"value": 383
},
{
"name": "T_ResultRelInfo",
"value": 384
},
{
"name": "T_EState",
"value": 385
},
{
"name": "T_WindowFuncExprState",
"value": 386
},
{
"name": "T_SetExprState",
"value": 387
},
{
"name": "T_SubPlanState",
"value": 388
},
{
"name": "T_DomainConstraintState",
"value": 389
},
{
"name": "T_ResultState",
"value": 390
},
{
"name": "T_ProjectSetState",
"value": 391
},
{
"name": "T_ModifyTableState",
"value": 392
},
{
"name": "T_AppendState",
"value": 393
},
{
"name": "T_MergeAppendState",
"value": 394
},
{
"name": "T_RecursiveUnionState",
"value": 395
},
{
"name": "T_BitmapAndState",
"value": 396
},
{
"name": "T_BitmapOrState",
"value": 397
},
{
"name": "T_ScanState",
"value": 398
},
{
"name": "T_SeqScanState",
"value": 399
},
{
"name": "T_SampleScanState",
"value": 400
},
{
"name": "T_IndexScanState",
"value": 401
},
{
"name": "T_IndexOnlyScanState",
"value": 402
},
{
"name": "T_BitmapIndexScanState",
"value": 403
},
{
"name": "T_BitmapHeapScanState",
"value": 404
},
{
"name": "T_TidScanState",
"value": 405
},
{
"name": "T_TidRangeScanState",
"value": 406
},
{
"name": "T_SubqueryScanState",
"value": 407
},
{
"name": "T_FunctionScanState",
"value": 408
},
{
"name": "T_ValuesScanState",
"value": 409
},
{
"name": "T_TableFuncScanState",
"value": 410
},
{
"name": "T_CteScanState",
"value": 411
},
{
"name": "T_NamedTuplestoreScanState",
"value": 412
},
{
"name": "T_WorkTableScanState",
"value": 413
},
{
"name": "T_ForeignScanState",
"value": 414
},
{
"name": "T_CustomScanState",
"value": 415
},
{
"name": "T_JoinState",
"value": 416
},
{
"name": "T_NestLoopState",
"value": 417
},
{
"name": "T_MergeJoinState",
"value": 418
},
{
"name": "T_HashJoinState",
"value": 419
},
{
"name": "T_MaterialState",
"value": 420
},
{
"name": "T_MemoizeState",
"value": 421
},
{
"name": "T_SortState",
"value": 422
},
{
"name": "T_IncrementalSortState",
"value": 423
},
{
"name": "T_GroupState",
"value": 424
},
{
"name": "T_AggState",
"value": 425
},
{
"name": "T_WindowAggState",
"value": 426
},
{
"name": "T_UniqueState",
"value": 427
},
{
"name": "T_GatherState",
"value": 428
},
{
"name": "T_GatherMergeState",
"value": 429
},
{
"name": "T_HashState",
"value": 430
},
{
"name": "T_SetOpState",
"value": 431
},
{
"name": "T_LockRowsState",
"value": 432
},
{
"name": "T_LimitState",
"value": 433
},
{
"name": "T_IndexAmRoutine",
"value": 434
},
{
"name": "T_TableAmRoutine",
"value": 435
},
{
"name": "T_TsmRoutine",
"value": 436
},
{
"name": "T_EventTriggerData",
"value": 437
},
{
"name": "T_TriggerData",
"value": 438
},
{
"name": "T_TupleTableSlot",
"value": 439
},
{
"name": "T_FdwRoutine",
"value": 440
},
{
"name": "T_Bitmapset",
"value": 441
},
{
"name": "T_ExtensibleNode",
"value": 442
},
{
"name": "T_ErrorSaveContext",
"value": 443
},
{
"name": "T_IdentifySystemCmd",
"value": 444
},
{
"name": "T_BaseBackupCmd",
"value": 445
},
{
"name": "T_CreateReplicationSlotCmd",
"value": 446
},
{
"name": "T_DropReplicationSlotCmd",
"value": 447
},
{
"name": "T_AlterReplicationSlotCmd",
"value": 448
},
{
"name": "T_StartReplicationCmd",
"value": 449
},
{
"name": "T_ReadReplicationSlotCmd",
"value": 450
},
{
"name": "T_TimeLineHistoryCmd",
"value": 451
},
{
"name": "T_UploadManifestCmd",
"value": 452
},
{
"name": "T_SupportRequestSimplify",
"value": 453
},
{
"name": "T_SupportRequestSelectivity",
"value": 454
},
{
"name": "T_SupportRequestCost",
"value": 455
},
{
"name": "T_SupportRequestRows",
"value": 456
},
{
"name": "T_SupportRequestIndexCondition",
"value": 457
},
{
"name": "T_SupportRequestWFuncMonotonic",
"value": 458
},
{
"name": "T_SupportRequestOptimizeWindowClause",
"value": 459
},
{
"name": "T_Integer",
"value": 460
},
{
"name": "T_Float",
"value": 461
},
{
"name": "T_Boolean",
"value": 462
},
{
"name": "T_String",
"value": 463
},
{
"name": "T_BitString",
"value": 464
},
{
"name": "T_ForeignKeyCacheInfo",
"value": 465
},
{
"name": "T_IntList",
"value": 466
},
{
"name": "T_OidList",
"value": 467
},
{
"name": "T_XidList",
"value": 468
},
{
"name": "T_AllocSetContext",
"value": 469
},
{
"name": "T_GenerationContext",
"value": 470
},
{
"name": "T_SlabContext",
"value": 471
},
{
"name": "T_BumpContext",
"value": 472
},
{
"name": "T_TIDBitmap",
"value": 473
},
{
"name": "T_WindowObjectData",
"value": 474
}
],
"comment": "/*\n * The first field of every node is NodeTag. Each node created (with makeNode)\n * will have one of the following tags as the value of its first field.\n *\n * Note that inserting or deleting node types changes the numbers of other\n * node types later in the list. This is no problem during development, since\n * the node numbers are never stored on disk. But don't do it in a released\n * branch, because that would represent an ABI break for extensions.\n */\n"
},
"CmdType": {
"values": [
{
"comment": ""
},
{
"name": "CMD_UNKNOWN",
"value": 0
},
{
"name": "CMD_SELECT",
"value": 1,
"comment": "/* select stmt */"
},
{
"name": "CMD_UPDATE",
"value": 2,
"comment": "/* update stmt */"
},
{
"name": "CMD_INSERT",
"value": 3,
"comment": "/* insert stmt */"
},
{
"name": "CMD_DELETE",
"value": 4,
"comment": "/* delete stmt */"
},
{
"name": "CMD_MERGE",
"value": 5,
"comment": "/* merge stmt */"
},
{
"name": "CMD_UTILITY",
"value": 6,
"comment": "/* cmds like create, destroy, copy, vacuum,\n\t\t\t\t\t\t\t\t * etc. */\n"
},
{
"name": "CMD_NOTHING",
"value": 7,
"comment": "/* dummy command for instead nothing rules\n\t\t\t\t\t\t\t\t * with qual */\n"
}
],
"comment": "/*\n * CmdType -\n *\t enums for type of operation represented by a Query or PlannedStmt\n *\n * This is needed in both parsenodes.h and plannodes.h, so put it here...\n */\n"
},
"JoinType": {
"values": [
{
"comment": ""
},
{
"comment": "\t/*\n\t * The canonical kinds of joins according to the SQL JOIN syntax. Only\n\t * these codes can appear in parser output (e.g., JoinExpr nodes).\n\t */\n"
},
{
"name": "JOIN_INNER",
"value": 0,
"comment": "/* matching tuple pairs only */"
},
{
"name": "JOIN_LEFT",
"value": 1,
"comment": "/* pairs + unmatched LHS tuples */"
},
{
"name": "JOIN_FULL",
"value": 2,
"comment": "/* pairs + unmatched LHS + unmatched RHS */"
},
{
"name": "JOIN_RIGHT",
"value": 3,
"comment": "/* pairs + unmatched RHS tuples */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Semijoins and anti-semijoins (as defined in relational theory) do not\n\t * appear in the SQL JOIN syntax, but there are standard idioms for\n\t * representing them (e.g., using EXISTS). The planner recognizes these\n\t * cases and converts them to joins. So the planner and executor must\n\t * support these codes. NOTE: in JOIN_SEMI output, it is unspecified\n\t * which matching RHS row is joined to. In JOIN_ANTI output, the row is\n\t * guaranteed to be null-extended.\n\t */\n"
},
{
"name": "JOIN_SEMI",
"value": 4,
"comment": "/* 1 copy of each LHS row that has match(es) */"
},
{
"name": "JOIN_ANTI",
"value": 5,
"comment": "/* 1 copy of each LHS row that has no match */"
},
{
"name": "JOIN_RIGHT_ANTI",
"value": 6,
"comment": "/* 1 copy of each RHS row that has no match */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These codes are used internally in the planner, but are not supported\n\t * by the executor (nor, indeed, by most of the planner).\n\t */\n"
},
{
"name": "JOIN_UNIQUE_OUTER",
"value": 7,
"comment": "/* LHS path must be made unique */"
},
{
"name": "JOIN_UNIQUE_INNER",
"value": 8,
"comment": "/* RHS path must be made unique */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * We might need additional join types someday.\n\t */\n"
}
],
"comment": "/*\n * JoinType -\n *\t enums for types of relation joins\n *\n * JoinType determines the exact semantics of joining two relations using\n * a matching qualification. For example, it tells what to do with a tuple\n * that has no match in the other relation.\n *\n * This is needed in both parsenodes.h and plannodes.h, so put it here...\n */\n"
},
"AggStrategy": {
"values": [
{
"comment": ""
},
{
"name": "AGG_PLAIN",
"value": 0,
"comment": "/* simple agg across all input rows */"
},
{
"name": "AGG_SORTED",
"value": 1,
"comment": "/* grouped agg, input must be sorted */"
},
{
"name": "AGG_HASHED",
"value": 2,
"comment": "/* grouped agg, use internal hashtable */"
},
{
"name": "AGG_MIXED",
"value": 3,
"comment": "/* grouped agg, hash and sort both used */"
}
],
"comment": "/*\n * AggStrategy -\n *\t overall execution strategies for Agg plan nodes\n *\n * This is needed in both pathnodes.h and plannodes.h, so put it here...\n */\n"
},
"AggSplit": {
"values": [
{
"comment": ""
},
{
"comment": "\t/* Basic, non-split aggregation: */\n"
},
{
"name": "AGGSPLIT_SIMPLE",
"value": 0
},
{
"comment": "\t/* Initial phase of partial aggregation, with serialization: */\n"
},
{
"name": "AGGSPLIT_INITIAL_SERIAL",
"value": 1
},
{
"comment": "\t/* Final phase of partial aggregation, with deserialization: */\n"
},
{
"name": "AGGSPLIT_FINAL_DESERIAL",
"value": 2
}
],
"comment": "/* Supported operating modes (i.e., useful combinations of these options): */\n"
},
"SetOpCmd": {
"values": [
{
"comment": ""
},
{
"name": "SETOPCMD_INTERSECT",
"value": 0
},
{
"name": "SETOPCMD_INTERSECT_ALL",
"value": 1
},
{
"name": "SETOPCMD_EXCEPT",
"value": 2
},
{
"name": "SETOPCMD_EXCEPT_ALL",
"value": 3
}
],
"comment": "/*\n * SetOpCmd and SetOpStrategy -\n *\t overall semantics and execution strategies for SetOp plan nodes\n *\n * This is needed in both pathnodes.h and plannodes.h, so put it here...\n */\n"
},
"SetOpStrategy": {
"values": [
{
"comment": ""
},
{
"name": "SETOP_SORTED",
"value": 0,
"comment": "/* input must be sorted */"
},
{
"name": "SETOP_HASHED",
"value": 1,
"comment": "/* use internal hashtable */"
}
],
"comment": null
},
"OnConflictAction": {
"values": [
{
"comment": ""
},
{
"name": "ONCONFLICT_NONE",
"value": 0,
"comment": "/* No \"ON CONFLICT\" clause */"
},
{
"name": "ONCONFLICT_NOTHING",
"value": 1,
"comment": "/* ON CONFLICT ... DO NOTHING */"
},
{
"name": "ONCONFLICT_UPDATE",
"value": 2,
"comment": "/* ON CONFLICT ... DO UPDATE */"
}
],
"comment": "/*\n * OnConflictAction -\n *\t \"ON CONFLICT\" clause type of query\n *\n * This is needed in both parsenodes.h and plannodes.h, so put it here...\n */\n"
},
"LimitOption": {
"values": [
{
"comment": ""
},
{
"name": "LIMIT_OPTION_DEFAULT",
"value": 0,
"comment": "/* No limit present */"
},
{
"name": "LIMIT_OPTION_COUNT",
"value": 1,
"comment": "/* FETCH FIRST... ONLY */"
},
{
"name": "LIMIT_OPTION_WITH_TIES",
"value": 2,
"comment": "/* FETCH FIRST... WITH TIES */"
}
],
"comment": "/*\n * LimitOption -\n *\tLIMIT option of query\n *\n * This is needed in both parsenodes.h and plannodes.h, so put it here...\n */\n"
}
},
"nodes/params": {
},
"access/attnum": {
},
"c": {
},
"postgres": {
},
"postgres_ext": {
},
"commands/vacuum": {
"VacOptValue": {
"values": [
{
"comment": ""
},
{
"name": "VACOPTVALUE_UNSPECIFIED",
"value": 0
},
{
"name": "VACOPTVALUE_AUTO",
"value": 1
},
{
"name": "VACOPTVALUE_DISABLED",
"value": 2
},
{
"name": "VACOPTVALUE_ENABLED",
"value": 3
}
],
"comment": "/*\n * Values used by index_cleanup and truncate params.\n *\n * VACOPTVALUE_UNSPECIFIED is used as an initial placeholder when VACUUM\n * command has no explicit value. When that happens the final usable value\n * comes from the corresponding reloption (though the reloption default is\n * usually used).\n */\n"
}
},
"storage/block": {
},
"access/sdir": {
"ScanDirection": {
"values": [
{
"comment": ""
},
{
"name": "BackwardScanDirection",
"value": 0
},
{
"name": "NoMovementScanDirection",
"value": 0
},
{
"name": "ForwardScanDirection",
"value": 1
}
],
"comment": "/*\n * Defines the direction for scanning a table or an index. Scans are never\n * invoked using NoMovementScanDirectionScans. For convenience, we use the\n * values -1 and 1 for backward and forward scans. This allows us to perform\n * a few mathematical tricks such as what is done in ScanDirectionCombine.\n */\n"
}
},
"mb/pg_wchar": {
"pg_enc": {
"values": [
{
"comment": ""
},
{
"name": "PG_SQL_ASCII",
"value": 0,
"comment": "/* SQL/ASCII */"
},
{
"name": "PG_EUC_JP",
"value": 1,
"comment": "/* EUC for Japanese */"
},
{
"name": "PG_EUC_CN",
"value": 2,
"comment": "/* EUC for Chinese */"
},
{
"name": "PG_EUC_KR",
"value": 3,
"comment": "/* EUC for Korean */"
},
{
"name": "PG_EUC_TW",
"value": 4,
"comment": "/* EUC for Taiwan */"
},
{
"name": "PG_EUC_JIS_2004",
"value": 5,
"comment": "/* EUC-JIS-2004 */"
},
{
"name": "PG_UTF8",
"value": 6,
"comment": "/* Unicode UTF8 */"
},
{
"name": "PG_MULE_INTERNAL",
"value": 7,
"comment": "/* Mule internal code */"
},
{
"name": "PG_LATIN1",
"value": 8,
"comment": "/* ISO-8859-1 Latin 1 */"
},
{
"name": "PG_LATIN2",
"value": 9,
"comment": "/* ISO-8859-2 Latin 2 */"
},
{
"name": "PG_LATIN3",
"value": 10,
"comment": "/* ISO-8859-3 Latin 3 */"
},
{
"name": "PG_LATIN4",
"value": 11,
"comment": "/* ISO-8859-4 Latin 4 */"
},
{
"name": "PG_LATIN5",
"value": 12,
"comment": "/* ISO-8859-9 Latin 5 */"
},
{
"name": "PG_LATIN6",
"value": 13,
"comment": "/* ISO-8859-10 Latin6 */"
},
{
"name": "PG_LATIN7",
"value": 14,
"comment": "/* ISO-8859-13 Latin7 */"
},
{
"name": "PG_LATIN8",
"value": 15,
"comment": "/* ISO-8859-14 Latin8 */"
},
{
"name": "PG_LATIN9",
"value": 16,
"comment": "/* ISO-8859-15 Latin9 */"
},
{
"name": "PG_LATIN10",
"value": 17,
"comment": "/* ISO-8859-16 Latin10 */"
},
{
"name": "PG_WIN1256",
"value": 18,
"comment": "/* windows-1256 */"
},
{
"name": "PG_WIN1258",
"value": 19,
"comment": "/* Windows-1258 */"
},
{
"name": "PG_WIN866",
"value": 20,
"comment": "/* (MS-DOS CP866) */"
},
{
"name": "PG_WIN874",
"value": 21,
"comment": "/* windows-874 */"
},
{
"name": "PG_KOI8R",
"value": 22,
"comment": "/* KOI8-R */"
},
{
"name": "PG_WIN1251",
"value": 23,
"comment": "/* windows-1251 */"
},
{
"name": "PG_WIN1252",
"value": 24,
"comment": "/* windows-1252 */"
},
{
"name": "PG_ISO_8859_5",
"value": 25,
"comment": "/* ISO-8859-5 */"
},
{
"name": "PG_ISO_8859_6",
"value": 26,
"comment": "/* ISO-8859-6 */"
},
{
"name": "PG_ISO_8859_7",
"value": 27,
"comment": "/* ISO-8859-7 */"
},
{
"name": "PG_ISO_8859_8",
"value": 28,
"comment": "/* ISO-8859-8 */"
},
{
"name": "PG_WIN1250",
"value": 29,
"comment": "/* windows-1250 */"
},
{
"name": "PG_WIN1253",
"value": 30,
"comment": "/* windows-1253 */"
},
{
"name": "PG_WIN1254",
"value": 31,
"comment": "/* windows-1254 */"
},
{
"name": "PG_WIN1255",
"value": 32,
"comment": "/* windows-1255 */"
},
{
"name": "PG_WIN1257",
"value": 33,
"comment": "/* windows-1257 */"
},
{
"name": "PG_KOI8U",
"value": 34,
"comment": "/* KOI8-U */"
},
{
"comment": "\t/* PG_ENCODING_BE_LAST points to the above entry */\n"
},
{
"comment": ""
},
{
"comment": "\t/* followings are for client encoding only */\n"
},
{
"name": "PG_SJIS",
"value": 35,
"comment": "/* Shift JIS (Windows-932) */"
},
{
"name": "PG_BIG5",
"value": 36,
"comment": "/* Big5 (Windows-950) */"
},
{
"name": "PG_GBK",
"value": 37,
"comment": "/* GBK (Windows-936) */"
},
{
"name": "PG_UHC",
"value": 38,
"comment": "/* UHC (Windows-949) */"
},
{
"name": "PG_GB18030",
"value": 39,
"comment": "/* GB18030 */"
},
{
"name": "PG_JOHAB",
"value": 40,
"comment": "/* EUC for Korean JOHAB */"
},
{
"name": "PG_SHIFT_JIS_2004",
"value": 41,
"comment": "/* Shift-JIS-2004 */"
},
{
"name": "_PG_LAST_ENCODING_",
"value": 42,
"comment": "/* mark only */"
},
{
"comment": ""
}
],
"comment": "/*\n * PostgreSQL encoding identifiers\n *\n * WARNING: If you add some encoding don't forget to update\n *\t\t\tthe pg_enc2name_tbl[] array (in src/common/encnames.c),\n *\t\t\tthe pg_enc2gettext_tbl[] array (in src/common/encnames.c) and\n *\t\t\tthe pg_wchar_table[] array (in src/common/wchar.c) and to check\n *\t\t\tPG_ENCODING_BE_LAST macro.\n *\n * PG_SQL_ASCII is default encoding and must be = 0.\n *\n * XXX\tWe must avoid renumbering any backend encoding until libpq's major\n * version number is increased beyond 5; it turns out that the backend\n * encoding IDs are effectively part of libpq's ABI as far as 8.2 initdb and\n * psql are concerned.\n */\n"
}
},
"../backend/parser/gram": {
"yytokentype": {
"values": [
{
"name": "IDENT",
"value": 258
},
{
"name": "UIDENT",
"value": 259
},
{
"name": "FCONST",
"value": 260
},
{
"name": "SCONST",
"value": 261
},
{
"name": "USCONST",
"value": 262
},
{
"name": "BCONST",
"value": 263
},
{
"name": "XCONST",
"value": 264
},
{
"name": "Op",
"value": 265
},
{
"name": "ICONST",
"value": 266
},
{
"name": "PARAM",
"value": 267
},
{
"name": "TYPECAST",
"value": 268
},
{
"name": "DOT_DOT",
"value": 269
},
{
"name": "COLON_EQUALS",
"value": 270
},
{
"name": "EQUALS_GREATER",
"value": 271
},
{
"name": "LESS_EQUALS",
"value": 272
},
{
"name": "GREATER_EQUALS",
"value": 273
},
{
"name": "NOT_EQUALS",
"value": 274
},
{
"name": "SQL_COMMENT",
"value": 275
},
{
"name": "C_COMMENT",
"value": 276
},
{
"name": "ABORT_P",
"value": 277
},
{
"name": "ABSENT",
"value": 278
},
{
"name": "ABSOLUTE_P",
"value": 279
},
{
"name": "ACCESS",
"value": 280
},
{
"name": "ACTION",
"value": 281
},
{
"name": "ADD_P",
"value": 282
},
{
"name": "ADMIN",
"value": 283
},
{
"name": "AFTER",
"value": 284
},
{
"name": "AGGREGATE",
"value": 285
},
{
"name": "ALL",
"value": 286
},
{
"name": "ALSO",
"value": 287
},
{
"name": "ALTER",
"value": 288
},
{
"name": "ALWAYS",
"value": 289
},
{
"name": "ANALYSE",
"value": 290
},
{
"name": "ANALYZE",
"value": 291
},
{
"name": "AND",
"value": 292
},
{
"name": "ANY",
"value": 293
},
{
"name": "ARRAY",
"value": 294
},
{
"name": "AS",
"value": 295
},
{
"name": "ASC",
"value": 296
},
{
"name": "ASENSITIVE",
"value": 297
},
{
"name": "ASSERTION",
"value": 298
},
{
"name": "ASSIGNMENT",
"value": 299
},
{
"name": "ASYMMETRIC",
"value": 300
},
{
"name": "ATOMIC",
"value": 301
},
{
"name": "AT",
"value": 302
},
{
"name": "ATTACH",
"value": 303
},
{
"name": "ATTRIBUTE",
"value": 304
},
{
"name": "AUTHORIZATION",
"value": 305
},
{
"name": "BACKWARD",
"value": 306
},
{
"name": "BEFORE",
"value": 307
},
{
"name": "BEGIN_P",
"value": 308
},
{
"name": "BETWEEN",
"value": 309
},
{
"name": "BIGINT",
"value": 310
},
{
"name": "BINARY",
"value": 311
},
{
"name": "BIT",
"value": 312
},
{
"name": "BOOLEAN_P",
"value": 313
},
{
"name": "BOTH",
"value": 314
},
{
"name": "BREADTH",
"value": 315
},
{
"name": "BY",
"value": 316
},
{
"name": "CACHE",
"value": 317
},
{
"name": "CALL",
"value": 318
},
{
"name": "CALLED",
"value": 319
},
{
"name": "CASCADE",
"value": 320
},
{
"name": "CASCADED",
"value": 321
},
{
"name": "CASE",
"value": 322
},
{
"name": "CAST",
"value": 323
},
{
"name": "CATALOG_P",
"value": 324
},
{
"name": "CHAIN",
"value": 325
},
{
"name": "CHAR_P",
"value": 326
},
{
"name": "CHARACTER",
"value": 327
},
{
"name": "CHARACTERISTICS",
"value": 328
},
{
"name": "CHECK",
"value": 329
},
{
"name": "CHECKPOINT",
"value": 330
},
{
"name": "CLASS",
"value": 331
},
{
"name": "CLOSE",
"value": 332
},
{
"name": "CLUSTER",
"value": 333
},
{
"name": "COALESCE",
"value": 334
},
{
"name": "COLLATE",
"value": 335
},
{
"name": "COLLATION",
"value": 336
},
{
"name": "COLUMN",
"value": 337
},
{
"name": "COLUMNS",
"value": 338
},
{
"name": "COMMENT",
"value": 339
},
{
"name": "COMMENTS",
"value": 340
},
{
"name": "COMMIT",
"value": 341
},
{
"name": "COMMITTED",
"value": 342
},
{
"name": "COMPRESSION",
"value": 343
},
{
"name": "CONCURRENTLY",
"value": 344
},
{
"name": "CONDITIONAL",
"value": 345
},
{
"name": "CONFIGURATION",
"value": 346
},
{
"name": "CONFLICT",
"value": 347
},
{
"name": "CONNECTION",
"value": 348
},
{
"name": "CONSTRAINT",
"value": 349
},
{
"name": "CONSTRAINTS",
"value": 350
},
{
"name": "CONTENT_P",
"value": 351
},
{
"name": "CONTINUE_P",
"value": 352
},
{
"name": "CONVERSION_P",
"value": 353
},
{
"name": "COPY",
"value": 354
},
{
"name": "COST",
"value": 355
},
{
"name": "CREATE",
"value": 356
},
{
"name": "CROSS",
"value": 357
},
{
"name": "CSV",
"value": 358
},
{
"name": "CUBE",
"value": 359
},
{
"name": "CURRENT_P",
"value": 360
},
{
"name": "CURRENT_CATALOG",
"value": 361
},
{
"name": "CURRENT_DATE",
"value": 362
},
{
"name": "CURRENT_ROLE",
"value": 363
},
{
"name": "CURRENT_SCHEMA",
"value": 364
},
{
"name": "CURRENT_TIME",
"value": 365
},
{
"name": "CURRENT_TIMESTAMP",
"value": 366
},
{
"name": "CURRENT_USER",
"value": 367
},
{
"name": "CURSOR",
"value": 368
},
{
"name": "CYCLE",
"value": 369
},
{
"name": "DATA_P",
"value": 370
},
{
"name": "DATABASE",
"value": 371
},
{
"name": "DAY_P",
"value": 372
},
{
"name": "DEALLOCATE",
"value": 373
},
{
"name": "DEC",
"value": 374
},
{
"name": "DECIMAL_P",
"value": 375
},
{
"name": "DECLARE",
"value": 376
},
{
"name": "DEFAULT",
"value": 377
},
{
"name": "DEFAULTS",
"value": 378
},
{
"name": "DEFERRABLE",
"value": 379
},
{
"name": "DEFERRED",
"value": 380
},
{
"name": "DEFINER",
"value": 381
},
{
"name": "DELETE_P",
"value": 382
},
{
"name": "DELIMITER",
"value": 383
},
{
"name": "DELIMITERS",
"value": 384
},
{
"name": "DEPENDS",
"value": 385
},
{
"name": "DEPTH",
"value": 386
},
{
"name": "DESC",
"value": 387
},
{
"name": "DETACH",
"value": 388
},
{
"name": "DICTIONARY",
"value": 389
},
{
"name": "DISABLE_P",
"value": 390
},
{
"name": "DISCARD",
"value": 391
},
{
"name": "DISTINCT",
"value": 392
},
{
"name": "DO",
"value": 393
},
{
"name": "DOCUMENT_P",
"value": 394
},
{
"name": "DOMAIN_P",
"value": 395
},
{
"name": "DOUBLE_P",
"value": 396
},
{
"name": "DROP",
"value": 397
},
{
"name": "EACH",
"value": 398
},
{
"name": "ELSE",
"value": 399
},
{
"name": "EMPTY_P",
"value": 400
},
{
"name": "ENABLE_P",
"value": 401
},
{
"name": "ENCODING",
"value": 402
},
{
"name": "ENCRYPTED",
"value": 403
},
{
"name": "END_P",
"value": 404
},
{
"name": "ENUM_P",
"value": 405
},
{
"name": "ERROR_P",
"value": 406
},
{
"name": "ESCAPE",
"value": 407
},
{
"name": "EVENT",
"value": 408
},
{
"name": "EXCEPT",
"value": 409
},
{
"name": "EXCLUDE",
"value": 410
},
{
"name": "EXCLUDING",
"value": 411
},
{
"name": "EXCLUSIVE",
"value": 412
},
{
"name": "EXECUTE",
"value": 413
},
{
"name": "EXISTS",
"value": 414
},
{
"name": "EXPLAIN",
"value": 415
},
{
"name": "EXPRESSION",
"value": 416
},
{
"name": "EXTENSION",
"value": 417
},
{
"name": "EXTERNAL",
"value": 418
},
{
"name": "EXTRACT",
"value": 419
},
{
"name": "FALSE_P",
"value": 420
},
{
"name": "FAMILY",
"value": 421
},
{
"name": "FETCH",
"value": 422
},
{
"name": "FILTER",
"value": 423
},
{
"name": "FINALIZE",
"value": 424
},
{
"name": "FIRST_P",
"value": 425
},
{
"name": "FLOAT_P",
"value": 426
},
{
"name": "FOLLOWING",
"value": 427
},
{
"name": "FOR",
"value": 428
},
{
"name": "FORCE",
"value": 429
},
{
"name": "FOREIGN",
"value": 430
},
{
"name": "FORMAT",
"value": 431
},
{
"name": "FORWARD",
"value": 432
},
{
"name": "FREEZE",
"value": 433
},
{
"name": "FROM",
"value": 434
},
{
"name": "FULL",
"value": 435
},
{
"name": "FUNCTION",
"value": 436
},
{
"name": "FUNCTIONS",
"value": 437
},
{
"name": "GENERATED",
"value": 438
},
{
"name": "GLOBAL",
"value": 439
},
{
"name": "GRANT",
"value": 440
},
{
"name": "GRANTED",
"value": 441
},
{
"name": "GREATEST",
"value": 442
},
{
"name": "GROUP_P",
"value": 443
},
{
"name": "GROUPING",
"value": 444
},
{
"name": "GROUPS",
"value": 445
},
{
"name": "HANDLER",
"value": 446
},
{
"name": "HAVING",
"value": 447
},
{
"name": "HEADER_P",
"value": 448
},
{
"name": "HOLD",
"value": 449
},
{
"name": "HOUR_P",
"value": 450
},
{
"name": "IDENTITY_P",
"value": 451
},
{
"name": "IF_P",
"value": 452
},
{
"name": "ILIKE",
"value": 453
},
{
"name": "IMMEDIATE",
"value": 454
},
{
"name": "IMMUTABLE",
"value": 455
},
{
"name": "IMPLICIT_P",
"value": 456
},
{
"name": "IMPORT_P",
"value": 457
},
{
"name": "IN_P",
"value": 458
},
{
"name": "INCLUDE",
"value": 459
},
{
"name": "INCLUDING",
"value": 460
},
{
"name": "INCREMENT",
"value": 461
},
{
"name": "INDENT",
"value": 462
},
{
"name": "INDEX",
"value": 463
},
{
"name": "INDEXES",
"value": 464
},
{
"name": "INHERIT",
"value": 465
},
{
"name": "INHERITS",
"value": 466
},
{
"name": "INITIALLY",
"value": 467
},
{
"name": "INLINE_P",
"value": 468
},
{
"name": "INNER_P",
"value": 469
},
{
"name": "INOUT",
"value": 470
},
{
"name": "INPUT_P",
"value": 471
},
{
"name": "INSENSITIVE",
"value": 472
},
{
"name": "INSERT",
"value": 473
},
{
"name": "INSTEAD",
"value": 474
},
{
"name": "INT_P",
"value": 475
},
{
"name": "INTEGER",
"value": 476
},
{
"name": "INTERSECT",
"value": 477
},
{
"name": "INTERVAL",
"value": 478
},
{
"name": "INTO",
"value": 479
},
{
"name": "INVOKER",
"value": 480
},
{
"name": "IS",
"value": 481
},
{
"name": "ISNULL",
"value": 482
},
{
"name": "ISOLATION",
"value": 483
},
{
"name": "JOIN",
"value": 484
},
{
"name": "JSON",
"value": 485
},
{
"name": "JSON_ARRAY",
"value": 486
},
{
"name": "JSON_ARRAYAGG",
"value": 487
},
{
"name": "JSON_EXISTS",
"value": 488
},
{
"name": "JSON_OBJECT",
"value": 489
},
{
"name": "JSON_OBJECTAGG",
"value": 490
},
{
"name": "JSON_QUERY",
"value": 491
},
{
"name": "JSON_SCALAR",
"value": 492
},
{
"name": "JSON_SERIALIZE",
"value": 493
},
{
"name": "JSON_TABLE",
"value": 494
},
{
"name": "JSON_VALUE",
"value": 495
},
{
"name": "KEEP",
"value": 496
},
{
"name": "KEY",
"value": 497
},
{
"name": "KEYS",
"value": 498
},
{
"name": "LABEL",
"value": 499
},
{
"name": "LANGUAGE",
"value": 500
},
{
"name": "LARGE_P",
"value": 501
},
{
"name": "LAST_P",
"value": 502
},
{
"name": "LATERAL_P",
"value": 503
},
{
"name": "LEADING",
"value": 504
},
{
"name": "LEAKPROOF",
"value": 505
},
{
"name": "LEAST",
"value": 506
},
{
"name": "LEFT",
"value": 507
},
{
"name": "LEVEL",
"value": 508
},
{
"name": "LIKE",
"value": 509
},
{
"name": "LIMIT",
"value": 510
},
{
"name": "LISTEN",
"value": 511
},
{
"name": "LOAD",
"value": 512
},
{
"name": "LOCAL",
"value": 513
},
{
"name": "LOCALTIME",
"value": 514
},
{
"name": "LOCALTIMESTAMP",
"value": 515
},
{
"name": "LOCATION",
"value": 516
},
{
"name": "LOCK_P",
"value": 517
},
{
"name": "LOCKED",
"value": 518
},
{
"name": "LOGGED",
"value": 519
},
{
"name": "MAPPING",
"value": 520
},
{
"name": "MATCH",
"value": 521
},
{
"name": "MATCHED",
"value": 522
},
{
"name": "MATERIALIZED",
"value": 523
},
{
"name": "MAXVALUE",
"value": 524
},
{
"name": "MERGE",
"value": 525
},
{
"name": "MERGE_ACTION",
"value": 526
},
{
"name": "METHOD",
"value": 527
},
{
"name": "MINUTE_P",
"value": 528
},
{
"name": "MINVALUE",
"value": 529
},
{
"name": "MODE",
"value": 530
},
{
"name": "MONTH_P",
"value": 531
},
{
"name": "MOVE",
"value": 532
},
{
"name": "NAME_P",
"value": 533
},
{
"name": "NAMES",
"value": 534
},
{
"name": "NATIONAL",
"value": 535
},
{
"name": "NATURAL",
"value": 536
},
{
"name": "NCHAR",
"value": 537
},
{
"name": "NESTED",
"value": 538
},
{
"name": "NEW",
"value": 539
},
{
"name": "NEXT",
"value": 540
},
{
"name": "NFC",
"value": 541
},
{
"name": "NFD",
"value": 542
},
{
"name": "NFKC",
"value": 543
},
{
"name": "NFKD",
"value": 544
},
{
"name": "NO",
"value": 545
},
{
"name": "NONE",
"value": 546
},
{
"name": "NORMALIZE",
"value": 547
},
{
"name": "NORMALIZED",
"value": 548
},
{
"name": "NOT",
"value": 549
},
{
"name": "NOTHING",
"value": 550
},
{
"name": "NOTIFY",
"value": 551
},
{
"name": "NOTNULL",
"value": 552
},
{
"name": "NOWAIT",
"value": 553
},
{
"name": "NULL_P",
"value": 554
},
{
"name": "NULLIF",
"value": 555
},
{
"name": "NULLS_P",
"value": 556
},
{
"name": "NUMERIC",
"value": 557
},
{
"name": "OBJECT_P",
"value": 558
},
{
"name": "OF",
"value": 559
},
{
"name": "OFF",
"value": 560
},
{
"name": "OFFSET",
"value": 561
},
{
"name": "OIDS",
"value": 562
},
{
"name": "OLD",
"value": 563
},
{
"name": "OMIT",
"value": 564
},
{
"name": "ON",
"value": 565
},
{
"name": "ONLY",
"value": 566
},
{
"name": "OPERATOR",
"value": 567
},
{
"name": "OPTION",
"value": 568
},
{
"name": "OPTIONS",
"value": 569
},
{
"name": "OR",
"value": 570
},
{
"name": "ORDER",
"value": 571
},
{
"name": "ORDINALITY",
"value": 572
},
{
"name": "OTHERS",
"value": 573
},
{
"name": "OUT_P",
"value": 574
},
{
"name": "OUTER_P",
"value": 575
},
{
"name": "OVER",
"value": 576
},
{
"name": "OVERLAPS",
"value": 577
},
{
"name": "OVERLAY",
"value": 578
},
{
"name": "OVERRIDING",
"value": 579
},
{
"name": "OWNED",
"value": 580
},
{
"name": "OWNER",
"value": 581
},
{
"name": "PARALLEL",
"value": 582
},
{
"name": "PARAMETER",
"value": 583
},
{
"name": "PARSER",
"value": 584
},
{
"name": "PARTIAL",
"value": 585
},
{
"name": "PARTITION",
"value": 586
},
{
"name": "PASSING",
"value": 587
},
{
"name": "PASSWORD",
"value": 588
},
{
"name": "PATH",
"value": 589
},
{
"name": "PLACING",
"value": 590
},
{
"name": "PLAN",
"value": 591
},
{
"name": "PLANS",
"value": 592
},
{
"name": "POLICY",
"value": 593
},
{
"name": "POSITION",
"value": 594
},
{
"name": "PRECEDING",
"value": 595
},
{
"name": "PRECISION",
"value": 596
},
{
"name": "PRESERVE",
"value": 597
},
{
"name": "PREPARE",
"value": 598
},
{
"name": "PREPARED",
"value": 599
},
{
"name": "PRIMARY",
"value": 600
},
{
"name": "PRIOR",
"value": 601
},
{
"name": "PRIVILEGES",
"value": 602
},
{
"name": "PROCEDURAL",
"value": 603
},
{
"name": "PROCEDURE",
"value": 604
},
{
"name": "PROCEDURES",
"value": 605
},
{
"name": "PROGRAM",
"value": 606
},
{
"name": "PUBLICATION",
"value": 607
},
{
"name": "QUOTE",
"value": 608
},
{
"name": "QUOTES",
"value": 609
},
{
"name": "RANGE",
"value": 610
},
{
"name": "READ",
"value": 611
},
{
"name": "REAL",
"value": 612
},
{
"name": "REASSIGN",
"value": 613
},
{
"name": "RECHECK",
"value": 614
},
{
"name": "RECURSIVE",
"value": 615
},
{
"name": "REF_P",
"value": 616
},
{
"name": "REFERENCES",
"value": 617
},
{
"name": "REFERENCING",
"value": 618
},
{
"name": "REFRESH",
"value": 619
},
{
"name": "REINDEX",
"value": 620
},
{
"name": "RELATIVE_P",
"value": 621
},
{
"name": "RELEASE",
"value": 622
},
{
"name": "RENAME",
"value": 623
},
{
"name": "REPEATABLE",
"value": 624
},
{
"name": "REPLACE",
"value": 625
},
{
"name": "REPLICA",
"value": 626
},
{
"name": "RESET",
"value": 627
},
{
"name": "RESTART",
"value": 628
},
{
"name": "RESTRICT",
"value": 629
},
{
"name": "RETURN",
"value": 630
},
{
"name": "RETURNING",
"value": 631
},
{
"name": "RETURNS",
"value": 632
},
{
"name": "REVOKE",
"value": 633
},
{
"name": "RIGHT",
"value": 634
},
{
"name": "ROLE",
"value": 635
},
{
"name": "ROLLBACK",
"value": 636
},
{
"name": "ROLLUP",
"value": 637
},
{
"name": "ROUTINE",
"value": 638
},
{
"name": "ROUTINES",
"value": 639
},
{
"name": "ROW",
"value": 640
},
{
"name": "ROWS",
"value": 641
},
{
"name": "RULE",
"value": 642
},
{
"name": "SAVEPOINT",
"value": 643
},
{
"name": "SCALAR",
"value": 644
},
{
"name": "SCHEMA",
"value": 645
},
{
"name": "SCHEMAS",
"value": 646
},
{
"name": "SCROLL",
"value": 647
},
{
"name": "SEARCH",
"value": 648
},
{
"name": "SECOND_P",
"value": 649
},
{
"name": "SECURITY",
"value": 650
},
{
"name": "SELECT",
"value": 651
},
{
"name": "SEQUENCE",
"value": 652
},
{
"name": "SEQUENCES",
"value": 653
},
{
"name": "SERIALIZABLE",
"value": 654
},
{
"name": "SERVER",
"value": 655
},
{
"name": "SESSION",
"value": 656
},
{
"name": "SESSION_USER",
"value": 657
},
{
"name": "SET",
"value": 658
},
{
"name": "SETS",
"value": 659
},
{
"name": "SETOF",
"value": 660
},
{
"name": "SHARE",
"value": 661
},
{
"name": "SHOW",
"value": 662
},
{
"name": "SIMILAR",
"value": 663
},
{
"name": "SIMPLE",
"value": 664
},
{
"name": "SKIP",
"value": 665
},
{
"name": "SMALLINT",
"value": 666
},
{
"name": "SNAPSHOT",
"value": 667
},
{
"name": "SOME",
"value": 668
},
{
"name": "SOURCE",
"value": 669
},
{
"name": "SQL_P",
"value": 670
},
{
"name": "STABLE",
"value": 671
},
{
"name": "STANDALONE_P",
"value": 672
},
{
"name": "START",
"value": 673
},
{
"name": "STATEMENT",
"value": 674
},
{
"name": "STATISTICS",
"value": 675
},
{
"name": "STDIN",
"value": 676
},
{
"name": "STDOUT",
"value": 677
},
{
"name": "STORAGE",
"value": 678
},
{
"name": "STORED",
"value": 679
},
{
"name": "STRICT_P",
"value": 680
},
{
"name": "STRING_P",
"value": 681
},
{
"name": "STRIP_P",
"value": 682
},
{
"name": "SUBSCRIPTION",
"value": 683
},
{
"name": "SUBSTRING",
"value": 684
},
{
"name": "SUPPORT",
"value": 685
},
{
"name": "SYMMETRIC",
"value": 686
},
{
"name": "SYSID",
"value": 687
},
{
"name": "SYSTEM_P",
"value": 688
},
{
"name": "SYSTEM_USER",
"value": 689
},
{
"name": "TABLE",
"value": 690
},
{
"name": "TABLES",
"value": 691
},
{
"name": "TABLESAMPLE",
"value": 692
},
{
"name": "TABLESPACE",
"value": 693
},
{
"name": "TARGET",
"value": 694
},
{
"name": "TEMP",
"value": 695
},
{
"name": "TEMPLATE",
"value": 696
},
{
"name": "TEMPORARY",
"value": 697
},
{
"name": "TEXT_P",
"value": 698
},
{
"name": "THEN",
"value": 699
},
{
"name": "TIES",
"value": 700
},
{
"name": "TIME",
"value": 701
},
{
"name": "TIMESTAMP",
"value": 702
},
{
"name": "TO",
"value": 703
},
{
"name": "TRAILING",
"value": 704
},
{
"name": "TRANSACTION",
"value": 705
},
{
"name": "TRANSFORM",
"value": 706
},
{
"name": "TREAT",
"value": 707
},
{
"name": "TRIGGER",
"value": 708
},
{
"name": "TRIM",
"value": 709
},
{
"name": "TRUE_P",
"value": 710
},
{
"name": "TRUNCATE",
"value": 711
},
{
"name": "TRUSTED",
"value": 712
},
{
"name": "TYPE_P",
"value": 713
},
{
"name": "TYPES_P",
"value": 714
},
{
"name": "UESCAPE",
"value": 715
},
{
"name": "UNBOUNDED",
"value": 716
},
{
"name": "UNCONDITIONAL",
"value": 717
},
{
"name": "UNCOMMITTED",
"value": 718
},
{
"name": "UNENCRYPTED",
"value": 719
},
{
"name": "UNION",
"value": 720
},
{
"name": "UNIQUE",
"value": 721
},
{
"name": "UNKNOWN",
"value": 722
},
{
"name": "UNLISTEN",
"value": 723
},
{
"name": "UNLOGGED",
"value": 724
},
{
"name": "UNTIL",
"value": 725
},
{
"name": "UPDATE",
"value": 726
},
{
"name": "USER",
"value": 727
},
{
"name": "USING",
"value": 728
},
{
"name": "VACUUM",
"value": 729
},
{
"name": "VALID",
"value": 730
},
{
"name": "VALIDATE",
"value": 731
},
{
"name": "VALIDATOR",
"value": 732
},
{
"name": "VALUE_P",
"value": 733
},
{
"name": "VALUES",
"value": 734
},
{
"name": "VARCHAR",
"value": 735
},
{
"name": "VARIADIC",
"value": 736
},
{
"name": "VARYING",
"value": 737
},
{
"name": "VERBOSE",
"value": 738
},
{
"name": "VERSION_P",
"value": 739
},
{
"name": "VIEW",
"value": 740
},
{
"name": "VIEWS",
"value": 741
},
{
"name": "VOLATILE",
"value": 742
},
{
"name": "WHEN",
"value": 743
},
{
"name": "WHERE",
"value": 744
},
{
"name": "WHITESPACE_P",
"value": 745
},
{
"name": "WINDOW",
"value": 746
},
{
"name": "WITH",
"value": 747
},
{
"name": "WITHIN",
"value": 748
},
{
"name": "WITHOUT",
"value": 749
},
{
"name": "WORK",
"value": 750
},
{
"name": "WRAPPER",
"value": 751
},
{
"name": "WRITE",
"value": 752
},
{
"name": "XML_P",
"value": 753
},
{
"name": "XMLATTRIBUTES",
"value": 754
},
{
"name": "XMLCONCAT",
"value": 755
},
{
"name": "XMLELEMENT",
"value": 756
},
{
"name": "XMLEXISTS",
"value": 757
},
{
"name": "XMLFOREST",
"value": 758
},
{
"name": "XMLNAMESPACES",
"value": 759
},
{
"name": "XMLPARSE",
"value": 760
},
{
"name": "XMLPI",
"value": 761
},
{
"name": "XMLROOT",
"value": 762
},
{
"name": "XMLSERIALIZE",
"value": 763
},
{
"name": "XMLTABLE",
"value": 764
},
{
"name": "YEAR_P",
"value": 765
},
{
"name": "YES_P",
"value": 766
},
{
"name": "ZONE",
"value": 767
},
{
"name": "FORMAT_LA",
"value": 768
},
{
"name": "NOT_LA",
"value": 769
},
{
"name": "NULLS_LA",
"value": 770
},
{
"name": "WITH_LA",
"value": 771
},
{
"name": "WITHOUT_LA",
"value": 772
},
{
"name": "MODE_TYPE_NAME",
"value": 773
},
{
"name": "MODE_PLPGSQL_EXPR",
"value": 774
},
{
"name": "MODE_PLPGSQL_ASSIGN1",
"value": 775
},
{
"name": "MODE_PLPGSQL_ASSIGN2",
"value": 776
},
{
"name": "MODE_PLPGSQL_ASSIGN3",
"value": 777
},
{
"name": "UMINUS",
"value": 778
}
],
"comment": " /* Put the tokens into the symbol table, so that GDB and other debuggers\n know about them. */\n"
}
},
"../backend/parser/gramparse": {
}
}