{
"nodes/parsenodes": {
"Query": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "commandType",
"c_type": "CmdType",
"comment": "/* select|insert|update|delete|merge|utility */"
},
{
"comment": ""
},
{
"comment": "\t/* where did I come from? */\n"
},
{
"name": "querySource",
"c_type": "QuerySource",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * query identifier (can be set by plugins); ignored for equal, as it\n\t * might not be set; also not stored. This is the result of the query\n\t * jumble, hence ignored.\n\t */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* do I set the command result tag? */\n"
},
{
"name": "canSetTag",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"name": "utilityStmt",
"c_type": "Node*",
"comment": "/* non-null if commandType == CMD_UTILITY */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * rtable index of target relation for INSERT/UPDATE/DELETE/MERGE; 0 for\n\t * SELECT. This is ignored in the query jumble as unrelated to the\n\t * compilation of the query ID.\n\t */\n"
},
{
"name": "resultRelation",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* has aggregates in tlist or havingQual */\n"
},
{
"name": "hasAggs",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* has window functions in tlist */\n"
},
{
"name": "hasWindowFuncs",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* has set-returning functions in tlist */\n"
},
{
"name": "hasTargetSRFs",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* has subquery SubLink */\n"
},
{
"name": "hasSubLinks",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* distinctClause is from DISTINCT ON */\n"
},
{
"name": "hasDistinctOn",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* WITH RECURSIVE was specified */\n"
},
{
"name": "hasRecursive",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* has INSERT/UPDATE/DELETE/MERGE in WITH */\n"
},
{
"name": "hasModifyingCTE",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* FOR [KEY] UPDATE/SHARE was specified */\n"
},
{
"name": "hasForUpdate",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* rewriter has applied some RLS policy */\n"
},
{
"name": "hasRowSecurity",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* is a RETURN statement */\n"
},
{
"name": "isReturn",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"name": "cteList",
"c_type": "List*",
"comment": "/* WITH list (of CommonTableExpr's) */"
},
{
"comment": ""
},
{
"name": "rtable",
"c_type": "List*",
"comment": "/* list of range table entries */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * list of RTEPermissionInfo nodes for the rtable entries having\n\t * perminfoindex > 0\n\t */\n"
},
{
"name": "rteperminfos",
"c_type": "List*",
"comment": null
},
{
"name": "jointree",
"c_type": "FromExpr*",
"comment": "/* table join tree (FROM and WHERE clauses);\n\t\t\t\t\t\t\t\t * also USING clause for MERGE */\n"
},
{
"comment": ""
},
{
"name": "mergeActionList",
"c_type": "List*",
"comment": "/* list of actions for MERGE (only) */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * rtable index of target relation for MERGE to pull data. Initially, this\n\t * is the same as resultRelation, but after query rewriting, if the target\n\t * relation is a trigger-updatable view, this is the index of the expanded\n\t * view subquery, whereas resultRelation is the index of the target view.\n\t */\n"
},
{
"name": "mergeTargetRelation",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* join condition between source and target for MERGE */\n"
},
{
"name": "mergeJoinCondition",
"c_type": "Node*",
"comment": null
},
{
"comment": ""
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* target list (of TargetEntry) */"
},
{
"comment": ""
},
{
"comment": "\t/* OVERRIDING clause */\n"
},
{
"name": "override",
"c_type": "OverridingKind",
"comment": null
},
{
"comment": ""
},
{
"name": "onConflict",
"c_type": "OnConflictExpr*",
"comment": "/* ON CONFLICT DO [NOTHING | UPDATE] */"
},
{
"comment": ""
},
{
"name": "returningList",
"c_type": "List*",
"comment": "/* return-values list (of TargetEntry) */"
},
{
"comment": ""
},
{
"name": "groupClause",
"c_type": "List*",
"comment": "/* a list of SortGroupClause's */"
},
{
"name": "groupDistinct",
"c_type": "bool",
"comment": "/* is the group by clause distinct? */"
},
{
"comment": ""
},
{
"name": "groupingSets",
"c_type": "List*",
"comment": "/* a list of GroupingSet's if present */"
},
{
"comment": ""
},
{
"name": "havingQual",
"c_type": "Node*",
"comment": "/* qualifications applied to groups */"
},
{
"comment": ""
},
{
"name": "windowClause",
"c_type": "List*",
"comment": "/* a list of WindowClause's */"
},
{
"comment": ""
},
{
"name": "distinctClause",
"c_type": "List*",
"comment": "/* a list of SortGroupClause's */"
},
{
"comment": ""
},
{
"name": "sortClause",
"c_type": "List*",
"comment": "/* a list of SortGroupClause's */"
},
{
"comment": ""
},
{
"name": "limitOffset",
"c_type": "Node*",
"comment": "/* # of result tuples to skip (int8 expr) */"
},
{
"name": "limitCount",
"c_type": "Node*",
"comment": "/* # of result tuples to return (int8 expr) */"
},
{
"name": "limitOption",
"c_type": "LimitOption",
"comment": "/* limit type */"
},
{
"comment": ""
},
{
"name": "rowMarks",
"c_type": "List*",
"comment": "/* a list of RowMarkClause's */"
},
{
"comment": ""
},
{
"name": "setOperations",
"c_type": "Node*",
"comment": "/* set-operation tree if this is top level of\n\t\t\t\t\t\t\t\t * a UNION/INTERSECT/EXCEPT query */\n"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * A list of pg_constraint OIDs that the query depends on to be\n\t * semantically valid\n\t */\n"
},
{
"name": "constraintDeps",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* a list of WithCheckOption's (added during rewrite) */\n"
},
{
"name": "withCheckOptions",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * The following two fields identify the portion of the source text string\n\t * containing this query. They are typically only populated in top-level\n\t * Queries, not in sub-queries. When not set, they might both be zero, or\n\t * both be -1 meaning \"unknown\".\n\t */\n"
},
{
"comment": "\t/* start location, or -1 if unknown */\n"
},
{
"name": "stmt_location",
"c_type": "ParseLoc",
"comment": null
},
{
"comment": "\t/* length in bytes; 0 means \"rest of string\" */\n"
},
{
"name": "stmt_len",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * Query -\n *\t Parse analysis turns all statements into a Query tree\n *\t for further processing by the rewriter and planner.\n *\n *\t Utility statements (i.e. non-optimizable statements) have the\n *\t utilityStmt field set, and the rest of the Query is mostly dummy.\n *\n *\t Planning converts a Query tree into a Plan tree headed by a PlannedStmt\n *\t node --- the Query structure is not used by the executor.\n *\n *\t All the fields ignored for the query jumbling are not semantically\n *\t significant (such as alias names), as is ignored anything that can\n *\t be deduced from child nodes (else we'd just be double-hashing that\n *\t piece of information).\n */\n"
},
"TypeName": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "names",
"c_type": "List*",
"comment": "/* qualified name (list of String nodes) */"
},
{
"name": "typeOid",
"c_type": "Oid",
"comment": "/* type identified by OID */"
},
{
"name": "setof",
"c_type": "bool",
"comment": "/* is a set? */"
},
{
"name": "pct_type",
"c_type": "bool",
"comment": "/* %TYPE specified? */"
},
{
"name": "typmods",
"c_type": "List*",
"comment": "/* type modifier expression(s) */"
},
{
"name": "typemod",
"c_type": "int32",
"comment": "/* prespecified type modifier */"
},
{
"name": "arrayBounds",
"c_type": "List*",
"comment": "/* array bounds */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * TypeName - specifies a type in definitions\n *\n * For TypeName structures generated internally, it is often easier to\n * specify the type by OID than by name. If \"names\" is NIL then the\n * actual type OID is given by typeOid, otherwise typeOid is unused.\n * Similarly, if \"typmods\" is NIL then the actual typmod is expected to\n * be prespecified in typemod, otherwise typemod is unused.\n *\n * If pct_type is true, then names is actually a field name and we look up\n * the type of that field. Otherwise (the normal case), names is a type\n * name possibly qualified with schema and database name.\n */\n"
},
"ColumnRef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "fields",
"c_type": "List*",
"comment": "/* field names (String nodes) or A_Star */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * ColumnRef - specifies a reference to a column, or possibly a whole tuple\n *\n * The \"fields\" list must be nonempty. It can contain String nodes\n * (representing names) and A_Star nodes (representing occurrence of a '*').\n * Currently, A_Star must appear only as the last list element --- the grammar\n * is responsible for enforcing this!\n *\n * Note: any container subscripting or selection of fields from composite columns\n * is represented by an A_Indirection node above the ColumnRef. However,\n * for simplicity in the normal case, initial field selection from a table\n * name is represented within ColumnRef and not by adding A_Indirection.\n */\n"
},
"ParamRef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "number",
"c_type": "int",
"comment": "/* the number of the parameter */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * ParamRef - specifies a $n parameter reference\n */\n"
},
"A_Expr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "A_Expr_Kind",
"comment": "/* see above */"
},
{
"name": "name",
"c_type": "List*",
"comment": "/* possibly-qualified name of operator */"
},
{
"name": "lexpr",
"c_type": "Node*",
"comment": "/* left argument, or NULL if none */"
},
{
"name": "rexpr",
"c_type": "Node*",
"comment": "/* right argument, or NULL if none */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * A_Expr - infix, prefix, and postfix expressions\n */\n"
},
"TypeCast": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "arg",
"c_type": "Node*",
"comment": "/* the expression being casted */"
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* the target type */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * TypeCast - a CAST expression\n */\n"
},
"CollateClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "arg",
"c_type": "Node*",
"comment": "/* input expression */"
},
{
"name": "collname",
"c_type": "List*",
"comment": "/* possibly-qualified collation name */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * CollateClause - a COLLATE expression\n */\n"
},
"RoleSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "roletype",
"c_type": "RoleSpecType",
"comment": "/* Type of this rolespec */"
},
{
"name": "rolename",
"c_type": "char*",
"comment": "/* filled only for ROLESPEC_CSTRING */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": null
},
"FuncCall": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "funcname",
"c_type": "List*",
"comment": "/* qualified name of function */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* the arguments (list of exprs) */"
},
{
"name": "agg_order",
"c_type": "List*",
"comment": "/* ORDER BY (list of SortBy) */"
},
{
"name": "agg_filter",
"c_type": "Node*",
"comment": "/* FILTER clause, if any */"
},
{
"name": "over",
"c_type": "WindowDef*",
"comment": "/* OVER clause, if any */"
},
{
"name": "agg_within_group",
"c_type": "bool",
"comment": "/* ORDER BY appeared in WITHIN GROUP */"
},
{
"name": "agg_star",
"c_type": "bool",
"comment": "/* argument was really '*' */"
},
{
"name": "agg_distinct",
"c_type": "bool",
"comment": "/* arguments were labeled DISTINCT */"
},
{
"name": "func_variadic",
"c_type": "bool",
"comment": "/* last argument was labeled VARIADIC */"
},
{
"name": "funcformat",
"c_type": "CoercionForm",
"comment": "/* how to display this node */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * FuncCall - a function or aggregate invocation\n *\n * agg_order (if not NIL) indicates we saw 'foo(... ORDER BY ...)', or if\n * agg_within_group is true, it was 'foo(...) WITHIN GROUP (ORDER BY ...)'.\n * agg_star indicates we saw a 'foo(*)' construct, while agg_distinct\n * indicates we saw 'foo(DISTINCT ...)'. In any of these cases, the\n * construct *must* be an aggregate call. Otherwise, it might be either an\n * aggregate or some other kind of function. However, if FILTER or OVER is\n * present it had better be an aggregate or window function.\n *\n * Normally, you'd initialize this via makeFuncCall() and then only change the\n * parts of the struct its defaults don't match afterwards, as needed.\n */\n"
},
"A_Star": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
}
],
"comment": "/*\n * A_Star - '*' representing all columns of a table or compound field\n *\n * This can appear within ColumnRef.fields, A_Indirection.indirection, and\n * ResTarget.indirection lists.\n */\n"
},
"A_Indices": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "is_slice",
"c_type": "bool",
"comment": "/* true if slice (i.e., colon present) */"
},
{
"name": "lidx",
"c_type": "Node*",
"comment": "/* slice lower bound, if any */"
},
{
"name": "uidx",
"c_type": "Node*",
"comment": "/* subscript, or slice upper bound if any */"
}
],
"comment": "/*\n * A_Indices - array subscript or slice bounds ([idx] or [lidx:uidx])\n *\n * In slice case, either or both of lidx and uidx can be NULL (omitted).\n * In non-slice case, uidx holds the single subscript and lidx is always NULL.\n */\n"
},
"A_Indirection": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "arg",
"c_type": "Node*",
"comment": "/* the thing being selected from */"
},
{
"name": "indirection",
"c_type": "List*",
"comment": "/* subscripts and/or field names and/or * */"
}
],
"comment": "/*\n * A_Indirection - select a field and/or array element from an expression\n *\n * The indirection list can contain A_Indices nodes (representing\n * subscripting), String nodes (representing field selection --- the\n * string value is the name of the field to select), and A_Star nodes\n * (representing selection of all fields of a composite type).\n * For example, a complex selection operation like\n *\t\t\t\t(foo).field1[42][7].field2\n * would be represented with a single A_Indirection node having a 4-element\n * indirection list.\n *\n * Currently, A_Star must appear only as the last list element --- the grammar\n * is responsible for enforcing this!\n */\n"
},
"A_ArrayExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "elements",
"c_type": "List*",
"comment": "/* array element expressions */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * A_ArrayExpr - an ARRAY[] construct\n */\n"
},
"ResTarget": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* column name or NULL */"
},
{
"name": "indirection",
"c_type": "List*",
"comment": "/* subscripts, field names, and '*', or NIL */"
},
{
"name": "val",
"c_type": "Node*",
"comment": "/* the value expression to compute or assign */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * ResTarget -\n *\t result target (used in target list of pre-transformed parse trees)\n *\n * In a SELECT target list, 'name' is the column label from an\n * 'AS ColumnLabel' clause, or NULL if there was none, and 'val' is the\n * value expression itself. The 'indirection' field is not used.\n *\n * INSERT uses ResTarget in its target-column-names list. Here, 'name' is\n * the name of the destination column, 'indirection' stores any subscripts\n * attached to the destination, and 'val' is not used.\n *\n * In an UPDATE target list, 'name' is the name of the destination column,\n * 'indirection' stores any subscripts attached to the destination, and\n * 'val' is the expression to assign.\n *\n * See A_Indirection for more info about what can appear in 'indirection'.\n */\n"
},
"MultiAssignRef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "source",
"c_type": "Node*",
"comment": "/* the row-valued expression */"
},
{
"name": "colno",
"c_type": "int",
"comment": "/* column number for this target (1..n) */"
},
{
"name": "ncolumns",
"c_type": "int",
"comment": "/* number of targets in the construct */"
}
],
"comment": "/*\n * MultiAssignRef - element of a row source expression for UPDATE\n *\n * In an UPDATE target list, when we have SET (a,b,c) = row-valued-expression,\n * we generate separate ResTarget items for each of a,b,c. Their \"val\" trees\n * are MultiAssignRef nodes numbered 1..n, linking to a common copy of the\n * row-valued-expression (which parse analysis will process only once, when\n * handling the MultiAssignRef with colno=1).\n */\n"
},
"SortBy": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "node",
"c_type": "Node*",
"comment": "/* expression to sort on */"
},
{
"name": "sortby_dir",
"c_type": "SortByDir",
"comment": "/* ASC/DESC/USING/default */"
},
{
"name": "sortby_nulls",
"c_type": "SortByNulls",
"comment": "/* NULLS FIRST/LAST */"
},
{
"name": "useOp",
"c_type": "List*",
"comment": "/* name of op to use, if SORTBY_USING */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* operator location, or -1 if none/unknown */"
}
],
"comment": "/*\n * SortBy - for ORDER BY clause\n */\n"
},
"WindowDef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* window's own name */"
},
{
"name": "refname",
"c_type": "char*",
"comment": "/* referenced window name, if any */"
},
{
"name": "partitionClause",
"c_type": "List*",
"comment": "/* PARTITION BY expression list */"
},
{
"name": "orderClause",
"c_type": "List*",
"comment": "/* ORDER BY (list of SortBy) */"
},
{
"name": "frameOptions",
"c_type": "int",
"comment": "/* frame_clause options, see below */"
},
{
"name": "startOffset",
"c_type": "Node*",
"comment": "/* expression for starting bound, if any */"
},
{
"name": "endOffset",
"c_type": "Node*",
"comment": "/* expression for ending bound, if any */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* parse location, or -1 if none/unknown */"
}
],
"comment": "/*\n * WindowDef - raw representation of WINDOW and OVER clauses\n *\n * For entries in a WINDOW list, \"name\" is the window name being defined.\n * For OVER clauses, we use \"name\" for the \"OVER window\" syntax, or \"refname\"\n * for the \"OVER (window)\" syntax, which is subtly different --- the latter\n * implies overriding the window frame clause.\n */\n"
},
"RangeSubselect": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "lateral",
"c_type": "bool",
"comment": "/* does it have LATERAL prefix? */"
},
{
"name": "subquery",
"c_type": "Node*",
"comment": "/* the untransformed sub-select clause */"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": "/* table alias & optional column aliases */"
}
],
"comment": "/*\n * RangeSubselect - subquery appearing in a FROM clause\n */\n"
},
"RangeFunction": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "lateral",
"c_type": "bool",
"comment": "/* does it have LATERAL prefix? */"
},
{
"name": "ordinality",
"c_type": "bool",
"comment": "/* does it have WITH ORDINALITY suffix? */"
},
{
"name": "is_rowsfrom",
"c_type": "bool",
"comment": "/* is result of ROWS FROM() syntax? */"
},
{
"name": "functions",
"c_type": "List*",
"comment": "/* per-function information, see above */"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": "/* table alias & optional column aliases */"
},
{
"name": "coldeflist",
"c_type": "List*",
"comment": "/* list of ColumnDef nodes to describe result\n\t\t\t\t\t\t\t\t * of function returning RECORD */\n"
}
],
"comment": "/*\n * RangeFunction - function call appearing in a FROM clause\n *\n * functions is a List because we use this to represent the construct\n * ROWS FROM(func1(...), func2(...), ...). Each element of this list is a\n * two-element sublist, the first element being the untransformed function\n * call tree, and the second element being a possibly-empty list of ColumnDef\n * nodes representing any columndef list attached to that function within the\n * ROWS FROM() syntax.\n *\n * alias and coldeflist represent any alias and/or columndef list attached\n * at the top level. (We disallow coldeflist appearing both here and\n * per-function, but that's checked in parse analysis, not by the grammar.)\n */\n"
},
"RangeTableFunc": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "lateral",
"c_type": "bool",
"comment": "/* does it have LATERAL prefix? */"
},
{
"name": "docexpr",
"c_type": "Node*",
"comment": "/* document expression */"
},
{
"name": "rowexpr",
"c_type": "Node*",
"comment": "/* row generator expression */"
},
{
"name": "namespaces",
"c_type": "List*",
"comment": "/* list of namespaces as ResTarget */"
},
{
"name": "columns",
"c_type": "List*",
"comment": "/* list of RangeTableFuncCol */"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": "/* table alias & optional column aliases */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * RangeTableFunc - raw form of \"table functions\" such as XMLTABLE\n *\n * Note: JSON_TABLE is also a \"table function\", but it uses JsonTable node,\n * not RangeTableFunc.\n */\n"
},
"RangeTableFuncCol": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "colname",
"c_type": "char*",
"comment": "/* name of generated column */"
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* type of generated column */"
},
{
"name": "for_ordinality",
"c_type": "bool",
"comment": "/* does it have FOR ORDINALITY? */"
},
{
"name": "is_not_null",
"c_type": "bool",
"comment": "/* does it have NOT NULL? */"
},
{
"name": "colexpr",
"c_type": "Node*",
"comment": "/* column filter expression */"
},
{
"name": "coldefexpr",
"c_type": "Node*",
"comment": "/* column default value expression */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * RangeTableFuncCol - one column in a RangeTableFunc->columns\n *\n * If for_ordinality is true (FOR ORDINALITY), then the column is an int4\n * column and the rest of the fields are ignored.\n */\n"
},
"RangeTableSample": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "Node*",
"comment": "/* relation to be sampled */"
},
{
"name": "method",
"c_type": "List*",
"comment": "/* sampling method name (possibly qualified) */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* argument(s) for sampling method */"
},
{
"name": "repeatable",
"c_type": "Node*",
"comment": "/* REPEATABLE expression, or NULL if none */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* method name location, or -1 if unknown */"
}
],
"comment": "/*\n * RangeTableSample - TABLESAMPLE appearing in a raw FROM clause\n *\n * This node, appearing only in raw parse trees, represents\n *\t\t<relation> TABLESAMPLE <method> (<params>) REPEATABLE (<num>)\n * Currently, the <relation> can only be a RangeVar, but we might in future\n * allow RangeSubselect and other options. Note that the RangeTableSample\n * is wrapped around the node representing the <relation>, rather than being\n * a subfield of it.\n */\n"
},
"ColumnDef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "colname",
"c_type": "char*",
"comment": "/* name of column */"
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* type of column */"
},
{
"name": "compression",
"c_type": "char*",
"comment": "/* compression method for column */"
},
{
"name": "inhcount",
"c_type": "int",
"comment": "/* number of times column is inherited */"
},
{
"name": "is_local",
"c_type": "bool",
"comment": "/* column has local (non-inherited) def'n */"
},
{
"name": "is_not_null",
"c_type": "bool",
"comment": "/* NOT NULL constraint specified? */"
},
{
"name": "is_from_type",
"c_type": "bool",
"comment": "/* column definition came from table type */"
},
{
"name": "storage",
"c_type": "char",
"comment": "/* attstorage setting, or 0 for default */"
},
{
"name": "storage_name",
"c_type": "char*",
"comment": "/* attstorage setting name or NULL for default */"
},
{
"name": "raw_default",
"c_type": "Node*",
"comment": "/* default value (untransformed parse tree) */"
},
{
"name": "cooked_default",
"c_type": "Node*",
"comment": "/* default value (transformed expr tree) */"
},
{
"name": "identity",
"c_type": "char",
"comment": "/* attidentity setting */"
},
{
"name": "identitySequence",
"c_type": "RangeVar*",
"comment": "/* to store identity sequence name for\n\t\t\t\t\t\t\t\t\t * ALTER TABLE ... ADD COLUMN */\n"
},
{
"name": "generated",
"c_type": "char",
"comment": "/* attgenerated setting */"
},
{
"name": "collClause",
"c_type": "CollateClause*",
"comment": "/* untransformed COLLATE spec, if any */"
},
{
"name": "collOid",
"c_type": "Oid",
"comment": "/* collation OID (InvalidOid if not set) */"
},
{
"name": "constraints",
"c_type": "List*",
"comment": "/* other constraints on column */"
},
{
"name": "fdwoptions",
"c_type": "List*",
"comment": "/* per-column FDW options */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* parse location, or -1 if none/unknown */"
}
],
"comment": "/*\n * ColumnDef - column definition (used in various creates)\n *\n * If the column has a default value, we may have the value expression\n * in either \"raw\" form (an untransformed parse tree) or \"cooked\" form\n * (a post-parse-analysis, executable expression tree), depending on\n * how this ColumnDef node was created (by parsing, or by inheritance\n * from an existing relation). We should never have both in the same node!\n *\n * Similarly, we may have a COLLATE specification in either raw form\n * (represented as a CollateClause with arg==NULL) or cooked form\n * (the collation's OID).\n *\n * The constraints list may contain a CONSTR_DEFAULT item in a raw\n * parsetree produced by gram.y, but transformCreateStmt will remove\n * the item and set raw_default instead. CONSTR_DEFAULT items\n * should not appear in any subsequent processing.\n */\n"
},
"TableLikeClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": null
},
{
"name": "options",
"c_type": "bits32",
"comment": "/* OR of TableLikeOption flags */"
},
{
"name": "relationOid",
"c_type": "Oid",
"comment": "/* If table has been looked up, its OID */"
}
],
"comment": "/*\n * TableLikeClause - CREATE TABLE ( ... LIKE ... ) clause\n */\n"
},
"IndexElem": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* name of attribute to index, or NULL */"
},
{
"name": "expr",
"c_type": "Node*",
"comment": "/* expression to index, or NULL */"
},
{
"name": "indexcolname",
"c_type": "char*",
"comment": "/* name for index column; NULL = default */"
},
{
"name": "collation",
"c_type": "List*",
"comment": "/* name of collation; NIL = default */"
},
{
"name": "opclass",
"c_type": "List*",
"comment": "/* name of desired opclass; NIL = default */"
},
{
"name": "opclassopts",
"c_type": "List*",
"comment": "/* opclass-specific options, or NIL */"
},
{
"name": "ordering",
"c_type": "SortByDir",
"comment": "/* ASC/DESC/default */"
},
{
"name": "nulls_ordering",
"c_type": "SortByNulls",
"comment": "/* FIRST/LAST/default */"
}
],
"comment": "/*\n * IndexElem - index parameters (used in CREATE INDEX, and in ON CONFLICT)\n *\n * For a plain index attribute, 'name' is the name of the table column to\n * index, and 'expr' is NULL. For an index expression, 'name' is NULL and\n * 'expr' is the expression tree.\n */\n"
},
"DefElem": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "defnamespace",
"c_type": "char*",
"comment": "/* NULL if unqualified name */"
},
{
"name": "defname",
"c_type": "char*",
"comment": null
},
{
"name": "arg",
"c_type": "Node*",
"comment": "/* typically Integer, Float, String, or\n\t\t\t\t\t\t\t\t * TypeName */\n"
},
{
"name": "defaction",
"c_type": "DefElemAction",
"comment": "/* unspecified action, or SET/ADD/DROP */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"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"
},
"LockingClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "lockedRels",
"c_type": "List*",
"comment": "/* FOR [KEY] UPDATE/SHARE relations */"
},
{
"name": "strength",
"c_type": "LockClauseStrength",
"comment": null
},
{
"name": "waitPolicy",
"c_type": "LockWaitPolicy",
"comment": "/* NOWAIT and SKIP LOCKED */"
}
],
"comment": "/*\n * LockingClause - raw representation of FOR [NO KEY] UPDATE/[KEY] SHARE\n *\t\toptions\n *\n * Note: lockedRels == NIL means \"all relations in query\". Otherwise it\n * is a list of RangeVar nodes. (We use RangeVar mainly because it carries\n * a location field --- currently, parse analysis insists on unqualified\n * names in LockingClause.)\n */\n"
},
"XmlSerialize": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "xmloption",
"c_type": "XmlOptionType",
"comment": "/* DOCUMENT or CONTENT */"
},
{
"name": "expr",
"c_type": "Node*",
"comment": null
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": null
},
{
"name": "indent",
"c_type": "bool",
"comment": "/* [NO] INDENT */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * XMLSERIALIZE (in raw parse tree only)\n */\n"
},
"PartitionElem": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* name of column to partition on, or NULL */"
},
{
"name": "expr",
"c_type": "Node*",
"comment": "/* expression to partition on, or NULL */"
},
{
"name": "collation",
"c_type": "List*",
"comment": "/* name of collation; NIL = default */"
},
{
"name": "opclass",
"c_type": "List*",
"comment": "/* name of desired opclass; NIL = default */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * PartitionElem - parse-time representation of a single partition key\n *\n * expr can be either a raw expression tree or a parse-analyzed expression.\n * We don't store these on-disk, though.\n */\n"
},
"PartitionSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "strategy",
"c_type": "PartitionStrategy",
"comment": null
},
{
"name": "partParams",
"c_type": "List*",
"comment": "/* List of PartitionElems */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * PartitionSpec - parse-time representation of a partition key specification\n *\n * This represents the key space we will be partitioning on.\n */\n"
},
"PartitionBoundSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "strategy",
"c_type": "char",
"comment": "/* see PARTITION_STRATEGY codes above */"
},
{
"name": "is_default",
"c_type": "bool",
"comment": "/* is it a default partition bound? */"
},
{
"comment": ""
},
{
"comment": "\t/* Partitioning info for HASH strategy: */\n"
},
{
"name": "modulus",
"c_type": "int",
"comment": null
},
{
"name": "remainder",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Partitioning info for LIST strategy: */\n"
},
{
"name": "listdatums",
"c_type": "List*",
"comment": "/* List of Consts (or A_Consts in raw tree) */"
},
{
"comment": ""
},
{
"comment": "\t/* Partitioning info for RANGE strategy: */\n"
},
{
"name": "lowerdatums",
"c_type": "List*",
"comment": "/* List of PartitionRangeDatums */"
},
{
"name": "upperdatums",
"c_type": "List*",
"comment": "/* List of PartitionRangeDatums */"
},
{
"comment": ""
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * PartitionBoundSpec - a partition bound specification\n *\n * This represents the portion of the partition key space assigned to a\n * particular partition. These are stored on disk in pg_class.relpartbound.\n */\n"
},
"PartitionRangeDatum": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "kind",
"c_type": "PartitionRangeDatumKind",
"comment": null
},
{
"name": "value",
"c_type": "Node*",
"comment": "/* Const (or A_Const in raw tree), if kind is\n\t\t\t\t\t\t\t\t * PARTITION_RANGE_DATUM_VALUE, else NULL */\n"
},
{
"comment": ""
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": null
},
"SinglePartitionSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
}
],
"comment": "/*\n * PartitionDesc - used in reverted ALTER TABLE SPLIT PARTITION command\n *\n * Kept as a stub for nodetag ABI compatibility.\n */\n"
},
"PartitionCmd": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "RangeVar*",
"comment": "/* name of partition to attach/detach */"
},
{
"name": "bound",
"c_type": "PartitionBoundSpec*",
"comment": "/* FOR VALUES, if attaching */"
},
{
"name": "concurrent",
"c_type": "bool",
"comment": null
}
],
"comment": "/*\n * PartitionCmd - info for ALTER TABLE/INDEX ATTACH/DETACH PARTITION commands\n */\n"
},
"RangeTblEntry": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid in all RTEs:\n\t *\n\t * put alias + eref first to make dump more legible\n\t */\n"
},
{
"comment": "\t/* user-written alias clause, if any */\n"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": null
},
{
"comment": "\t/* expanded reference names */\n"
},
{
"name": "eref",
"c_type": "Alias*",
"comment": null
},
{
"comment": ""
},
{
"name": "rtekind",
"c_type": "RTEKind",
"comment": "/* see above */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a plain relation RTE (else zero):\n\t *\n\t * inh is true for relation references that should be expanded to include\n\t * inheritance children, if the rel has any. In the parser, this will\n\t * only be true for RTE_RELATION entries. The planner also uses this\n\t * field to mark RTE_SUBQUERY entries that contain UNION ALL queries that\n\t * it has flattened into pulled-up subqueries (creating a structure much\n\t * like the effects of inheritance).\n\t *\n\t * rellockmode is really LOCKMODE, but it's declared int to avoid having\n\t * to include lock-related headers here. It must be RowExclusiveLock if\n\t * the RTE is an INSERT/UPDATE/DELETE/MERGE target, else RowShareLock if\n\t * the RTE is a SELECT FOR UPDATE/FOR SHARE target, else AccessShareLock.\n\t *\n\t * Note: in some cases, rule expansion may result in RTEs that are marked\n\t * with RowExclusiveLock even though they are not the target of the\n\t * current query; this happens if a DO ALSO rule simply scans the original\n\t * target table. We leave such RTEs with their original lockmode so as to\n\t * avoid getting an additional, lesser lock.\n\t *\n\t * perminfoindex is 1-based index of the RTEPermissionInfo belonging to\n\t * this RTE in the containing struct's list of same; 0 if permissions need\n\t * not be checked for this RTE.\n\t *\n\t * As a special case, relid, relkind, rellockmode, and perminfoindex can\n\t * also be set (nonzero) in an RTE_SUBQUERY RTE. This occurs when we\n\t * convert an RTE_RELATION RTE naming a view into an RTE_SUBQUERY\n\t * containing the view's query. We still need to perform run-time locking\n\t * and permission checks on the view, even though it's not directly used\n\t * in the query anymore, and the most expedient way to do that is to\n\t * retain these fields from the old state of the RTE.\n\t *\n\t * As a special case, RTE_NAMEDTUPLESTORE can also set relid to indicate\n\t * that the tuple format of the tuplestore is the same as the referenced\n\t * relation. This allows plans referencing AFTER trigger transition\n\t * tables to be invalidated if the underlying table is altered.\n\t */\n"
},
{
"comment": "\t/* OID of the relation */\n"
},
{
"name": "relid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* inheritance requested? */\n"
},
{
"name": "inh",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* relation kind (see pg_class.relkind) */\n"
},
{
"name": "relkind",
"c_type": "char",
"comment": null
},
{
"comment": "\t/* lock level that query requires on the rel */\n"
},
{
"name": "rellockmode",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* index of RTEPermissionInfo entry, or 0 */\n"
},
{
"name": "perminfoindex",
"c_type": "Index",
"comment": null
},
{
"comment": "\t/* sampling info, or NULL */\n"
},
{
"name": "tablesample",
"c_type": "TableSampleClause*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a subquery RTE (else NULL):\n\t */\n"
},
{
"comment": "\t/* the sub-query */\n"
},
{
"name": "subquery",
"c_type": "Query*",
"comment": null
},
{
"comment": "\t/* is from security_barrier view? */\n"
},
{
"name": "security_barrier",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a join RTE (else NULL/zero):\n\t *\n\t * joinaliasvars is a list of (usually) Vars corresponding to the columns\n\t * of the join result. An alias Var referencing column K of the join\n\t * result can be replaced by the K'th element of joinaliasvars --- but to\n\t * simplify the task of reverse-listing aliases correctly, we do not do\n\t * that until planning time. In detail: an element of joinaliasvars can\n\t * be a Var of one of the join's input relations, or such a Var with an\n\t * implicit coercion to the join's output column type, or a COALESCE\n\t * expression containing the two input column Vars (possibly coerced).\n\t * Elements beyond the first joinmergedcols entries are always just Vars,\n\t * and are never referenced from elsewhere in the query (that is, join\n\t * alias Vars are generated only for merged columns). We keep these\n\t * entries only because they're needed in expandRTE() and similar code.\n\t *\n\t * Vars appearing within joinaliasvars are marked with varnullingrels sets\n\t * that describe the nulling effects of this join and lower ones. This is\n\t * essential for FULL JOIN cases, because the COALESCE expression only\n\t * describes the semantics correctly if its inputs have been nulled by the\n\t * join. For other cases, it allows expandRTE() to generate a valid\n\t * representation of the join's output without consulting additional\n\t * parser state.\n\t *\n\t * Within a Query loaded from a stored rule, it is possible for non-merged\n\t * joinaliasvars items to be null pointers, which are placeholders for\n\t * (necessarily unreferenced) columns dropped since the rule was made.\n\t * Also, once planning begins, joinaliasvars items can be almost anything,\n\t * as a result of subquery-flattening substitutions.\n\t *\n\t * joinleftcols is an integer list of physical column numbers of the left\n\t * join input rel that are included in the join; likewise joinrighttcols\n\t * for the right join input rel. (Which rels those are can be determined\n\t * from the associated JoinExpr.) If the join is USING/NATURAL, then the\n\t * first joinmergedcols entries in each list identify the merged columns.\n\t * The merged columns come first in the join output, then remaining\n\t * columns of the left input, then remaining columns of the right.\n\t *\n\t * Note that input columns could have been dropped after creation of a\n\t * stored rule, if they are not referenced in the query (in particular,\n\t * merged columns could not be dropped); this is not accounted for in\n\t * joinleftcols/joinrighttcols.\n\t */\n"
},
{
"name": "jointype",
"c_type": "JoinType",
"comment": null
},
{
"comment": "\t/* number of merged (JOIN USING) columns */\n"
},
{
"name": "joinmergedcols",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* list of alias-var expansions */\n"
},
{
"name": "joinaliasvars",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* left-side input column numbers */\n"
},
{
"name": "joinleftcols",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* right-side input column numbers */\n"
},
{
"name": "joinrightcols",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * join_using_alias is an alias clause attached directly to JOIN/USING. It\n\t * is different from the alias field (below) in that it does not hide the\n\t * range variables of the tables being joined.\n\t */\n"
},
{
"name": "join_using_alias",
"c_type": "Alias*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a function RTE (else NIL/zero):\n\t *\n\t * When funcordinality is true, the eref->colnames list includes an alias\n\t * for the ordinality column. The ordinality column is otherwise\n\t * implicit, and must be accounted for \"by hand\" in places such as\n\t * expandRTE().\n\t */\n"
},
{
"comment": "\t/* list of RangeTblFunction nodes */\n"
},
{
"name": "functions",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* is this called WITH ORDINALITY? */\n"
},
{
"name": "funcordinality",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a TableFunc RTE (else NULL):\n\t */\n"
},
{
"name": "tablefunc",
"c_type": "TableFunc*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a values RTE (else NIL):\n\t */\n"
},
{
"comment": "\t/* list of expression lists */\n"
},
{
"name": "values_lists",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for a CTE RTE (else NULL/zero):\n\t */\n"
},
{
"comment": "\t/* name of the WITH list item */\n"
},
{
"name": "ctename",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* number of query levels up */\n"
},
{
"name": "ctelevelsup",
"c_type": "Index",
"comment": null
},
{
"comment": "\t/* is this a recursive self-reference? */\n"
},
{
"name": "self_reference",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for CTE, VALUES, ENR, and TableFunc RTEs (else NIL):\n\t *\n\t * We need these for CTE RTEs so that the types of self-referential\n\t * columns are well-defined. For VALUES RTEs, storing these explicitly\n\t * saves having to re-determine the info by scanning the values_lists. For\n\t * ENRs, we store the types explicitly here (we could get the information\n\t * from the catalogs if 'relid' was supplied, but we'd still need these\n\t * for TupleDesc-based ENRs, so we might as well always store the type\n\t * info here). For TableFuncs, these fields are redundant with data in\n\t * the TableFunc node, but keeping them here allows some code sharing with\n\t * the other cases.\n\t *\n\t * For ENRs only, we have to consider the possibility of dropped columns.\n\t * A dropped column is included in these lists, but it will have zeroes in\n\t * all three lists (as well as an empty-string entry in eref). Testing\n\t * for zero coltype is the standard way to detect a dropped column.\n\t */\n"
},
{
"comment": "\t/* OID list of column type OIDs */\n"
},
{
"name": "coltypes",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* integer list of column typmods */\n"
},
{
"name": "coltypmods",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column collation OIDs */\n"
},
{
"name": "colcollations",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid for ENR RTEs (else NULL/zero):\n\t */\n"
},
{
"comment": "\t/* name of ephemeral named relation */\n"
},
{
"name": "enrname",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* estimated or actual from caller */\n"
},
{
"name": "enrtuples",
"c_type": "Cardinality",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Fields valid in all RTEs:\n\t */\n"
},
{
"comment": "\t/* was LATERAL specified? */\n"
},
{
"name": "lateral",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* present in FROM clause? */\n"
},
{
"name": "inFromCl",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* security barrier quals to apply, if any */\n"
},
{
"name": "securityQuals",
"c_type": "List*",
"comment": null
}
],
"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"
},
"RTEPermissionInfo": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "relid",
"c_type": "Oid",
"comment": "/* relation OID */"
},
{
"name": "inh",
"c_type": "bool",
"comment": "/* separately check inheritance children? */"
},
{
"name": "requiredPerms",
"c_type": "AclMode",
"comment": "/* bitmask of required access permissions */"
},
{
"name": "checkAsUser",
"c_type": "Oid",
"comment": "/* if valid, check access as this role */"
},
{
"name": "selectedCols",
"c_type": "Bitmapset*",
"comment": "/* columns needing SELECT permission */"
},
{
"name": "insertedCols",
"c_type": "Bitmapset*",
"comment": "/* columns needing INSERT permission */"
},
{
"name": "updatedCols",
"c_type": "Bitmapset*",
"comment": "/* columns needing UPDATE permission */"
}
],
"comment": "/*\n * RTEPermissionInfo\n * \t\tPer-relation information for permission checking. Added to the Query\n * \t\tnode by the parser when adding the corresponding RTE to the query\n * \t\trange table and subsequently editorialized on by the rewriter if\n * \t\tneeded after rule expansion.\n *\n * Only the relations directly mentioned in the query are checked for\n * access permissions by the core executor, so only their RTEPermissionInfos\n * are present in the Query. However, extensions may want to check inheritance\n * children too, depending on the value of rte->inh, so it's copied in 'inh'\n * for their perusal.\n *\n * requiredPerms and checkAsUser specify run-time access permissions checks\n * to be performed at query startup. The user must have *all* of the\n * permissions that are OR'd together in requiredPerms (never 0!). If\n * checkAsUser is not zero, then do the permissions checks using the access\n * rights of that user, not the current effective user ID. (This allows rules\n * to act as setuid gateways.)\n *\n * For SELECT/INSERT/UPDATE permissions, if the user doesn't have table-wide\n * permissions then it is sufficient to have the permissions on all columns\n * identified in selectedCols (for SELECT) and/or insertedCols and/or\n * updatedCols (INSERT with ON CONFLICT DO UPDATE may have all 3).\n * selectedCols, insertedCols and updatedCols are bitmapsets, which cannot have\n * negative integer members, so we subtract FirstLowInvalidHeapAttributeNumber\n * from column numbers before storing them in these fields. A whole-row Var\n * reference is represented by setting the bit for InvalidAttrNumber.\n *\n * updatedCols is also used in some other places, for example, to determine\n * which triggers to fire and in FDWs to know which changed columns they need\n * to ship off.\n */\n"
},
"RangeTblFunction": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "funcexpr",
"c_type": "Node*",
"comment": "/* expression tree for func call */"
},
{
"comment": "\t/* number of columns it contributes to RTE */\n"
},
{
"name": "funccolcount",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* These fields record the contents of a column definition list, if any: */\n"
},
{
"comment": "\t/* column names (list of String) */\n"
},
{
"name": "funccolnames",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column type OIDs */\n"
},
{
"name": "funccoltypes",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* integer list of column typmods */\n"
},
{
"name": "funccoltypmods",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column collation OIDs */\n"
},
{
"name": "funccolcollations",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* This is set during planning for use by the executor: */\n"
},
{
"comment": "\t/* PARAM_EXEC Param IDs affecting this func */\n"
},
{
"name": "funcparams",
"c_type": "Bitmapset*",
"comment": null
}
],
"comment": "/*\n * RangeTblFunction -\n *\t RangeTblEntry subsidiary data for one function in a FUNCTION RTE.\n *\n * If the function had a column definition list (required for an\n * otherwise-unspecified RECORD result), funccolnames lists the names given\n * in the definition list, funccoltypes lists their declared column types,\n * funccoltypmods lists their typmods, funccolcollations their collations.\n * Otherwise, those fields are NIL.\n *\n * Notice we don't attempt to store info about the results of functions\n * returning named composite types, because those can change from time to\n * time. We do however remember how many columns we thought the type had\n * (including dropped columns!), so that we can successfully ignore any\n * columns added after the query was parsed.\n *\n * The query jumbling only needs to track the function expression.\n */\n"
},
"TableSampleClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "tsmhandler",
"c_type": "Oid",
"comment": "/* OID of the tablesample handler function */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* tablesample argument expression(s) */"
},
{
"name": "repeatable",
"c_type": "Expr*",
"comment": "/* REPEATABLE expression, or NULL if none */"
}
],
"comment": "/*\n * TableSampleClause - TABLESAMPLE appearing in a transformed FROM clause\n *\n * Unlike RangeTableSample, this is a subnode of the relevant RangeTblEntry.\n */\n"
},
"WithCheckOption": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "WCOKind",
"comment": "/* kind of WCO */"
},
{
"name": "relname",
"c_type": "char*",
"comment": "/* name of relation that specified the WCO */"
},
{
"name": "polname",
"c_type": "char*",
"comment": "/* name of RLS policy being checked */"
},
{
"name": "qual",
"c_type": "Node*",
"comment": "/* constraint qual to check */"
},
{
"name": "cascaded",
"c_type": "bool",
"comment": "/* true for a cascaded WCO on a view */"
}
],
"comment": null
},
"SortGroupClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "tleSortGroupRef",
"c_type": "Index",
"comment": "/* reference into targetlist */"
},
{
"name": "eqop",
"c_type": "Oid",
"comment": "/* the equality operator ('=' op) */"
},
{
"name": "sortop",
"c_type": "Oid",
"comment": "/* the ordering operator ('<' op), or 0 */"
},
{
"name": "nulls_first",
"c_type": "bool",
"comment": "/* do NULLs come before normal values? */"
},
{
"comment": "\t/* can eqop be implemented by hashing? */\n"
},
{
"name": "hashable",
"c_type": "bool",
"comment": null
}
],
"comment": "/*\n * SortGroupClause -\n *\t\trepresentation of ORDER BY, GROUP BY, PARTITION BY,\n *\t\tDISTINCT, DISTINCT ON items\n *\n * You might think that ORDER BY is only interested in defining ordering,\n * and GROUP/DISTINCT are only interested in defining equality. However,\n * one way to implement grouping is to sort and then apply a \"uniq\"-like\n * filter. So it's also interesting to keep track of possible sort operators\n * for GROUP/DISTINCT, and in particular to try to sort for the grouping\n * in a way that will also yield a requested ORDER BY ordering. So we need\n * to be able to compare ORDER BY and GROUP/DISTINCT lists, which motivates\n * the decision to give them the same representation.\n *\n * tleSortGroupRef must match ressortgroupref of exactly one entry of the\n *\t\tquery's targetlist; that is the expression to be sorted or grouped by.\n * eqop is the OID of the equality operator.\n * sortop is the OID of the ordering operator (a \"<\" or \">\" operator),\n *\t\tor InvalidOid if not available.\n * nulls_first means about what you'd expect. If sortop is InvalidOid\n *\t\tthen nulls_first is meaningless and should be set to false.\n * hashable is true if eqop is hashable (note this condition also depends\n *\t\ton the datatype of the input expression).\n *\n * In an ORDER BY item, all fields must be valid. (The eqop isn't essential\n * here, but it's cheap to get it along with the sortop, and requiring it\n * to be valid eases comparisons to grouping items.) Note that this isn't\n * actually enough information to determine an ordering: if the sortop is\n * collation-sensitive, a collation OID is needed too. We don't store the\n * collation in SortGroupClause because it's not available at the time the\n * parser builds the SortGroupClause; instead, consult the exposed collation\n * of the referenced targetlist expression to find out what it is.\n *\n * In a grouping item, eqop must be valid. If the eqop is a btree equality\n * operator, then sortop should be set to a compatible ordering operator.\n * We prefer to set eqop/sortop/nulls_first to match any ORDER BY item that\n * the query presents for the same tlist item. If there is none, we just\n * use the default ordering op for the datatype.\n *\n * If the tlist item's type has a hash opclass but no btree opclass, then\n * we will set eqop to the hash equality operator, sortop to InvalidOid,\n * and nulls_first to false. A grouping item of this kind can only be\n * implemented by hashing, and of course it'll never match an ORDER BY item.\n *\n * The hashable flag is provided since we generally have the requisite\n * information readily available when the SortGroupClause is constructed,\n * and it's relatively expensive to get it again later. Note there is no\n * need for a \"sortable\" flag since OidIsValid(sortop) serves the purpose.\n *\n * A query might have both ORDER BY and DISTINCT (or DISTINCT ON) clauses.\n * In SELECT DISTINCT, the distinctClause list is as long or longer than the\n * sortClause list, while in SELECT DISTINCT ON it's typically shorter.\n * The two lists must match up to the end of the shorter one --- the parser\n * rearranges the distinctClause if necessary to make this true. (This\n * restriction ensures that only one sort step is needed to both satisfy the\n * ORDER BY and set up for the Unique step. This is semantically necessary\n * for DISTINCT ON, and presents no real drawback for DISTINCT.)\n */\n"
},
"GroupingSet": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "GroupingSetKind",
"comment": null
},
{
"name": "content",
"c_type": "List*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": null
},
"WindowClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": "\t/* window name (NULL in an OVER clause) */\n"
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* referenced window name, if any */\n"
},
{
"name": "refname",
"c_type": "char*",
"comment": null
},
{
"name": "partitionClause",
"c_type": "List*",
"comment": "/* PARTITION BY list */"
},
{
"comment": "\t/* ORDER BY list */\n"
},
{
"name": "orderClause",
"c_type": "List*",
"comment": null
},
{
"name": "frameOptions",
"c_type": "int",
"comment": "/* frame_clause options, see WindowDef */"
},
{
"name": "startOffset",
"c_type": "Node*",
"comment": "/* expression for starting bound, if any */"
},
{
"name": "endOffset",
"c_type": "Node*",
"comment": "/* expression for ending bound, if any */"
},
{
"comment": "\t/* in_range function for startOffset */\n"
},
{
"name": "startInRangeFunc",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* in_range function for endOffset */\n"
},
{
"name": "endInRangeFunc",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* collation for in_range tests */\n"
},
{
"name": "inRangeColl",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* use ASC sort order for in_range tests? */\n"
},
{
"name": "inRangeAsc",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* nulls sort first for in_range tests? */\n"
},
{
"name": "inRangeNullsFirst",
"c_type": "bool",
"comment": null
},
{
"name": "winref",
"c_type": "Index",
"comment": "/* ID referenced by window functions */"
},
{
"comment": "\t/* did we copy orderClause from refname? */\n"
},
{
"name": "copiedOrder",
"c_type": "bool",
"comment": null
}
],
"comment": "/*\n * WindowClause -\n *\t\ttransformed representation of WINDOW and OVER clauses\n *\n * A parsed Query's windowClause list contains these structs. \"name\" is set\n * if the clause originally came from WINDOW, and is NULL if it originally\n * was an OVER clause (but note that we collapse out duplicate OVERs).\n * partitionClause and orderClause are lists of SortGroupClause structs.\n * partitionClause is sanitized by the query planner to remove any columns or\n * expressions belonging to redundant PathKeys.\n * If we have RANGE with offset PRECEDING/FOLLOWING, the semantics of that are\n * specified by startInRangeFunc/inRangeColl/inRangeAsc/inRangeNullsFirst\n * for the start offset, or endInRangeFunc/inRange* for the end offset.\n * winref is an ID number referenced by WindowFunc nodes; it must be unique\n * among the members of a Query's windowClause list.\n * When refname isn't null, the partitionClause is always copied from there;\n * the orderClause might or might not be copied (see copiedOrder); the framing\n * options are never copied, per spec.\n *\n * The information relevant for the query jumbling is the partition clause\n * type and its bounds.\n */\n"
},
"RowMarkClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "rti",
"c_type": "Index",
"comment": "/* range table index of target relation */"
},
{
"name": "strength",
"c_type": "LockClauseStrength",
"comment": null
},
{
"name": "waitPolicy",
"c_type": "LockWaitPolicy",
"comment": "/* NOWAIT and SKIP LOCKED */"
},
{
"name": "pushedDown",
"c_type": "bool",
"comment": "/* pushed down from higher query level? */"
}
],
"comment": "/*\n * RowMarkClause -\n *\t parser output representation of FOR [KEY] UPDATE/SHARE clauses\n *\n * Query.rowMarks contains a separate RowMarkClause node for each relation\n * identified as a FOR [KEY] UPDATE/SHARE target. If one of these clauses\n * is applied to a subquery, we generate RowMarkClauses for all normal and\n * subquery rels in the subquery, but they are marked pushedDown = true to\n * distinguish them from clauses that were explicitly written at this query\n * level. Also, Query.hasForUpdate tells whether there were explicit FOR\n * UPDATE/SHARE/KEY SHARE clauses in the current query level.\n */\n"
},
"WithClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "ctes",
"c_type": "List*",
"comment": "/* list of CommonTableExprs */"
},
{
"name": "recursive",
"c_type": "bool",
"comment": "/* true = WITH RECURSIVE */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * WithClause -\n *\t representation of WITH clause\n *\n * Note: WithClause does not propagate into the Query representation;\n * but CommonTableExpr does.\n */\n"
},
"InferClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "indexElems",
"c_type": "List*",
"comment": "/* IndexElems to infer unique index */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualification (partial-index predicate) */"
},
{
"name": "conname",
"c_type": "char*",
"comment": "/* Constraint name, or NULL if unnamed */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * InferClause -\n *\t\tON CONFLICT unique index inference clause\n *\n * Note: InferClause does not propagate into the Query representation.\n */\n"
},
"OnConflictClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "action",
"c_type": "OnConflictAction",
"comment": "/* DO NOTHING or UPDATE? */"
},
{
"name": "infer",
"c_type": "InferClause*",
"comment": "/* Optional index inference clause */"
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* the target list (of ResTarget) */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualifications */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * OnConflictClause -\n *\t\trepresentation of ON CONFLICT clause\n *\n * Note: OnConflictClause does not propagate into the Query representation.\n */\n"
},
"CTESearchClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "search_col_list",
"c_type": "List*",
"comment": null
},
{
"name": "search_breadth_first",
"c_type": "bool",
"comment": null
},
{
"name": "search_seq_column",
"c_type": "char*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": null
},
"CTECycleClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "cycle_col_list",
"c_type": "List*",
"comment": null
},
{
"name": "cycle_mark_column",
"c_type": "char*",
"comment": null
},
{
"name": "cycle_mark_value",
"c_type": "Node*",
"comment": null
},
{
"name": "cycle_mark_default",
"c_type": "Node*",
"comment": null
},
{
"name": "cycle_path_column",
"c_type": "char*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
},
{
"comment": "\t/* These fields are set during parse analysis: */\n"
},
{
"name": "cycle_mark_type",
"c_type": "Oid",
"comment": "/* common type of _value and _default */"
},
{
"name": "cycle_mark_typmod",
"c_type": "int",
"comment": null
},
{
"name": "cycle_mark_collation",
"c_type": "Oid",
"comment": null
},
{
"name": "cycle_mark_neop",
"c_type": "Oid",
"comment": "/* <> operator for type */"
}
],
"comment": null
},
"CommonTableExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Query name (never qualified). The string name is included in the query\n\t * jumbling because RTE_CTE RTEs need it.\n\t */\n"
},
{
"name": "ctename",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* optional list of column names */\n"
},
{
"name": "aliascolnames",
"c_type": "List*",
"comment": null
},
{
"name": "ctematerialized",
"c_type": "CTEMaterialize",
"comment": "/* is this an optimization fence? */"
},
{
"comment": "\t/* SelectStmt/InsertStmt/etc before parse analysis, Query afterwards: */\n"
},
{
"name": "ctequery",
"c_type": "Node*",
"comment": "/* the CTE's subquery */"
},
{
"name": "search_clause",
"c_type": "CTESearchClause*",
"comment": null
},
{
"name": "cycle_clause",
"c_type": "CTECycleClause*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
},
{
"comment": "\t/* These fields are set during parse analysis: */\n"
},
{
"comment": "\t/* is this CTE actually recursive? */\n"
},
{
"name": "cterecursive",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Number of RTEs referencing this CTE (excluding internal\n\t * self-references), irrelevant for query jumbling.\n\t */\n"
},
{
"name": "cterefcount",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* list of output column names */\n"
},
{
"name": "ctecolnames",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of output column type OIDs */\n"
},
{
"name": "ctecoltypes",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* integer list of output column typmods */\n"
},
{
"name": "ctecoltypmods",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column collation OIDs */\n"
},
{
"name": "ctecolcollations",
"c_type": "List*",
"comment": null
}
],
"comment": null
},
"MergeWhenClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "matchKind",
"c_type": "MergeMatchKind",
"comment": "/* MATCHED/NOT MATCHED BY SOURCE/TARGET */"
},
{
"name": "commandType",
"c_type": "CmdType",
"comment": "/* INSERT/UPDATE/DELETE/DO NOTHING */"
},
{
"name": "override",
"c_type": "OverridingKind",
"comment": "/* OVERRIDING clause */"
},
{
"name": "condition",
"c_type": "Node*",
"comment": "/* WHEN conditions (raw parser) */"
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* INSERT/UPDATE targetlist */"
},
{
"comment": "\t/* the following members are only used in INSERT actions */\n"
},
{
"name": "values",
"c_type": "List*",
"comment": "/* VALUES to INSERT, or NULL */"
}
],
"comment": "/*\n * MergeWhenClause -\n *\t\traw parser representation of a WHEN clause in a MERGE statement\n *\n * This is transformed into MergeAction by parse analysis\n */\n"
},
"TriggerTransition": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"name": "isNew",
"c_type": "bool",
"comment": null
},
{
"name": "isTable",
"c_type": "bool",
"comment": null
}
],
"comment": "/*\n * TriggerTransition -\n *\t representation of transition row or table naming clause\n *\n * Only transition tables are initially supported in the syntax, and only for\n * AFTER triggers, but other permutations are accepted by the parser so we can\n * give a meaningful message from C code.\n */\n"
},
"JsonOutput": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* RETURNING type name, if specified */"
},
{
"name": "returning",
"c_type": "JsonReturning*",
"comment": "/* RETURNING FORMAT clause and type Oids */"
}
],
"comment": "/*\n * JsonOutput -\n *\t\trepresentation of JSON output clause (RETURNING type [FORMAT format])\n */\n"
},
"JsonArgument": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "val",
"c_type": "JsonValueExpr*",
"comment": "/* argument value expression */"
},
{
"name": "name",
"c_type": "char*",
"comment": "/* argument name */"
}
],
"comment": "/*\n * JsonArgument -\n *\t\trepresentation of argument from JSON PASSING clause\n */\n"
},
"JsonFuncExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "op",
"c_type": "JsonExprOp",
"comment": "/* expression type */"
},
{
"name": "column_name",
"c_type": "char*",
"comment": "/* JSON_TABLE() column name or NULL if this is\n\t\t\t\t\t\t\t\t * not for a JSON_TABLE() */\n"
},
{
"name": "context_item",
"c_type": "JsonValueExpr*",
"comment": "/* context item expression */"
},
{
"name": "pathspec",
"c_type": "Node*",
"comment": "/* JSON path specification expression */"
},
{
"name": "passing",
"c_type": "List*",
"comment": "/* list of PASSING clause arguments, if any */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* output clause, if specified */"
},
{
"name": "on_empty",
"c_type": "JsonBehavior*",
"comment": "/* ON EMPTY behavior */"
},
{
"name": "on_error",
"c_type": "JsonBehavior*",
"comment": "/* ON ERROR behavior */"
},
{
"name": "wrapper",
"c_type": "JsonWrapper",
"comment": "/* array wrapper behavior (JSON_QUERY only) */"
},
{
"name": "quotes",
"c_type": "JsonQuotes",
"comment": "/* omit or keep quotes? (JSON_QUERY only) */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonFuncExpr -\n *\t\tuntransformed representation of function expressions for\n *\t\tSQL/JSON query functions\n */\n"
},
"JsonTablePathSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "string",
"c_type": "Node*",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"name": "name_location",
"c_type": "ParseLoc",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* location of 'string' */"
}
],
"comment": "/*\n * JsonTablePathSpec\n *\t\tuntransformed specification of JSON path expression with an optional\n *\t\tname\n */\n"
},
"JsonTable": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "context_item",
"c_type": "JsonValueExpr*",
"comment": "/* context item expression */"
},
{
"name": "pathspec",
"c_type": "JsonTablePathSpec*",
"comment": "/* JSON path specification */"
},
{
"name": "passing",
"c_type": "List*",
"comment": "/* list of PASSING clause arguments, if any */"
},
{
"name": "columns",
"c_type": "List*",
"comment": "/* list of JsonTableColumn */"
},
{
"name": "on_error",
"c_type": "JsonBehavior*",
"comment": "/* ON ERROR behavior */"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": "/* table alias in FROM clause */"
},
{
"name": "lateral",
"c_type": "bool",
"comment": "/* does it have LATERAL prefix? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonTable -\n *\t\tuntransformed representation of JSON_TABLE\n */\n"
},
"JsonTableColumn": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "coltype",
"c_type": "JsonTableColumnType",
"comment": "/* column type */"
},
{
"name": "name",
"c_type": "char*",
"comment": "/* column name */"
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* column type name */"
},
{
"name": "pathspec",
"c_type": "JsonTablePathSpec*",
"comment": "/* JSON path specification */"
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": "/* JSON format clause, if specified */"
},
{
"name": "wrapper",
"c_type": "JsonWrapper",
"comment": "/* WRAPPER behavior for formatted columns */"
},
{
"name": "quotes",
"c_type": "JsonQuotes",
"comment": "/* omit or keep quotes on scalar strings? */"
},
{
"name": "columns",
"c_type": "List*",
"comment": "/* nested columns */"
},
{
"name": "on_empty",
"c_type": "JsonBehavior*",
"comment": "/* ON EMPTY behavior */"
},
{
"name": "on_error",
"c_type": "JsonBehavior*",
"comment": "/* ON ERROR behavior */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonTableColumn -\n *\t\tuntransformed representation of JSON_TABLE column\n */\n"
},
"JsonKeyValue": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "key",
"c_type": "Expr*",
"comment": "/* key expression */"
},
{
"name": "value",
"c_type": "JsonValueExpr*",
"comment": "/* JSON value expression */"
}
],
"comment": "/*\n * JsonKeyValue -\n *\t\tuntransformed representation of JSON object key-value pair for\n *\t\tJSON_OBJECT() and JSON_OBJECTAGG()\n */\n"
},
"JsonParseExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "expr",
"c_type": "JsonValueExpr*",
"comment": "/* string expression */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "unique_keys",
"c_type": "bool",
"comment": "/* WITH UNIQUE KEYS? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonParseExpr -\n *\t\tuntransformed representation of JSON()\n */\n"
},
"JsonScalarExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "expr",
"c_type": "Expr*",
"comment": "/* scalar expression */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonScalarExpr -\n *\t\tuntransformed representation of JSON_SCALAR()\n */\n"
},
"JsonSerializeExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "expr",
"c_type": "JsonValueExpr*",
"comment": "/* json value expression */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonSerializeExpr -\n *\t\tuntransformed representation of JSON_SERIALIZE() function\n */\n"
},
"JsonObjectConstructor": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "exprs",
"c_type": "List*",
"comment": "/* list of JsonKeyValue pairs */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* skip NULL values? */"
},
{
"name": "unique",
"c_type": "bool",
"comment": "/* check key uniqueness? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonObjectConstructor -\n *\t\tuntransformed representation of JSON_OBJECT() constructor\n */\n"
},
"JsonArrayConstructor": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "exprs",
"c_type": "List*",
"comment": "/* list of JsonValueExpr elements */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* skip NULL elements? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonArrayConstructor -\n *\t\tuntransformed representation of JSON_ARRAY(element,...) constructor\n */\n"
},
"JsonArrayQueryConstructor": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* subquery */"
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if specified */"
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": "/* FORMAT clause for subquery, if specified */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* skip NULL elements? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonArrayQueryConstructor -\n *\t\tuntransformed representation of JSON_ARRAY(subquery) constructor\n */\n"
},
"JsonAggConstructor": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "output",
"c_type": "JsonOutput*",
"comment": "/* RETURNING clause, if any */"
},
{
"name": "agg_filter",
"c_type": "Node*",
"comment": "/* FILTER clause, if any */"
},
{
"name": "agg_order",
"c_type": "List*",
"comment": "/* ORDER BY clause, if any */"
},
{
"name": "over",
"c_type": "WindowDef*",
"comment": "/* OVER clause, if any */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonAggConstructor -\n *\t\tcommon fields of untransformed representation of\n *\t\tJSON_ARRAYAGG() and JSON_OBJECTAGG()\n */\n"
},
"JsonObjectAgg": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "constructor",
"c_type": "JsonAggConstructor*",
"comment": "/* common fields */"
},
{
"name": "arg",
"c_type": "JsonKeyValue*",
"comment": "/* object key-value pair */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* skip NULL values? */"
},
{
"name": "unique",
"c_type": "bool",
"comment": "/* check key uniqueness? */"
}
],
"comment": "/*\n * JsonObjectAgg -\n *\t\tuntransformed representation of JSON_OBJECTAGG()\n */\n"
},
"JsonArrayAgg": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "constructor",
"c_type": "JsonAggConstructor*",
"comment": "/* common fields */"
},
{
"name": "arg",
"c_type": "JsonValueExpr*",
"comment": "/* array element expression */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* skip NULL elements? */"
}
],
"comment": "/*\n * JsonArrayAgg -\n *\t\tuntransformed representation of JSON_ARRAYAGG()\n */\n"
},
"RawStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "stmt",
"c_type": "Node*",
"comment": "/* raw parse tree */"
},
{
"name": "stmt_location",
"c_type": "ParseLoc",
"comment": "/* start location, or -1 if unknown */"
},
{
"name": "stmt_len",
"c_type": "ParseLoc",
"comment": "/* length in bytes; 0 means \"rest of string\" */"
}
],
"comment": "/*\n *\t\tRawStmt --- container for any one statement's raw parse tree\n *\n * Parse analysis converts a raw parse tree headed by a RawStmt node into\n * an analyzed statement headed by a Query node. For optimizable statements,\n * the conversion is complex. For utility statements, the parser usually just\n * transfers the raw parse tree (sans RawStmt) into the utilityStmt field of\n * the Query node, and all the useful work happens at execution time.\n *\n * stmt_location/stmt_len identify the portion of the source text string\n * containing this raw statement (useful for multi-statement strings).\n *\n * This is irrelevant for query jumbling, as this is not used in parsed\n * queries.\n */\n"
},
"InsertStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to insert into */"
},
{
"name": "cols",
"c_type": "List*",
"comment": "/* optional: names of the target columns */"
},
{
"name": "selectStmt",
"c_type": "Node*",
"comment": "/* the source SELECT/VALUES, or NULL */"
},
{
"name": "onConflictClause",
"c_type": "OnConflictClause*",
"comment": "/* ON CONFLICT clause */"
},
{
"name": "returningList",
"c_type": "List*",
"comment": "/* list of expressions to return */"
},
{
"name": "withClause",
"c_type": "WithClause*",
"comment": "/* WITH clause */"
},
{
"name": "override",
"c_type": "OverridingKind",
"comment": "/* OVERRIDING clause */"
}
],
"comment": "/* ----------------------\n *\t\tInsert Statement\n *\n * The source expression is represented by SelectStmt for both the\n * SELECT and VALUES cases. If selectStmt is NULL, then the query\n * is INSERT ... DEFAULT VALUES.\n * ----------------------\n */\n"
},
"DeleteStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to delete from */"
},
{
"name": "usingClause",
"c_type": "List*",
"comment": "/* optional using clause for more tables */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualifications */"
},
{
"name": "returningList",
"c_type": "List*",
"comment": "/* list of expressions to return */"
},
{
"name": "withClause",
"c_type": "WithClause*",
"comment": "/* WITH clause */"
}
],
"comment": "/* ----------------------\n *\t\tDelete Statement\n * ----------------------\n */\n"
},
"UpdateStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to update */"
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* the target list (of ResTarget) */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualifications */"
},
{
"name": "fromClause",
"c_type": "List*",
"comment": "/* optional from clause for more tables */"
},
{
"name": "returningList",
"c_type": "List*",
"comment": "/* list of expressions to return */"
},
{
"name": "withClause",
"c_type": "WithClause*",
"comment": "/* WITH clause */"
}
],
"comment": "/* ----------------------\n *\t\tUpdate Statement\n * ----------------------\n */\n"
},
"MergeStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* target relation to merge into */"
},
{
"name": "sourceRelation",
"c_type": "Node*",
"comment": "/* source relation */"
},
{
"name": "joinCondition",
"c_type": "Node*",
"comment": "/* join condition between source and target */"
},
{
"name": "mergeWhenClauses",
"c_type": "List*",
"comment": "/* list of MergeWhenClause(es) */"
},
{
"name": "returningList",
"c_type": "List*",
"comment": "/* list of expressions to return */"
},
{
"name": "withClause",
"c_type": "WithClause*",
"comment": "/* WITH clause */"
}
],
"comment": "/* ----------------------\n *\t\tMerge Statement\n * ----------------------\n */\n"
},
"SelectStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields are used only in \"leaf\" SelectStmts.\n\t */\n"
},
{
"name": "distinctClause",
"c_type": "List*",
"comment": "/* NULL, list of DISTINCT ON exprs, or\n\t\t\t\t\t\t\t\t * lcons(NIL,NIL) for all (SELECT DISTINCT) */\n"
},
{
"name": "intoClause",
"c_type": "IntoClause*",
"comment": "/* target for SELECT INTO */"
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* the target list (of ResTarget) */"
},
{
"name": "fromClause",
"c_type": "List*",
"comment": "/* the FROM clause */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* WHERE qualification */"
},
{
"name": "groupClause",
"c_type": "List*",
"comment": "/* GROUP BY clauses */"
},
{
"name": "groupDistinct",
"c_type": "bool",
"comment": "/* Is this GROUP BY DISTINCT? */"
},
{
"name": "havingClause",
"c_type": "Node*",
"comment": "/* HAVING conditional-expression */"
},
{
"name": "windowClause",
"c_type": "List*",
"comment": "/* WINDOW window_name AS (...), ... */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * In a \"leaf\" node representing a VALUES list, the above fields are all\n\t * null, and instead this field is set. Note that the elements of the\n\t * sublists are just expressions, without ResTarget decoration. Also note\n\t * that a list element can be DEFAULT (represented as a SetToDefault\n\t * node), regardless of the context of the VALUES list. It's up to parse\n\t * analysis to reject that where not valid.\n\t */\n"
},
{
"name": "valuesLists",
"c_type": "List*",
"comment": "/* untransformed list of expression lists */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields are used in both \"leaf\" SelectStmts and upper-level\n\t * SelectStmts.\n\t */\n"
},
{
"name": "sortClause",
"c_type": "List*",
"comment": "/* sort clause (a list of SortBy's) */"
},
{
"name": "limitOffset",
"c_type": "Node*",
"comment": "/* # of result tuples to skip */"
},
{
"name": "limitCount",
"c_type": "Node*",
"comment": "/* # of result tuples to return */"
},
{
"name": "limitOption",
"c_type": "LimitOption",
"comment": "/* limit type */"
},
{
"name": "lockingClause",
"c_type": "List*",
"comment": "/* FOR UPDATE (list of LockingClause's) */"
},
{
"name": "withClause",
"c_type": "WithClause*",
"comment": "/* WITH clause */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields are used only in upper-level SelectStmts.\n\t */\n"
},
{
"name": "op",
"c_type": "SetOperation",
"comment": "/* type of set op */"
},
{
"name": "all",
"c_type": "bool",
"comment": "/* ALL specified? */"
},
{
"name": "larg",
"c_type": "SelectStmt*",
"comment": "/* left child */"
},
{
"name": "rarg",
"c_type": "SelectStmt*",
"comment": "/* right child */"
},
{
"comment": "\t/* Eventually add fields for CORRESPONDING spec here */\n"
}
],
"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"
},
"SetOperationStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "op",
"c_type": "SetOperation",
"comment": "/* type of set op */"
},
{
"name": "all",
"c_type": "bool",
"comment": "/* ALL specified? */"
},
{
"name": "larg",
"c_type": "Node*",
"comment": "/* left child */"
},
{
"name": "rarg",
"c_type": "Node*",
"comment": "/* right child */"
},
{
"comment": "\t/* Eventually add fields for CORRESPONDING spec here */\n"
},
{
"comment": ""
},
{
"comment": "\t/* Fields derived during parse analysis (irrelevant for query jumbling): */\n"
},
{
"comment": "\t/* OID list of output column type OIDs */\n"
},
{
"name": "colTypes",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* integer list of output column typmods */\n"
},
{
"name": "colTypmods",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of output column collation OIDs */\n"
},
{
"name": "colCollations",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* a list of SortGroupClause's */\n"
},
{
"name": "groupClauses",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* groupClauses is NIL if UNION ALL, but must be set otherwise */\n"
}
],
"comment": "/* ----------------------\n *\t\tSet Operation node for post-analysis query trees\n *\n * After parse analysis, a SELECT with set operations is represented by a\n * top-level Query node containing the leaf SELECTs as subqueries in its\n * range table. Its setOperations field shows the tree of set operations,\n * with leaf SelectStmt nodes replaced by RangeTblRef nodes, and internal\n * nodes replaced by SetOperationStmt nodes. Information about the output\n * column types is added, too. (Note that the child nodes do not necessarily\n * produce these types directly, but we've checked that their output types\n * can be coerced to the output column type.) Also, if it's not UNION ALL,\n * information about the types' sort/group semantics is provided in the form\n * of a SortGroupClause list (same representation as, eg, DISTINCT).\n * The resolved common column collations are provided too; but note that if\n * it's not UNION ALL, it's okay for a column to not have a common collation,\n * so a member of the colCollations list could be InvalidOid even though the\n * column has a collatable type.\n * ----------------------\n */\n"
},
"ReturnStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "returnval",
"c_type": "Node*",
"comment": null
}
],
"comment": "/*\n * RETURN statement (inside SQL function body)\n */\n"
},
"PLAssignStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "name",
"c_type": "char*",
"comment": "/* initial column name */"
},
{
"name": "indirection",
"c_type": "List*",
"comment": "/* subscripts and field names, if any */"
},
{
"name": "nnames",
"c_type": "int",
"comment": "/* number of names to use in ColumnRef */"
},
{
"name": "val",
"c_type": "SelectStmt*",
"comment": "/* the PL/pgSQL expression to assign */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* name's token location, or -1 if unknown */"
}
],
"comment": "/* ----------------------\n *\t\tPL/pgSQL Assignment Statement\n *\n * Like SelectStmt, this is transformed into a SELECT Query.\n * However, the targetlist of the result looks more like an UPDATE.\n * ----------------------\n */\n"
},
"CreateSchemaStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "schemaname",
"c_type": "char*",
"comment": "/* the name of the schema to create */"
},
{
"name": "authrole",
"c_type": "RoleSpec*",
"comment": "/* the owner of the created schema */"
},
{
"name": "schemaElts",
"c_type": "List*",
"comment": "/* schema components (list of parsenodes) */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if schema already exists? */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Schema Statement\n *\n * NOTE: the schemaElts list contains raw parsetrees for component statements\n * of the schema, such as CREATE TABLE, GRANT, etc. These are analyzed and\n * executed after the schema itself is created.\n * ----------------------\n */\n"
},
"AlterTableStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* table to work on */"
},
{
"name": "cmds",
"c_type": "List*",
"comment": "/* list of subcommands */"
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* type of object */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if table missing */"
}
],
"comment": "/* ----------------------\n *\tAlter Table\n * ----------------------\n */\n"
},
"ReplicaIdentityStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "identity_type",
"c_type": "char",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": null
}
],
"comment": "/* ----------------------\n *\tAlter Table\n * ----------------------\n */\n"
},
"AlterTableCmd": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "subtype",
"c_type": "AlterTableType",
"comment": "/* Type of table alteration to apply */"
},
{
"name": "name",
"c_type": "char*",
"comment": "/* column, constraint, or trigger to act on,\n\t\t\t\t\t\t\t\t * or tablespace, access method */\n"
},
{
"name": "num",
"c_type": "int16",
"comment": "/* attribute number for columns referenced by\n\t\t\t\t\t\t\t\t * number */\n"
},
{
"name": "newowner",
"c_type": "RoleSpec*",
"comment": null
},
{
"name": "def",
"c_type": "Node*",
"comment": "/* definition of new column, index,\n\t\t\t\t\t\t\t\t * constraint, or parent table */\n"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE for DROP cases */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if missing? */"
},
{
"name": "recurse",
"c_type": "bool",
"comment": "/* exec-time recursion */"
}
],
"comment": "/* ----------------------\n *\tAlter Table\n * ----------------------\n */\n"
},
"AlterCollationStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "collname",
"c_type": "List*",
"comment": null
}
],
"comment": "/* ----------------------\n * Alter Collation\n * ----------------------\n */\n"
},
"AlterDomainStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "subtype",
"c_type": "char",
"comment": "/*------------\n\t\t\t\t\t\t\t\t *\tT = alter column default\n\t\t\t\t\t\t\t\t *\tN = alter column drop not null\n\t\t\t\t\t\t\t\t *\tO = alter column set not null\n\t\t\t\t\t\t\t\t *\tC = add constraint\n\t\t\t\t\t\t\t\t *\tX = drop constraint\n\t\t\t\t\t\t\t\t *------------\n\t\t\t\t\t\t\t\t */\n"
},
{
"name": "typeName",
"c_type": "List*",
"comment": "/* domain to work on */"
},
{
"name": "name",
"c_type": "char*",
"comment": "/* column or constraint name to act on */"
},
{
"name": "def",
"c_type": "Node*",
"comment": "/* definition of default or constraint */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE for DROP cases */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if missing? */"
}
],
"comment": "/* ----------------------\n *\tAlter Domain\n *\n * The fields are used in different ways by the different variants of\n * this command.\n * ----------------------\n */\n"
},
"GrantStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "is_grant",
"c_type": "bool",
"comment": "/* true = GRANT, false = REVOKE */"
},
{
"name": "targtype",
"c_type": "GrantTargetType",
"comment": "/* type of the grant target */"
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* kind of object being operated on */"
},
{
"name": "objects",
"c_type": "List*",
"comment": "/* list of RangeVar nodes, ObjectWithArgs\n\t\t\t\t\t\t\t\t * nodes, or plain names (as String values) */\n"
},
{
"name": "privileges",
"c_type": "List*",
"comment": "/* list of AccessPriv nodes */"
},
{
"comment": "\t/* privileges == NIL denotes ALL PRIVILEGES */\n"
},
{
"name": "grantees",
"c_type": "List*",
"comment": "/* list of RoleSpec nodes */"
},
{
"name": "grant_option",
"c_type": "bool",
"comment": "/* grant or revoke grant option */"
},
{
"name": "grantor",
"c_type": "RoleSpec*",
"comment": null
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* drop behavior (for REVOKE) */"
}
],
"comment": "/* ----------------------\n *\t\tGrant|Revoke Statement\n * ----------------------\n */\n"
},
"ObjectWithArgs": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objname",
"c_type": "List*",
"comment": "/* qualified name of function/operator */"
},
{
"name": "objargs",
"c_type": "List*",
"comment": "/* list of Typename nodes (input args only) */"
},
{
"name": "objfuncargs",
"c_type": "List*",
"comment": "/* list of FunctionParameter nodes */"
},
{
"name": "args_unspecified",
"c_type": "bool",
"comment": "/* argument list was omitted? */"
}
],
"comment": "/*\n * ObjectWithArgs represents a function/procedure/operator name plus parameter\n * identification.\n *\n * objargs includes only the types of the input parameters of the object.\n * In some contexts, that will be all we have, and it's enough to look up\n * objects according to the traditional Postgres rules (i.e., when only input\n * arguments matter).\n *\n * objfuncargs, if not NIL, carries the full specification of the parameter\n * list, including parameter mode annotations.\n *\n * Some grammar productions can set args_unspecified = true instead of\n * providing parameter info. In this case, lookup will succeed only if\n * the object name is unique. Note that otherwise, NIL parameter lists\n * mean zero arguments.\n */\n"
},
"AccessPriv": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "priv_name",
"c_type": "char*",
"comment": "/* string name of privilege */"
},
{
"name": "cols",
"c_type": "List*",
"comment": "/* list of String */"
}
],
"comment": "/*\n * An access privilege, with optional list of column names\n * priv_name == NULL denotes ALL PRIVILEGES (only used with a column list)\n * cols == NIL denotes \"all columns\"\n * Note that simple \"ALL PRIVILEGES\" is represented as a NIL list, not\n * an AccessPriv with both fields null.\n */\n"
},
"GrantRoleStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "granted_roles",
"c_type": "List*",
"comment": "/* list of roles to be granted/revoked */"
},
{
"name": "grantee_roles",
"c_type": "List*",
"comment": "/* list of member roles to add/delete */"
},
{
"name": "is_grant",
"c_type": "bool",
"comment": "/* true = GRANT, false = REVOKE */"
},
{
"name": "opt",
"c_type": "List*",
"comment": "/* options e.g. WITH GRANT OPTION */"
},
{
"name": "grantor",
"c_type": "RoleSpec*",
"comment": "/* set grantor to other than current role */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* drop behavior (for REVOKE) */"
}
],
"comment": "/* ----------------------\n *\t\tGrant/Revoke Role Statement\n *\n * Note: because of the parsing ambiguity with the GRANT <privileges>\n * statement, granted_roles is a list of AccessPriv; the execution code\n * should complain if any column lists appear. grantee_roles is a list\n * of role names, as String values.\n * ----------------------\n */\n"
},
"AlterDefaultPrivilegesStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": "/* list of DefElem */"
},
{
"name": "action",
"c_type": "GrantStmt*",
"comment": "/* GRANT/REVOKE action (with objects=NIL) */"
}
],
"comment": "/* ----------------------\n *\tAlter Default Privileges Statement\n * ----------------------\n */\n"
},
"CopyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* the relation to copy */"
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* the query (SELECT or DML statement with\n\t\t\t\t\t\t\t\t * RETURNING) to copy, as a raw parse tree */\n"
},
{
"name": "attlist",
"c_type": "List*",
"comment": "/* List of column names (as Strings), or NIL\n\t\t\t\t\t\t\t\t * for all columns */\n"
},
{
"name": "is_from",
"c_type": "bool",
"comment": "/* TO or FROM */"
},
{
"name": "is_program",
"c_type": "bool",
"comment": "/* is 'filename' a program to popen? */"
},
{
"name": "filename",
"c_type": "char*",
"comment": "/* filename, or NULL for STDIN/STDOUT */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* WHERE condition (or NULL) */"
}
],
"comment": "/* ----------------------\n *\t\tCopy Statement\n *\n * We support \"COPY relation FROM file\", \"COPY relation TO file\", and\n * \"COPY (query) TO file\". In any given CopyStmt, exactly one of \"relation\"\n * and \"query\" must be non-NULL.\n * ----------------------\n */\n"
},
"VariableSetStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "VariableSetKind",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* variable to be set */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* List of A_Const nodes */"
},
{
"name": "is_local",
"c_type": "bool",
"comment": "/* SET LOCAL? */"
}
],
"comment": null
},
"VariableShowStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": null
}
],
"comment": "/* ----------------------\n * Show Statement\n * ----------------------\n */\n"
},
"CreateStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to create */"
},
{
"name": "tableElts",
"c_type": "List*",
"comment": "/* column definitions (list of ColumnDef) */"
},
{
"name": "inhRelations",
"c_type": "List*",
"comment": "/* relations to inherit from (list of\n\t\t\t\t\t\t\t\t * RangeVar) */\n"
},
{
"name": "partbound",
"c_type": "PartitionBoundSpec*",
"comment": "/* FOR VALUES clause */"
},
{
"name": "partspec",
"c_type": "PartitionSpec*",
"comment": "/* PARTITION BY clause */"
},
{
"name": "ofTypename",
"c_type": "TypeName*",
"comment": "/* OF typename */"
},
{
"name": "constraints",
"c_type": "List*",
"comment": "/* constraints (list of Constraint nodes) */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* options from WITH clause */"
},
{
"name": "oncommit",
"c_type": "OnCommitAction",
"comment": "/* what do we do at COMMIT? */"
},
{
"name": "tablespacename",
"c_type": "char*",
"comment": "/* table space to use, or NULL */"
},
{
"name": "accessMethod",
"c_type": "char*",
"comment": "/* table access method */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Table Statement\n *\n * NOTE: in the raw gram.y output, ColumnDef and Constraint nodes are\n * intermixed in tableElts, and constraints is NIL. After parse analysis,\n * tableElts contains just ColumnDefs, and constraints contains just\n * Constraint nodes (in fact, only CONSTR_CHECK nodes, in the present\n * implementation).\n * ----------------------\n */\n"
},
"Constraint": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "contype",
"c_type": "ConstrType",
"comment": "/* see above */"
},
{
"name": "conname",
"c_type": "char*",
"comment": "/* Constraint name, or NULL if unnamed */"
},
{
"name": "deferrable",
"c_type": "bool",
"comment": "/* DEFERRABLE? */"
},
{
"name": "initdeferred",
"c_type": "bool",
"comment": "/* INITIALLY DEFERRED? */"
},
{
"name": "skip_validation",
"c_type": "bool",
"comment": "/* skip validation of existing rows? */"
},
{
"name": "initially_valid",
"c_type": "bool",
"comment": "/* mark the new constraint as valid? */"
},
{
"name": "is_no_inherit",
"c_type": "bool",
"comment": "/* is constraint non-inheritable? */"
},
{
"name": "raw_expr",
"c_type": "Node*",
"comment": "/* CHECK or DEFAULT expression, as\n\t\t\t\t\t\t\t\t * untransformed parse tree */\n"
},
{
"name": "cooked_expr",
"c_type": "char*",
"comment": "/* CHECK or DEFAULT expression, as\n\t\t\t\t\t\t\t\t * nodeToString representation */\n"
},
{
"name": "generated_when",
"c_type": "char",
"comment": "/* ALWAYS or BY DEFAULT */"
},
{
"name": "inhcount",
"c_type": "int",
"comment": "/* initial inheritance count to apply, for\n\t\t\t\t\t\t\t\t * \"raw\" NOT NULL constraints */\n"
},
{
"name": "nulls_not_distinct",
"c_type": "bool",
"comment": "/* null treatment for UNIQUE constraints */"
},
{
"name": "keys",
"c_type": "List*",
"comment": "/* String nodes naming referenced key\n\t\t\t\t\t\t\t\t * column(s); for UNIQUE/PK/NOT NULL */\n"
},
{
"name": "including",
"c_type": "List*",
"comment": "/* String nodes naming referenced nonkey\n\t\t\t\t\t\t\t\t * column(s); for UNIQUE/PK */\n"
},
{
"name": "exclusions",
"c_type": "List*",
"comment": "/* list of (IndexElem, operator name) pairs;\n\t\t\t\t\t\t\t\t * for exclusion constraints */\n"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* options from WITH clause */"
},
{
"name": "indexname",
"c_type": "char*",
"comment": "/* existing index to use; otherwise NULL */"
},
{
"name": "indexspace",
"c_type": "char*",
"comment": "/* index tablespace; NULL for default */"
},
{
"name": "reset_default_tblspc",
"c_type": "bool",
"comment": "/* reset default_tablespace prior to\n\t\t\t\t\t\t\t\t\t\t * creating the index */\n"
},
{
"name": "access_method",
"c_type": "char*",
"comment": "/* index access method; NULL for default */"
},
{
"name": "where_clause",
"c_type": "Node*",
"comment": "/* partial index predicate */"
},
{
"comment": ""
},
{
"comment": "\t/* Fields used for FOREIGN KEY constraints: */\n"
},
{
"name": "pktable",
"c_type": "RangeVar*",
"comment": "/* Primary key table */"
},
{
"name": "fk_attrs",
"c_type": "List*",
"comment": "/* Attributes of foreign key */"
},
{
"name": "pk_attrs",
"c_type": "List*",
"comment": "/* Corresponding attrs in PK table */"
},
{
"name": "fk_matchtype",
"c_type": "char",
"comment": "/* FULL, PARTIAL, SIMPLE */"
},
{
"name": "fk_upd_action",
"c_type": "char",
"comment": "/* ON UPDATE action */"
},
{
"name": "fk_del_action",
"c_type": "char",
"comment": "/* ON DELETE action */"
},
{
"name": "fk_del_set_cols",
"c_type": "List*",
"comment": "/* ON DELETE SET NULL/DEFAULT (col1, col2) */"
},
{
"name": "old_conpfeqop",
"c_type": "List*",
"comment": "/* pg_constraint.conpfeqop of my former self */"
},
{
"name": "old_pktable_oid",
"c_type": "Oid",
"comment": "/* pg_constraint.confrelid of my former\n\t\t\t\t\t\t\t\t\t * self */\n"
},
{
"comment": ""
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/* Foreign key matchtype codes */\n"
},
"CreateTableSpaceStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "tablespacename",
"c_type": "char*",
"comment": null
},
{
"name": "owner",
"c_type": "RoleSpec*",
"comment": null
},
{
"name": "location",
"c_type": "char*",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tCreate/Drop Table Space Statements\n * ----------------------\n */\n"
},
"DropTableSpaceStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "tablespacename",
"c_type": "char*",
"comment": null
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if missing? */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Drop Table Space Statements\n * ----------------------\n */\n"
},
"AlterTableSpaceOptionsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "tablespacename",
"c_type": "char*",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": null
},
{
"name": "isReset",
"c_type": "bool",
"comment": null
}
],
"comment": null
},
"AlterTableMoveAllStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "orig_tablespacename",
"c_type": "char*",
"comment": null
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* Object type to move */"
},
{
"name": "roles",
"c_type": "List*",
"comment": "/* List of roles to move objects of */"
},
{
"name": "new_tablespacename",
"c_type": "char*",
"comment": null
},
{
"name": "nowait",
"c_type": "bool",
"comment": null
}
],
"comment": null
},
"CreateExtensionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "extname",
"c_type": "char*",
"comment": null
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter Extension Statements\n * ----------------------\n */\n"
},
"AlterExtensionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "extname",
"c_type": "char*",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* Only used for ALTER EXTENSION UPDATE; later might need an action field */\n"
},
"AlterExtensionContentsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "extname",
"c_type": "char*",
"comment": "/* Extension's name */"
},
{
"name": "action",
"c_type": "int",
"comment": "/* +1 = add object, -1 = drop object */"
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* Object's type */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* Qualified name of the object */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter Extension Statements\n * ----------------------\n */\n"
},
"CreateFdwStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "fdwname",
"c_type": "char*",
"comment": "/* foreign-data wrapper name */"
},
{
"name": "func_options",
"c_type": "List*",
"comment": "/* HANDLER/VALIDATOR options */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to FDW */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter FOREIGN DATA WRAPPER Statements\n * ----------------------\n */\n"
},
"AlterFdwStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "fdwname",
"c_type": "char*",
"comment": "/* foreign-data wrapper name */"
},
{
"name": "func_options",
"c_type": "List*",
"comment": "/* HANDLER/VALIDATOR options */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to FDW */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter FOREIGN DATA WRAPPER Statements\n * ----------------------\n */\n"
},
"CreateForeignServerStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "servername",
"c_type": "char*",
"comment": "/* server name */"
},
{
"name": "servertype",
"c_type": "char*",
"comment": "/* optional server type */"
},
{
"name": "version",
"c_type": "char*",
"comment": "/* optional server version */"
},
{
"name": "fdwname",
"c_type": "char*",
"comment": "/* FDW name */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to server */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter FOREIGN SERVER Statements\n * ----------------------\n */\n"
},
"AlterForeignServerStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "servername",
"c_type": "char*",
"comment": "/* server name */"
},
{
"name": "version",
"c_type": "char*",
"comment": "/* optional server version */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to server */"
},
{
"name": "has_version",
"c_type": "bool",
"comment": "/* version specified */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Alter FOREIGN SERVER Statements\n * ----------------------\n */\n"
},
"CreateForeignTableStmt": {
"fields": [
{
"name": "base",
"c_type": "CreateStmt",
"comment": null
},
{
"name": "servername",
"c_type": "char*",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tCreate FOREIGN TABLE Statement\n * ----------------------\n */\n"
},
"CreateUserMappingStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "user",
"c_type": "RoleSpec*",
"comment": "/* user role */"
},
{
"name": "servername",
"c_type": "char*",
"comment": "/* server name */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to server */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Drop USER MAPPING Statements\n * ----------------------\n */\n"
},
"AlterUserMappingStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "user",
"c_type": "RoleSpec*",
"comment": "/* user role */"
},
{
"name": "servername",
"c_type": "char*",
"comment": "/* server name */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* generic options to server */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Drop USER MAPPING Statements\n * ----------------------\n */\n"
},
"DropUserMappingStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "user",
"c_type": "RoleSpec*",
"comment": "/* user role */"
},
{
"name": "servername",
"c_type": "char*",
"comment": "/* server name */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* ignore missing mappings */"
}
],
"comment": "/* ----------------------\n *\t\tCreate/Drop USER MAPPING Statements\n * ----------------------\n */\n"
},
"ImportForeignSchemaStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "server_name",
"c_type": "char*",
"comment": "/* FDW server name */"
},
{
"name": "remote_schema",
"c_type": "char*",
"comment": "/* remote schema name to query */"
},
{
"name": "local_schema",
"c_type": "char*",
"comment": "/* local schema to create objects in */"
},
{
"name": "list_type",
"c_type": "ImportForeignSchemaType",
"comment": "/* type of table list */"
},
{
"name": "table_list",
"c_type": "List*",
"comment": "/* List of RangeVar */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* list of options to pass to FDW */"
}
],
"comment": null
},
"CreatePolicyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "policy_name",
"c_type": "char*",
"comment": "/* Policy's name */"
},
{
"name": "table",
"c_type": "RangeVar*",
"comment": "/* the table name the policy applies to */"
},
{
"name": "cmd_name",
"c_type": "char*",
"comment": "/* the command name the policy applies to */"
},
{
"name": "permissive",
"c_type": "bool",
"comment": "/* restrictive or permissive policy */"
},
{
"name": "roles",
"c_type": "List*",
"comment": "/* the roles associated with the policy */"
},
{
"name": "qual",
"c_type": "Node*",
"comment": "/* the policy's condition */"
},
{
"name": "with_check",
"c_type": "Node*",
"comment": "/* the policy's WITH CHECK condition. */"
}
],
"comment": "/*----------------------\n *\t\tCreate POLICY Statement\n *----------------------\n */\n"
},
"AlterPolicyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "policy_name",
"c_type": "char*",
"comment": "/* Policy's name */"
},
{
"name": "table",
"c_type": "RangeVar*",
"comment": "/* the table name the policy applies to */"
},
{
"name": "roles",
"c_type": "List*",
"comment": "/* the roles associated with the policy */"
},
{
"name": "qual",
"c_type": "Node*",
"comment": "/* the policy's condition */"
},
{
"name": "with_check",
"c_type": "Node*",
"comment": "/* the policy's WITH CHECK condition. */"
}
],
"comment": "/*----------------------\n *\t\tAlter POLICY Statement\n *----------------------\n */\n"
},
"CreateAmStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "amname",
"c_type": "char*",
"comment": "/* access method name */"
},
{
"name": "handler_name",
"c_type": "List*",
"comment": "/* handler function name */"
},
{
"name": "amtype",
"c_type": "char",
"comment": "/* type of access method */"
}
],
"comment": "/*----------------------\n *\t\tCreate ACCESS METHOD Statement\n *----------------------\n */\n"
},
"CreateTrigStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* replace trigger if already exists */"
},
{
"name": "isconstraint",
"c_type": "bool",
"comment": "/* This is a constraint trigger */"
},
{
"name": "trigname",
"c_type": "char*",
"comment": "/* TRIGGER's name */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation trigger is on */"
},
{
"name": "funcname",
"c_type": "List*",
"comment": "/* qual. name of function to call */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* list of String or NIL */"
},
{
"name": "row",
"c_type": "bool",
"comment": "/* ROW/STATEMENT */"
},
{
"comment": "\t/* timing uses the TRIGGER_TYPE bits defined in catalog/pg_trigger.h */\n"
},
{
"name": "timing",
"c_type": "int16",
"comment": "/* BEFORE, AFTER, or INSTEAD */"
},
{
"comment": "\t/* events uses the TRIGGER_TYPE bits defined in catalog/pg_trigger.h */\n"
},
{
"name": "events",
"c_type": "int16",
"comment": "/* \"OR\" of INSERT/UPDATE/DELETE/TRUNCATE */"
},
{
"name": "columns",
"c_type": "List*",
"comment": "/* column names, or NIL for all columns */"
},
{
"name": "whenClause",
"c_type": "Node*",
"comment": "/* qual expression, or NULL if none */"
},
{
"comment": "\t/* explicitly named transition data */\n"
},
{
"name": "transitionRels",
"c_type": "List*",
"comment": "/* TriggerTransition nodes, or NIL if none */"
},
{
"comment": "\t/* The remaining fields are only used for constraint triggers */\n"
},
{
"name": "deferrable",
"c_type": "bool",
"comment": "/* [NOT] DEFERRABLE */"
},
{
"name": "initdeferred",
"c_type": "bool",
"comment": "/* INITIALLY {DEFERRED|IMMEDIATE} */"
},
{
"name": "constrrel",
"c_type": "RangeVar*",
"comment": "/* opposite relation, if RI trigger */"
}
],
"comment": "/* ----------------------\n *\t\tCreate TRIGGER Statement\n * ----------------------\n */\n"
},
"CreateEventTrigStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "trigname",
"c_type": "char*",
"comment": "/* TRIGGER's name */"
},
{
"name": "eventname",
"c_type": "char*",
"comment": "/* event's identifier */"
},
{
"name": "whenclause",
"c_type": "List*",
"comment": "/* list of DefElems indicating filtering */"
},
{
"name": "funcname",
"c_type": "List*",
"comment": "/* qual. name of function to call */"
}
],
"comment": "/* ----------------------\n *\t\tCreate EVENT TRIGGER Statement\n * ----------------------\n */\n"
},
"AlterEventTrigStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "trigname",
"c_type": "char*",
"comment": "/* TRIGGER's name */"
},
{
"name": "tgenabled",
"c_type": "char",
"comment": "/* trigger's firing configuration WRT\n\t\t\t\t\t\t\t\t * session_replication_role */\n"
}
],
"comment": "/* ----------------------\n *\t\tAlter EVENT TRIGGER Statement\n * ----------------------\n */\n"
},
"CreatePLangStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* T => replace if already exists */"
},
{
"name": "plname",
"c_type": "char*",
"comment": "/* PL name */"
},
{
"name": "plhandler",
"c_type": "List*",
"comment": "/* PL call handler function (qual. name) */"
},
{
"name": "plinline",
"c_type": "List*",
"comment": "/* optional inline function (qual. name) */"
},
{
"name": "plvalidator",
"c_type": "List*",
"comment": "/* optional validator function (qual. name) */"
},
{
"name": "pltrusted",
"c_type": "bool",
"comment": "/* PL is trusted */"
}
],
"comment": "/* ----------------------\n *\t\tCreate LANGUAGE Statements\n * ----------------------\n */\n"
},
"CreateRoleStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "stmt_type",
"c_type": "RoleStmtType",
"comment": "/* ROLE/USER/GROUP */"
},
{
"name": "role",
"c_type": "char*",
"comment": "/* role name */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"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"
},
"AlterRoleStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "role",
"c_type": "RoleSpec*",
"comment": "/* role */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
},
{
"name": "action",
"c_type": "int",
"comment": "/* +1 = add members, -1 = drop members */"
}
],
"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"
},
"AlterRoleSetStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "role",
"c_type": "RoleSpec*",
"comment": "/* role */"
},
{
"name": "database",
"c_type": "char*",
"comment": "/* database name, or NULL */"
},
{
"name": "setstmt",
"c_type": "VariableSetStmt*",
"comment": "/* SET or RESET subcommand */"
}
],
"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"
},
"DropRoleStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "roles",
"c_type": "List*",
"comment": "/* List of roles to remove */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if a role is missing? */"
}
],
"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"
},
"CreateSeqStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "sequence",
"c_type": "RangeVar*",
"comment": "/* the sequence to create */"
},
{
"name": "options",
"c_type": "List*",
"comment": null
},
{
"name": "ownerId",
"c_type": "Oid",
"comment": "/* ID of owner, or InvalidOid for default */"
},
{
"name": "for_identity",
"c_type": "bool",
"comment": null
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
}
],
"comment": "/* ----------------------\n *\t\t{Create|Alter} SEQUENCE Statement\n * ----------------------\n */\n"
},
"AlterSeqStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "sequence",
"c_type": "RangeVar*",
"comment": "/* the sequence to alter */"
},
{
"name": "options",
"c_type": "List*",
"comment": null
},
{
"name": "for_identity",
"c_type": "bool",
"comment": null
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if a role is missing? */"
}
],
"comment": "/* ----------------------\n *\t\t{Create|Alter} SEQUENCE Statement\n * ----------------------\n */\n"
},
"DefineStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "ObjectType",
"comment": "/* aggregate, operator, type */"
},
{
"name": "oldstyle",
"c_type": "bool",
"comment": "/* hack to signal old CREATE AGG syntax */"
},
{
"name": "defnames",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* a list of TypeName (if needed) */"
},
{
"name": "definition",
"c_type": "List*",
"comment": "/* a list of DefElem */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* replace if already exists? */"
}
],
"comment": "/* ----------------------\n *\t\tCreate {Aggregate|Operator|Type} Statement\n * ----------------------\n */\n"
},
"CreateDomainStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "domainname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "typeName",
"c_type": "TypeName*",
"comment": "/* the base type */"
},
{
"name": "collClause",
"c_type": "CollateClause*",
"comment": "/* untransformed COLLATE spec, if any */"
},
{
"name": "constraints",
"c_type": "List*",
"comment": "/* constraints (list of Constraint nodes) */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Domain Statement\n * ----------------------\n */\n"
},
"CreateOpClassStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "opclassname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "opfamilyname",
"c_type": "List*",
"comment": "/* qualified name (ditto); NIL if omitted */"
},
{
"name": "amname",
"c_type": "char*",
"comment": "/* name of index AM opclass is for */"
},
{
"name": "datatype",
"c_type": "TypeName*",
"comment": "/* datatype of indexed column */"
},
{
"name": "items",
"c_type": "List*",
"comment": "/* List of CreateOpClassItem nodes */"
},
{
"name": "isDefault",
"c_type": "bool",
"comment": "/* Should be marked as default for type? */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Operator Class Statement\n * ----------------------\n */\n"
},
"CreateOpClassItem": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "itemtype",
"c_type": "int",
"comment": "/* see codes above */"
},
{
"name": "name",
"c_type": "ObjectWithArgs*",
"comment": "/* operator or function name and args */"
},
{
"name": "number",
"c_type": "int",
"comment": "/* strategy num or support proc num */"
},
{
"name": "order_family",
"c_type": "List*",
"comment": "/* only used for ordering operators */"
},
{
"name": "class_args",
"c_type": "List*",
"comment": "/* amproclefttype/amprocrighttype or\n\t\t\t\t\t\t\t\t * amoplefttype/amoprighttype */\n"
},
{
"comment": "\t/* fields used for a storagetype item: */\n"
},
{
"name": "storedtype",
"c_type": "TypeName*",
"comment": "/* datatype stored in index */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Operator Class Statement\n * ----------------------\n */\n"
},
"CreateOpFamilyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "opfamilyname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "amname",
"c_type": "char*",
"comment": "/* name of index AM opfamily is for */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Operator Family Statement\n * ----------------------\n */\n"
},
"AlterOpFamilyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "opfamilyname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "amname",
"c_type": "char*",
"comment": "/* name of index AM opfamily is for */"
},
{
"name": "isDrop",
"c_type": "bool",
"comment": "/* ADD or DROP the items? */"
},
{
"name": "items",
"c_type": "List*",
"comment": "/* List of CreateOpClassItem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Operator Family Statement\n * ----------------------\n */\n"
},
"DropStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objects",
"c_type": "List*",
"comment": "/* list of names */"
},
{
"name": "removeType",
"c_type": "ObjectType",
"comment": "/* object type */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE behavior */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if object is missing? */"
},
{
"name": "concurrent",
"c_type": "bool",
"comment": "/* drop index concurrently? */"
}
],
"comment": "/* ----------------------\n *\t\tDrop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement\n * ----------------------\n */\n"
},
"TruncateStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relations",
"c_type": "List*",
"comment": "/* relations (RangeVars) to be truncated */"
},
{
"name": "restart_seqs",
"c_type": "bool",
"comment": "/* restart owned sequences? */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE behavior */"
}
],
"comment": "/* ----------------------\n *\t\t\t\tTruncate Table Statement\n * ----------------------\n */\n"
},
"CommentStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* Object's type */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* Qualified name of the object */"
},
{
"name": "comment",
"c_type": "char*",
"comment": "/* Comment to insert, or NULL to remove */"
}
],
"comment": "/* ----------------------\n *\t\t\t\tComment On Statement\n * ----------------------\n */\n"
},
"SecLabelStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* Object's type */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* Qualified name of the object */"
},
{
"name": "provider",
"c_type": "char*",
"comment": "/* Label provider (or NULL) */"
},
{
"name": "label",
"c_type": "char*",
"comment": "/* New security label to be assigned */"
}
],
"comment": "/* ----------------------\n *\t\t\t\tSECURITY LABEL Statement\n * ----------------------\n */\n"
},
"DeclareCursorStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "portalname",
"c_type": "char*",
"comment": "/* name of the portal (cursor) */"
},
{
"name": "options",
"c_type": "int",
"comment": "/* bitmask of options (see above) */"
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* the query (see comments above) */"
}
],
"comment": "/* these planner-control flags do not correspond to any SQL grammar: */\n"
},
"ClosePortalStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "portalname",
"c_type": "char*",
"comment": "/* name of the portal (cursor) */"
},
{
"comment": "\t/* NULL means CLOSE ALL */\n"
}
],
"comment": "/* ----------------------\n *\t\tClose Portal Statement\n * ----------------------\n */\n"
},
"FetchStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "direction",
"c_type": "FetchDirection",
"comment": "/* see above */"
},
{
"name": "howMany",
"c_type": "long",
"comment": "/* number of rows, or position argument */"
},
{
"name": "portalname",
"c_type": "char*",
"comment": "/* name of portal (cursor) */"
},
{
"name": "ismove",
"c_type": "bool",
"comment": "/* true if MOVE */"
}
],
"comment": "/* ----------------------\n *\t\tFetch Statement (also Move)\n * ----------------------\n */\n"
},
"IndexStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "idxname",
"c_type": "char*",
"comment": "/* name of new index, or NULL for default */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to build index on */"
},
{
"name": "accessMethod",
"c_type": "char*",
"comment": "/* name of access method (eg. btree) */"
},
{
"name": "tableSpace",
"c_type": "char*",
"comment": "/* tablespace, or NULL for default */"
},
{
"name": "indexParams",
"c_type": "List*",
"comment": "/* columns to index: a list of IndexElem */"
},
{
"name": "indexIncludingParams",
"c_type": "List*",
"comment": "/* additional columns to index: a list\n\t\t\t\t\t\t\t\t\t\t * of IndexElem */\n"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* WITH clause options: a list of DefElem */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualification (partial-index predicate) */"
},
{
"name": "excludeOpNames",
"c_type": "List*",
"comment": "/* exclusion operator names, or NIL if none */"
},
{
"name": "idxcomment",
"c_type": "char*",
"comment": "/* comment to apply to index, or NULL */"
},
{
"name": "indexOid",
"c_type": "Oid",
"comment": "/* OID of an existing index, if any */"
},
{
"name": "oldNumber",
"c_type": "RelFileNumber",
"comment": "/* relfilenumber of existing storage, if any */"
},
{
"name": "oldCreateSubid",
"c_type": "SubTransactionId",
"comment": "/* rd_createSubid of oldNumber */"
},
{
"name": "oldFirstRelfilelocatorSubid",
"c_type": "SubTransactionId",
"comment": "/* rd_firstRelfilelocatorSubid\n\t\t\t\t\t\t\t\t\t\t\t\t\t * of oldNumber */\n"
},
{
"name": "unique",
"c_type": "bool",
"comment": "/* is index unique? */"
},
{
"name": "nulls_not_distinct",
"c_type": "bool",
"comment": "/* null treatment for UNIQUE constraints */"
},
{
"name": "primary",
"c_type": "bool",
"comment": "/* is index a primary key? */"
},
{
"name": "isconstraint",
"c_type": "bool",
"comment": "/* is it for a pkey/unique constraint? */"
},
{
"name": "deferrable",
"c_type": "bool",
"comment": "/* is the constraint DEFERRABLE? */"
},
{
"name": "initdeferred",
"c_type": "bool",
"comment": "/* is the constraint INITIALLY DEFERRED? */"
},
{
"name": "transformed",
"c_type": "bool",
"comment": "/* true when transformIndexStmt is finished */"
},
{
"name": "concurrent",
"c_type": "bool",
"comment": "/* should this be a concurrent index build? */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if index already exists? */"
},
{
"name": "reset_default_tblspc",
"c_type": "bool",
"comment": "/* reset default_tablespace prior to\n\t\t\t\t\t\t\t\t\t\t * executing */\n"
}
],
"comment": "/* ----------------------\n *\t\tCreate Index Statement\n *\n * This represents creation of an index and/or an associated constraint.\n * If isconstraint is true, we should create a pg_constraint entry along\n * with the index. But if indexOid isn't InvalidOid, we are not creating an\n * index, just a UNIQUE/PKEY constraint using an existing index. isconstraint\n * must always be true in this case, and the fields describing the index\n * properties are empty.\n * ----------------------\n */\n"
},
"CreateStatsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "defnames",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "stat_types",
"c_type": "List*",
"comment": "/* stat types (list of String) */"
},
{
"name": "exprs",
"c_type": "List*",
"comment": "/* expressions to build statistics on */"
},
{
"name": "relations",
"c_type": "List*",
"comment": "/* rels to build stats on (list of RangeVar) */"
},
{
"name": "stxcomment",
"c_type": "char*",
"comment": "/* comment to apply to stats, or NULL */"
},
{
"name": "transformed",
"c_type": "bool",
"comment": "/* true when transformStatsStmt is finished */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* do nothing if stats name already exists */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Statistics Statement\n * ----------------------\n */\n"
},
"StatsElem": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* name of attribute to index, or NULL */"
},
{
"name": "expr",
"c_type": "Node*",
"comment": "/* expression to index, or NULL */"
}
],
"comment": "/*\n * StatsElem - statistics parameters (used in CREATE STATISTICS)\n *\n * For a plain attribute, 'name' is the name of the referenced table column\n * and 'expr' is NULL. For an expression, 'name' is NULL and 'expr' is the\n * expression tree.\n */\n"
},
"AlterStatsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "defnames",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "stxstattarget",
"c_type": "Node*",
"comment": "/* statistics target */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if statistics object is missing */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Statistics Statement\n * ----------------------\n */\n"
},
"CreateFunctionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "is_procedure",
"c_type": "bool",
"comment": "/* it's really CREATE PROCEDURE */"
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* T => replace if already exists */"
},
{
"name": "funcname",
"c_type": "List*",
"comment": "/* qualified name of function to create */"
},
{
"name": "parameters",
"c_type": "List*",
"comment": "/* a list of FunctionParameter */"
},
{
"name": "returnType",
"c_type": "TypeName*",
"comment": "/* the return type */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* a list of DefElem */"
},
{
"name": "sql_body",
"c_type": "Node*",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tCreate Function Statement\n * ----------------------\n */\n"
},
"FunctionParameter": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* parameter name, or NULL if not given */"
},
{
"name": "argType",
"c_type": "TypeName*",
"comment": "/* TypeName for parameter type */"
},
{
"name": "mode",
"c_type": "FunctionParameterMode",
"comment": "/* IN/OUT/etc */"
},
{
"name": "defexpr",
"c_type": "Node*",
"comment": "/* raw default expr, or NULL if not given */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Function Statement\n * ----------------------\n */\n"
},
"AlterFunctionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": null
},
{
"name": "func",
"c_type": "ObjectWithArgs*",
"comment": "/* name and args of function */"
},
{
"name": "actions",
"c_type": "List*",
"comment": "/* list of DefElem */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Function Statement\n * ----------------------\n */\n"
},
"DoStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "args",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tDO Statement\n *\n * DoStmt is the raw parser output, InlineCodeBlock is the execution-time API\n * ----------------------\n */\n"
},
"InlineCodeBlock": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "source_text",
"c_type": "char*",
"comment": "/* source text of anonymous code block */"
},
{
"name": "langOid",
"c_type": "Oid",
"comment": "/* OID of selected language */"
},
{
"name": "langIsTrusted",
"c_type": "bool",
"comment": "/* trusted property of the language */"
},
{
"name": "atomic",
"c_type": "bool",
"comment": "/* atomic execution context */"
}
],
"comment": "/* ----------------------\n *\t\tDO Statement\n *\n * DoStmt is the raw parser output, InlineCodeBlock is the execution-time API\n * ----------------------\n */\n"
},
"CallStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": "\t/* from the parser */\n"
},
{
"name": "funccall",
"c_type": "FuncCall*",
"comment": null
},
{
"comment": "\t/* transformed call, with only input args */\n"
},
{
"name": "funcexpr",
"c_type": "FuncExpr*",
"comment": null
},
{
"comment": "\t/* transformed output-argument expressions */\n"
},
{
"name": "outargs",
"c_type": "List*",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tCALL statement\n *\n * OUT-mode arguments are removed from the transformed funcexpr. The outargs\n * list contains copies of the expressions for all output arguments, in the\n * order of the procedure's declared arguments. (outargs is never evaluated,\n * but is useful to the caller as a reference for what to assign to.)\n * The transformed call state is not relevant in the query jumbling, only the\n * function call is.\n * ----------------------\n */\n"
},
"CallContext": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "atomic",
"c_type": "bool",
"comment": null
}
],
"comment": null
},
"RenameStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "renameType",
"c_type": "ObjectType",
"comment": "/* OBJECT_TABLE, OBJECT_COLUMN, etc */"
},
{
"name": "relationType",
"c_type": "ObjectType",
"comment": "/* if column name, associated relation type */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* in case it's a table */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* in case it's some other object */"
},
{
"name": "subname",
"c_type": "char*",
"comment": "/* name of contained object (column, rule,\n\t\t\t\t\t\t\t\t * trigger, etc) */\n"
},
{
"name": "newname",
"c_type": "char*",
"comment": "/* the new name */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE behavior */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if missing? */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Object Rename Statement\n * ----------------------\n */\n"
},
"AlterObjectDependsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objectType",
"c_type": "ObjectType",
"comment": "/* OBJECT_FUNCTION, OBJECT_TRIGGER, etc */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* in case a table is involved */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* name of the object */"
},
{
"name": "extname",
"c_type": "String*",
"comment": "/* extension name */"
},
{
"name": "remove",
"c_type": "bool",
"comment": "/* set true to remove dep rather than add */"
}
],
"comment": "/* ----------------------\n * ALTER object DEPENDS ON EXTENSION extname\n * ----------------------\n */\n"
},
"AlterObjectSchemaStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objectType",
"c_type": "ObjectType",
"comment": "/* OBJECT_TABLE, OBJECT_TYPE, etc */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* in case it's a table */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* in case it's some other object */"
},
{
"name": "newschema",
"c_type": "char*",
"comment": "/* the new schema */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if missing? */"
}
],
"comment": "/* ----------------------\n *\t\tALTER object SET SCHEMA Statement\n * ----------------------\n */\n"
},
"AlterOwnerStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "objectType",
"c_type": "ObjectType",
"comment": "/* OBJECT_TABLE, OBJECT_TYPE, etc */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* in case it's a table */"
},
{
"name": "object",
"c_type": "Node*",
"comment": "/* in case it's some other object */"
},
{
"name": "newowner",
"c_type": "RoleSpec*",
"comment": "/* the new owner */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Object Owner Statement\n * ----------------------\n */\n"
},
"AlterOperatorStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "opername",
"c_type": "ObjectWithArgs*",
"comment": "/* operator name and argument types */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Operator Set ( this-n-that )\n * ----------------------\n */\n"
},
"AlterTypeStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typeName",
"c_type": "List*",
"comment": "/* type name (possibly qualified) */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ------------------------\n *\t\tAlter Type Set ( this-n-that )\n * ------------------------\n */\n"
},
"RuleStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation the rule is for */"
},
{
"name": "rulename",
"c_type": "char*",
"comment": "/* name of the rule */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualifications */"
},
{
"name": "event",
"c_type": "CmdType",
"comment": "/* SELECT, INSERT, etc */"
},
{
"name": "instead",
"c_type": "bool",
"comment": "/* is a 'do instead'? */"
},
{
"name": "actions",
"c_type": "List*",
"comment": "/* the action statements */"
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* OR REPLACE */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Rule Statement\n * ----------------------\n */\n"
},
"NotifyStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "conditionname",
"c_type": "char*",
"comment": "/* condition name to notify */"
},
{
"name": "payload",
"c_type": "char*",
"comment": "/* the payload string, or NULL if none */"
}
],
"comment": "/* ----------------------\n *\t\tNotify Statement\n * ----------------------\n */\n"
},
"ListenStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "conditionname",
"c_type": "char*",
"comment": "/* condition name to listen on */"
}
],
"comment": "/* ----------------------\n *\t\tListen Statement\n * ----------------------\n */\n"
},
"UnlistenStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "conditionname",
"c_type": "char*",
"comment": "/* name to unlisten on, or NULL for all */"
}
],
"comment": "/* ----------------------\n *\t\tUnlisten Statement\n * ----------------------\n */\n"
},
"TransactionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "TransactionStmtKind",
"comment": "/* see above */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* for BEGIN/START commands */"
},
{
"comment": "\t/* for savepoint commands */\n"
},
{
"name": "savepoint_name",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* for two-phase-commit related commands */\n"
},
{
"name": "gid",
"c_type": "char*",
"comment": null
},
{
"name": "chain",
"c_type": "bool",
"comment": "/* AND CHAIN option */"
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\t{Begin|Commit|Rollback} Transaction Statement\n * ----------------------\n */\n"
},
"CompositeTypeStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typevar",
"c_type": "RangeVar*",
"comment": "/* the composite type to be created */"
},
{
"name": "coldeflist",
"c_type": "List*",
"comment": "/* list of ColumnDef nodes */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Type Statement, composite types\n * ----------------------\n */\n"
},
"CreateEnumStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typeName",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "vals",
"c_type": "List*",
"comment": "/* enum values (list of String) */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Type Statement, enum types\n * ----------------------\n */\n"
},
"CreateRangeStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typeName",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "params",
"c_type": "List*",
"comment": "/* range parameters (list of DefElem) */"
}
],
"comment": "/* ----------------------\n *\t\tCreate Type Statement, range types\n * ----------------------\n */\n"
},
"AlterEnumStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "typeName",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "oldVal",
"c_type": "char*",
"comment": "/* old enum value's name, if renaming */"
},
{
"name": "newVal",
"c_type": "char*",
"comment": "/* new enum value's name */"
},
{
"name": "newValNeighbor",
"c_type": "char*",
"comment": "/* neighboring enum value, if specified */"
},
{
"name": "newValIsAfter",
"c_type": "bool",
"comment": "/* place new enum value after neighbor? */"
},
{
"name": "skipIfNewValExists",
"c_type": "bool",
"comment": "/* no error if new already exists? */"
}
],
"comment": "/* ----------------------\n *\t\tAlter Type Statement, enum types\n * ----------------------\n */\n"
},
"ViewStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "view",
"c_type": "RangeVar*",
"comment": "/* the view to be created */"
},
{
"name": "aliases",
"c_type": "List*",
"comment": "/* target column names */"
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* the SELECT query (as a raw parse tree) */"
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* replace an existing view? */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* options from WITH clause */"
},
{
"name": "withCheckOption",
"c_type": "ViewCheckOption",
"comment": "/* WITH CHECK OPTION */"
}
],
"comment": "/* ----------------------\n *\t\tCreate View Statement\n * ----------------------\n */\n"
},
"LoadStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "filename",
"c_type": "char*",
"comment": "/* file to load */"
}
],
"comment": "/* ----------------------\n *\t\tLoad Statement\n * ----------------------\n */\n"
},
"CreatedbStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dbname",
"c_type": "char*",
"comment": "/* name of database to create */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tCreatedb Statement\n * ----------------------\n */\n"
},
"AlterDatabaseStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dbname",
"c_type": "char*",
"comment": "/* name of database to alter */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\tAlter Database\n * ----------------------\n */\n"
},
"AlterDatabaseRefreshCollStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dbname",
"c_type": "char*",
"comment": null
}
],
"comment": null
},
"AlterDatabaseSetStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dbname",
"c_type": "char*",
"comment": "/* database name */"
},
{
"name": "setstmt",
"c_type": "VariableSetStmt*",
"comment": "/* SET or RESET subcommand */"
}
],
"comment": "/* ----------------------\n *\tAlter Database\n * ----------------------\n */\n"
},
"DropdbStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dbname",
"c_type": "char*",
"comment": "/* database to drop */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* skip error if db is missing? */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* currently only FORCE is supported */"
}
],
"comment": "/* ----------------------\n *\t\tDropdb Statement\n * ----------------------\n */\n"
},
"AlterSystemStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "setstmt",
"c_type": "VariableSetStmt*",
"comment": "/* SET subcommand */"
}
],
"comment": "/* ----------------------\n *\t\tAlter System Statement\n * ----------------------\n */\n"
},
"ClusterStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation being indexed, or NULL if all */"
},
{
"name": "indexname",
"c_type": "char*",
"comment": "/* original index defined */"
},
{
"name": "params",
"c_type": "List*",
"comment": "/* list of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tCluster Statement (support pbrown's cluster index implementation)\n * ----------------------\n */\n"
},
"VacuumStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "options",
"c_type": "List*",
"comment": "/* list of DefElem nodes */"
},
{
"name": "rels",
"c_type": "List*",
"comment": "/* list of VacuumRelation, or NIL for all */"
},
{
"name": "is_vacuumcmd",
"c_type": "bool",
"comment": "/* true for VACUUM, false for ANALYZE */"
}
],
"comment": "/* ----------------------\n *\t\tVacuum and Analyze Statements\n *\n * Even though these are nominally two statements, it's convenient to use\n * just one node type for both.\n * ----------------------\n */\n"
},
"VacuumRelation": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* table name to process, or NULL */"
},
{
"name": "oid",
"c_type": "Oid",
"comment": "/* table's OID; InvalidOid if not looked up */"
},
{
"name": "va_cols",
"c_type": "List*",
"comment": "/* list of column names, or NIL for all */"
}
],
"comment": "/*\n * Info about a single target table of VACUUM/ANALYZE.\n *\n * If the OID field is set, it always identifies the table to process.\n * Then the relation field can be NULL; if it isn't, it's used only to report\n * failure to open/lock the relation.\n */\n"
},
"ExplainStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* the query (see comments above) */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* list of DefElem nodes */"
}
],
"comment": "/* ----------------------\n *\t\tExplain Statement\n *\n * The \"query\" field is initially a raw parse tree, and is converted to a\n * Query node during parse analysis. Note that rewriting and planning\n * of the query are always postponed until execution.\n * ----------------------\n */\n"
},
"CreateTableAsStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* the query (see comments above) */"
},
{
"name": "into",
"c_type": "IntoClause*",
"comment": "/* destination table */"
},
{
"name": "objtype",
"c_type": "ObjectType",
"comment": "/* OBJECT_TABLE or OBJECT_MATVIEW */"
},
{
"name": "is_select_into",
"c_type": "bool",
"comment": "/* it was written as SELECT INTO */"
},
{
"name": "if_not_exists",
"c_type": "bool",
"comment": "/* just do nothing if it already exists? */"
}
],
"comment": "/* ----------------------\n *\t\tCREATE TABLE AS Statement (a/k/a SELECT INTO)\n *\n * A query written as CREATE TABLE AS will produce this node type natively.\n * A query written as SELECT ... INTO will be transformed to this form during\n * parse analysis.\n * A query written as CREATE MATERIALIZED view will produce this node type,\n * during parse analysis, since it needs all the same data.\n *\n * The \"query\" field is handled similarly to EXPLAIN, though note that it\n * can be a SELECT or an EXECUTE, but not other DML statements.\n * ----------------------\n */\n"
},
"RefreshMatViewStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "concurrent",
"c_type": "bool",
"comment": "/* allow concurrent access? */"
},
{
"name": "skipData",
"c_type": "bool",
"comment": "/* true for WITH NO DATA */"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to insert into */"
}
],
"comment": "/* ----------------------\n *\t\tREFRESH MATERIALIZED VIEW Statement\n * ----------------------\n */\n"
},
"CheckPointStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
}
],
"comment": "/* ----------------------\n * Checkpoint Statement\n * ----------------------\n */\n"
},
"DiscardStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "target",
"c_type": "DiscardMode",
"comment": null
}
],
"comment": "/* ----------------------\n * Discard Statement\n * ----------------------\n */\n"
},
"LockStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relations",
"c_type": "List*",
"comment": "/* relations to lock */"
},
{
"name": "mode",
"c_type": "int",
"comment": "/* lock mode */"
},
{
"name": "nowait",
"c_type": "bool",
"comment": "/* no wait mode */"
}
],
"comment": "/* ----------------------\n *\t\tLOCK Statement\n * ----------------------\n */\n"
},
"ConstraintsSetStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "constraints",
"c_type": "List*",
"comment": "/* List of names as RangeVars */"
},
{
"name": "deferred",
"c_type": "bool",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tSET CONSTRAINTS Statement\n * ----------------------\n */\n"
},
"ReindexStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "ReindexObjectType",
"comment": "/* REINDEX_OBJECT_INDEX, REINDEX_OBJECT_TABLE,\n\t\t\t\t\t\t\t\t * etc. */\n"
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* Table or index to reindex */"
},
{
"name": "name",
"c_type": "char*",
"comment": "/* name of database to reindex */"
},
{
"name": "params",
"c_type": "List*",
"comment": "/* list of DefElem nodes */"
}
],
"comment": null
},
"CreateConversionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "conversion_name",
"c_type": "List*",
"comment": "/* Name of the conversion */"
},
{
"name": "for_encoding_name",
"c_type": "char*",
"comment": "/* source encoding name */"
},
{
"name": "to_encoding_name",
"c_type": "char*",
"comment": "/* destination encoding name */"
},
{
"name": "func_name",
"c_type": "List*",
"comment": "/* qualified conversion function name */"
},
{
"name": "def",
"c_type": "bool",
"comment": "/* is this a default conversion? */"
}
],
"comment": "/* ----------------------\n *\t\tCREATE CONVERSION Statement\n * ----------------------\n */\n"
},
"CreateCastStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "sourcetype",
"c_type": "TypeName*",
"comment": null
},
{
"name": "targettype",
"c_type": "TypeName*",
"comment": null
},
{
"name": "func",
"c_type": "ObjectWithArgs*",
"comment": null
},
{
"name": "context",
"c_type": "CoercionContext",
"comment": null
},
{
"name": "inout",
"c_type": "bool",
"comment": null
}
],
"comment": "/* ----------------------\n *\tCREATE CAST Statement\n * ----------------------\n */\n"
},
"CreateTransformStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "replace",
"c_type": "bool",
"comment": null
},
{
"name": "type_name",
"c_type": "TypeName*",
"comment": null
},
{
"name": "lang",
"c_type": "char*",
"comment": null
},
{
"name": "fromsql",
"c_type": "ObjectWithArgs*",
"comment": null
},
{
"name": "tosql",
"c_type": "ObjectWithArgs*",
"comment": null
}
],
"comment": "/* ----------------------\n *\tCREATE TRANSFORM Statement\n * ----------------------\n */\n"
},
"PrepareStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* Name of plan, arbitrary */"
},
{
"name": "argtypes",
"c_type": "List*",
"comment": "/* Types of parameters (List of TypeName) */"
},
{
"name": "query",
"c_type": "Node*",
"comment": "/* The query itself (as a raw parsetree) */"
}
],
"comment": "/* ----------------------\n *\t\tPREPARE Statement\n * ----------------------\n */\n"
},
"ExecuteStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": "/* The name of the plan to execute */"
},
{
"name": "params",
"c_type": "List*",
"comment": "/* Values to assign to parameters */"
}
],
"comment": "/* ----------------------\n *\t\tEXECUTE Statement\n * ----------------------\n */\n"
},
"DeallocateStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": "\t/* The name of the plan to remove, NULL if DEALLOCATE ALL */\n"
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * True if DEALLOCATE ALL. This is redundant with \"name == NULL\", but we\n\t * make it a separate field so that exactly this condition (and not the\n\t * precise name) will be accounted for in query jumbling.\n\t */\n"
},
{
"name": "isall",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/* ----------------------\n *\t\tDEALLOCATE Statement\n * ----------------------\n */\n"
},
"DropOwnedStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "roles",
"c_type": "List*",
"comment": null
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": null
}
],
"comment": "/*\n *\t\tDROP OWNED statement\n */\n"
},
"ReassignOwnedStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "roles",
"c_type": "List*",
"comment": null
},
{
"name": "newrole",
"c_type": "RoleSpec*",
"comment": null
}
],
"comment": "/*\n *\t\tREASSIGN OWNED statement\n */\n"
},
"AlterTSDictionaryStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "dictname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": "/*\n * TS Dictionary stmts: DefineStmt, RenameStmt and DropStmt are default\n */\n"
},
"AlterTSConfigurationStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "AlterTSConfigType",
"comment": "/* ALTER_TSCONFIG_ADD_MAPPING, etc */"
},
{
"name": "cfgname",
"c_type": "List*",
"comment": "/* qualified name (list of String) */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * dicts will be non-NIL if ADD/ALTER MAPPING was specified. If dicts is\n\t * NIL, but tokentype isn't, DROP MAPPING was specified.\n\t */\n"
},
{
"name": "tokentype",
"c_type": "List*",
"comment": "/* list of String */"
},
{
"name": "dicts",
"c_type": "List*",
"comment": "/* list of list of String */"
},
{
"name": "override",
"c_type": "bool",
"comment": "/* if true - remove old variant */"
},
{
"name": "replace",
"c_type": "bool",
"comment": "/* if true - replace dictionary by another */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* for DROP - skip error if missing? */"
}
],
"comment": null
},
"PublicationTable": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "relation",
"c_type": "RangeVar*",
"comment": "/* relation to be published */"
},
{
"name": "whereClause",
"c_type": "Node*",
"comment": "/* qualifications */"
},
{
"name": "columns",
"c_type": "List*",
"comment": "/* List of columns in a publication table */"
}
],
"comment": null
},
"PublicationObjSpec": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "pubobjtype",
"c_type": "PublicationObjSpecType",
"comment": "/* type of this publication object */"
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"name": "pubtable",
"c_type": "PublicationTable*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": null
},
"CreatePublicationStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "pubname",
"c_type": "char*",
"comment": "/* Name of the publication */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
},
{
"name": "pubobjects",
"c_type": "List*",
"comment": "/* Optional list of publication objects */"
},
{
"name": "for_all_tables",
"c_type": "bool",
"comment": "/* Special publication for all tables in db */"
}
],
"comment": null
},
"AlterPublicationStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "pubname",
"c_type": "char*",
"comment": "/* Name of the publication */"
},
{
"comment": ""
},
{
"comment": "\t/* parameters used for ALTER PUBLICATION ... WITH */\n"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Parameters used for ALTER PUBLICATION ... ADD/DROP/SET publication\n\t * objects.\n\t */\n"
},
{
"name": "pubobjects",
"c_type": "List*",
"comment": "/* Optional list of publication objects */"
},
{
"name": "for_all_tables",
"c_type": "bool",
"comment": "/* Special publication for all tables in db */"
},
{
"name": "action",
"c_type": "AlterPublicationAction",
"comment": "/* What action to perform with the given\n\t\t\t\t\t\t\t\t\t * objects */\n"
}
],
"comment": null
},
"CreateSubscriptionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "subname",
"c_type": "char*",
"comment": "/* Name of the subscription */"
},
{
"name": "conninfo",
"c_type": "char*",
"comment": "/* Connection string to publisher */"
},
{
"name": "publication",
"c_type": "List*",
"comment": "/* One or more publication to subscribe to */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": null
},
"AlterSubscriptionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "kind",
"c_type": "AlterSubscriptionType",
"comment": "/* ALTER_SUBSCRIPTION_OPTIONS, etc */"
},
{
"name": "subname",
"c_type": "char*",
"comment": "/* Name of the subscription */"
},
{
"name": "conninfo",
"c_type": "char*",
"comment": "/* Connection string to publisher */"
},
{
"name": "publication",
"c_type": "List*",
"comment": "/* One or more publication to subscribe to */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* List of DefElem nodes */"
}
],
"comment": null
},
"DropSubscriptionStmt": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "subname",
"c_type": "char*",
"comment": "/* Name of the subscription */"
},
{
"name": "missing_ok",
"c_type": "bool",
"comment": "/* Skip error if missing? */"
},
{
"name": "behavior",
"c_type": "DropBehavior",
"comment": "/* RESTRICT or CASCADE behavior */"
}
],
"comment": null
}
},
"nodes/primnodes": {
"Alias": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "aliasname",
"c_type": "char*",
"comment": "/* aliased rel name (never qualified) */"
},
{
"name": "colnames",
"c_type": "List*",
"comment": "/* optional list of column aliases */"
}
],
"comment": "/*\n * Alias -\n *\t specifies an alias for a range variable; the alias might also\n *\t specify renaming of columns within the table.\n *\n * Note: colnames is a list of String nodes. In Alias structs\n * associated with RTEs, there may be entries corresponding to dropped\n * columns; these are normally empty strings (\"\"). See parsenodes.h for info.\n */\n"
},
"RangeVar": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* the catalog (database) name, or NULL */\n"
},
{
"name": "catalogname",
"c_type": "char*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* the schema name, or NULL */\n"
},
{
"name": "schemaname",
"c_type": "char*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* the relation/sequence name */\n"
},
{
"name": "relname",
"c_type": "char*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* expand rel by inheritance? recursively act on children? */\n"
},
{
"name": "inh",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* see RELPERSISTENCE_* in pg_class.h */\n"
},
{
"name": "relpersistence",
"c_type": "char",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* table alias & optional column aliases */\n"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * RangeVar - range variable, used in FROM clauses\n *\n * Also used to represent table names in utility statements; there, the alias\n * field is not used, and inh tells whether to apply the operation\n * recursively to child tables. In some contexts it is also useful to carry\n * a TEMP table indication here.\n */\n"
},
"TableFunc": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": "\t/* XMLTABLE or JSON_TABLE */\n"
},
{
"name": "functype",
"c_type": "TableFuncType",
"comment": null
},
{
"comment": "\t/* list of namespace URI expressions */\n"
},
{
"name": "ns_uris",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* list of namespace names or NULL */\n"
},
{
"name": "ns_names",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* input document expression */\n"
},
{
"name": "docexpr",
"c_type": "Node*",
"comment": null
},
{
"comment": "\t/* row filter expression */\n"
},
{
"name": "rowexpr",
"c_type": "Node*",
"comment": null
},
{
"comment": "\t/* column names (list of String) */\n"
},
{
"name": "colnames",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column type OIDs */\n"
},
{
"name": "coltypes",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* integer list of column typmods */\n"
},
{
"name": "coltypmods",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of column collation OIDs */\n"
},
{
"name": "colcollations",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* list of column filter expressions */\n"
},
{
"name": "colexprs",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* list of column default expressions */\n"
},
{
"name": "coldefexprs",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* JSON_TABLE: list of column value expressions */\n"
},
{
"name": "colvalexprs",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* JSON_TABLE: list of PASSING argument expressions */\n"
},
{
"name": "passingvalexprs",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* nullability flag for each output column */\n"
},
{
"name": "notnulls",
"c_type": "Bitmapset*",
"comment": null
},
{
"comment": "\t/* JSON_TABLE plan */\n"
},
{
"name": "plan",
"c_type": "Node*",
"comment": null
},
{
"comment": "\t/* counts from 0; -1 if none specified */\n"
},
{
"name": "ordinalitycol",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * TableFunc - node for a table function, such as XMLTABLE and JSON_TABLE.\n *\n * Entries in the ns_names list are either String nodes containing\n * literal namespace names, or NULL pointers to represent DEFAULT.\n */\n"
},
"IntoClause": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "rel",
"c_type": "RangeVar*",
"comment": "/* target relation name */"
},
{
"name": "colNames",
"c_type": "List*",
"comment": "/* column names to assign, or NIL */"
},
{
"name": "accessMethod",
"c_type": "char*",
"comment": "/* table access method */"
},
{
"name": "options",
"c_type": "List*",
"comment": "/* options from WITH clause */"
},
{
"name": "onCommit",
"c_type": "OnCommitAction",
"comment": "/* what do we do at COMMIT? */"
},
{
"name": "tableSpaceName",
"c_type": "char*",
"comment": "/* table space to use, or NULL */"
},
{
"comment": "\t/* materialized view's SELECT query */\n"
},
{
"name": "viewQuery",
"c_type": "Node*",
"comment": null
},
{
"name": "skipData",
"c_type": "bool",
"comment": "/* true for WITH NO DATA */"
}
],
"comment": "/*\n * IntoClause - target information for SELECT INTO, CREATE TABLE AS, and\n * CREATE MATERIALIZED VIEW\n *\n * For CREATE MATERIALIZED VIEW, viewQuery is the parsed-but-not-rewritten\n * SELECT Query for the view; otherwise it's NULL. This is irrelevant in\n * the query jumbling as CreateTableAsStmt already includes a reference to\n * its own Query, so ignore it. (Although it's actually Query*, we declare\n * it as Node* to avoid a forward reference.)\n */\n"
},
"Expr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
}
],
"comment": "/*\n * Expr - generic superclass for executable-expression nodes\n *\n * All node types that are used in executable expression trees should derive\n * from Expr (that is, have Expr as their first field). Since Expr only\n * contains NodeTag, this is a formality, but it is an easy form of\n * documentation. See also the ExprState node types in execnodes.h.\n */\n"
},
"Var": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * index of this var's relation in the range table, or\n\t * INNER_VAR/OUTER_VAR/etc\n\t */\n"
},
{
"name": "varno",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * attribute number of this var, or zero for all attrs (\"whole-row Var\")\n\t */\n"
},
{
"name": "varattno",
"c_type": "AttrNumber",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* pg_type OID for the type of this var */\n"
},
{
"name": "vartype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* pg_attribute typmod value */\n"
},
{
"name": "vartypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "varcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * RT indexes of outer joins that can replace the Var's value with null.\n\t * We can omit varnullingrels in the query jumble, because it's fully\n\t * determined by varno/varlevelsup plus the Var's query location.\n\t */\n"
},
{
"name": "varnullingrels",
"c_type": "Bitmapset*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * for subquery variables referencing outer relations; 0 in a normal var,\n\t * >0 means N levels up\n\t */\n"
},
{
"name": "varlevelsup",
"c_type": "Index",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * varnosyn/varattnosyn are ignored for equality, because Vars with\n\t * different syntactic identifiers are semantically the same as long as\n\t * their varno/varattno match.\n\t */\n"
},
{
"comment": "\t/* syntactic relation index (0 if unknown) */\n"
},
{
"comment": ""
},
{
"comment": "\t/* syntactic attribute number */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/* Symbols for the indexes of the special RTE entries in rules */\n"
},
"Const": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* pg_type OID of the constant's datatype */\n"
},
{
"name": "consttype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* typmod value, if any */\n"
},
{
"name": "consttypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "constcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* typlen of the constant's datatype */\n"
},
{
"name": "constlen",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* the constant's value */\n"
},
{
"name": "constvalue",
"c_type": "Datum",
"comment": null
},
{
"comment": "\t/* whether the constant is null (if true, constvalue is undefined) */\n"
},
{
"name": "constisnull",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Whether this datatype is passed by value. If true, then all the\n\t * information is stored in the Datum. If false, then the Datum contains\n\t * a pointer to the information.\n\t */\n"
},
{
"name": "constbyval",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * token location, or -1 if unknown. All constants are tracked as\n\t * locations in query jumbling, to be marked as parameters.\n\t */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * Const\n *\n * Note: for varlena data types, we make a rule that a Const node's value\n * must be in non-extended form (4-byte header, no compression or external\n * references). This ensures that the Const node is self-contained and makes\n * it more likely that equal() will see logically identical values as equal.\n *\n * Only the constant type OID is relevant for the query jumbling.\n */\n"
},
"Param": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "paramkind",
"c_type": "ParamKind",
"comment": "/* kind of parameter. See above */"
},
{
"name": "paramid",
"c_type": "int",
"comment": "/* numeric ID for parameter */"
},
{
"name": "paramtype",
"c_type": "Oid",
"comment": "/* pg_type OID of parameter's datatype */"
},
{
"comment": "\t/* typmod value, if known */\n"
},
{
"name": "paramtypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "paramcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"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"
},
"Aggref": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* pg_proc Oid of the aggregate */\n"
},
{
"name": "aggfnoid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* type Oid of result of the aggregate */\n"
},
{
"name": "aggtype",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* OID of collation of result */\n"
},
{
"name": "aggcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* OID of collation that function should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * type Oid of aggregate's transition value; ignored for equal since it\n\t * might not be set yet\n\t */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* type Oids of direct and aggregated args */\n"
},
{
"name": "aggargtypes",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* direct arguments, if an ordered-set agg */\n"
},
{
"name": "aggdirectargs",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* aggregated arguments and sort expressions */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* ORDER BY (list of SortGroupClause) */\n"
},
{
"name": "aggorder",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* DISTINCT (list of SortGroupClause) */\n"
},
{
"name": "aggdistinct",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* FILTER expression, if any */\n"
},
{
"name": "aggfilter",
"c_type": "Expr*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* true if argument list was really '*' */\n"
},
{
"name": "aggstar",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * true if variadic arguments have been combined into an array last\n\t * argument\n\t */\n"
},
{
"name": "aggvariadic",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* aggregate kind (see pg_aggregate.h) */\n"
},
{
"name": "aggkind",
"c_type": "char",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* aggregate input already sorted */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* > 0 if agg belongs to outer query */\n"
},
{
"name": "agglevelsup",
"c_type": "Index",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* expected agg-splitting mode of parent Agg */\n"
},
{
"name": "aggsplit",
"c_type": "AggSplit",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* unique ID within the Agg node */\n"
},
{
"name": "aggno",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* unique ID of transition state in the Agg */\n"
},
{
"name": "aggtransno",
"c_type": "int",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * Aggref\n *\n * The aggregate's args list is a targetlist, ie, a list of TargetEntry nodes.\n *\n * For a normal (non-ordered-set) aggregate, the non-resjunk TargetEntries\n * represent the aggregate's regular arguments (if any) and resjunk TLEs can\n * be added at the end to represent ORDER BY expressions that are not also\n * arguments. As in a top-level Query, the TLEs can be marked with\n * ressortgroupref indexes to let them be referenced by SortGroupClause\n * entries in the aggorder and/or aggdistinct lists. This represents ORDER BY\n * and DISTINCT operations to be applied to the aggregate input rows before\n * they are passed to the transition function. The grammar only allows a\n * simple \"DISTINCT\" specifier for the arguments, but we use the full\n * query-level representation to allow more code sharing.\n *\n * For an ordered-set aggregate, the args list represents the WITHIN GROUP\n * (aggregated) arguments, all of which will be listed in the aggorder list.\n * DISTINCT is not supported in this case, so aggdistinct will be NIL.\n * The direct arguments appear in aggdirectargs (as a list of plain\n * expressions, not TargetEntry nodes).\n *\n * aggtranstype is the data type of the state transition values for this\n * aggregate (resolved to an actual type, if agg's transtype is polymorphic).\n * This is determined during planning and is InvalidOid before that.\n *\n * aggargtypes is an OID list of the data types of the direct and regular\n * arguments. Normally it's redundant with the aggdirectargs and args lists,\n * but in a combining aggregate, it's not because the args list has been\n * replaced with a single argument representing the partial-aggregate\n * transition values.\n *\n * aggpresorted is set by the query planner for ORDER BY and DISTINCT\n * aggregates where the chosen plan provides presorted input for this\n * aggregate during execution.\n *\n * aggsplit indicates the expected partial-aggregation mode for the Aggref's\n * parent plan node. It's always set to AGGSPLIT_SIMPLE in the parser, but\n * the planner might change it to something else. We use this mainly as\n * a crosscheck that the Aggrefs match the plan; but note that when aggsplit\n * indicates a non-final mode, aggtype reflects the transition data type\n * not the SQL-level output type of the aggregate.\n *\n * aggno and aggtransno are -1 in the parse stage, and are set in planning.\n * Aggregates with the same 'aggno' represent the same aggregate expression,\n * and can share the result. Aggregates with same 'transno' but different\n * 'aggno' can share the same transition state, only the final function needs\n * to be called separately.\n *\n * Information related to collations, transition types and internal states\n * are irrelevant for the query jumbling.\n */\n"
},
"GroupingFunc": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* arguments, not evaluated but kept for benefit of EXPLAIN etc. */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* ressortgrouprefs of arguments */\n"
},
{
"name": "refs",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* actual column positions set by planner */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* same as Aggref.agglevelsup */\n"
},
{
"name": "agglevelsup",
"c_type": "Index",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* token location */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * GroupingFunc\n *\n * A GroupingFunc is a GROUPING(...) expression, which behaves in many ways\n * like an aggregate function (e.g. it \"belongs\" to a specific query level,\n * which might not be the one immediately containing it), but also differs in\n * an important respect: it never evaluates its arguments, they merely\n * designate expressions from the GROUP BY clause of the query level to which\n * it belongs.\n *\n * The spec defines the evaluation of GROUPING() purely by syntactic\n * replacement, but we make it a real expression for optimization purposes so\n * that one Agg node can handle multiple grouping sets at once. Evaluating the\n * result only needs the column positions to check against the grouping set\n * being projected. However, for EXPLAIN to produce meaningful output, we have\n * to keep the original expressions around, since expression deparse does not\n * give us any feasible way to get at the GROUP BY clause.\n *\n * Also, we treat two GroupingFunc nodes as equal if they have equal arguments\n * lists and agglevelsup, without comparing the refs and cols annotations.\n *\n * In raw parse output we have only the args list; parse analysis fills in the\n * refs list, and the planner fills in the cols list.\n *\n * All the fields used as information for an internal state are irrelevant\n * for the query jumbling.\n */\n"
},
"WindowFunc": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* pg_proc Oid of the function */\n"
},
{
"name": "winfnoid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* type Oid of result of the window function */\n"
},
{
"name": "wintype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation of result */\n"
},
{
"name": "wincollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation that function should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* arguments to the window function */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* FILTER expression, if any */\n"
},
{
"name": "aggfilter",
"c_type": "Expr*",
"comment": null
},
{
"comment": "\t/* List of WindowFuncRunConditions to help short-circuit execution */\n"
},
{
"name": "runCondition",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* index of associated WindowClause */\n"
},
{
"name": "winref",
"c_type": "Index",
"comment": null
},
{
"comment": "\t/* true if argument list was really '*' */\n"
},
{
"name": "winstar",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* is function a simple aggregate? */\n"
},
{
"name": "winagg",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * WindowFunc\n *\n * Collation information is irrelevant for the query jumbling, as is the\n * internal state information of the node like \"winstar\" and \"winagg\".\n */\n"
},
"WindowFuncRunCondition": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* PG_OPERATOR OID of the operator */\n"
},
{
"name": "opno",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation that operator should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * true of WindowFunc belongs on the left of the resulting OpExpr or false\n\t * if the WindowFunc is on the right.\n\t */\n"
},
{
"name": "wfunc_left",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * The Expr being compared to the WindowFunc to use in the OpExpr in the\n\t * WindowAgg's runCondition\n\t */\n"
},
{
"name": "arg",
"c_type": "Expr*",
"comment": null
}
],
"comment": "/*\n * WindowFuncRunCondition\n *\n * Represents intermediate OpExprs which will be used by WindowAgg to\n * short-circuit execution.\n */\n"
},
"MergeSupportFunc": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type Oid of result */\n"
},
{
"name": "msftype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "msfcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * MergeSupportFunc\n *\n * A MergeSupportFunc is a merge support function expression that can only\n * appear in the RETURNING list of a MERGE command. It returns information\n * about the currently executing merge action.\n *\n * Currently, the only supported function is MERGE_ACTION(), which returns the\n * command executed (\"INSERT\", \"UPDATE\", or \"DELETE\").\n */\n"
},
"SubscriptingRef": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type of the container proper */\n"
},
{
"name": "refcontainertype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* the container type's pg_type.typelem */\n"
},
{
"name": "refelemtype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* type of the SubscriptingRef's result */\n"
},
{
"name": "refrestype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* typmod of the result */\n"
},
{
"name": "reftypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* collation of result, or InvalidOid if none */\n"
},
{
"name": "refcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* expressions that evaluate to upper container indexes */\n"
},
{
"name": "refupperindexpr",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * expressions that evaluate to lower container indexes, or NIL for single\n\t * container element.\n\t */\n"
},
{
"name": "reflowerindexpr",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* the expression that evaluates to a container value */\n"
},
{
"name": "refexpr",
"c_type": "Expr*",
"comment": null
},
{
"comment": "\t/* expression for the source value, or NULL if fetch */\n"
},
{
"name": "refassgnexpr",
"c_type": "Expr*",
"comment": null
}
],
"comment": "/*\n * SubscriptingRef: describes a subscripting operation over a container\n * (array, etc).\n *\n * A SubscriptingRef can describe fetching a single element from a container,\n * fetching a part of a container (e.g. an array slice), storing a single\n * element into a container, or storing a slice. The \"store\" cases work with\n * an initial container value and a source value that is inserted into the\n * appropriate part of the container; the result of the operation is an\n * entire new modified container value.\n *\n * If reflowerindexpr = NIL, then we are fetching or storing a single container\n * element at the subscripts given by refupperindexpr. Otherwise we are\n * fetching or storing a container slice, that is a rectangular subcontainer\n * with lower and upper bounds given by the index expressions.\n * reflowerindexpr must be the same length as refupperindexpr when it\n * is not NIL.\n *\n * In the slice case, individual expressions in the subscript lists can be\n * NULL, meaning \"substitute the array's current lower or upper bound\".\n * (Non-array containers may or may not support this.)\n *\n * refcontainertype is the actual container type that determines the\n * subscripting semantics. (This will generally be either the exposed type of\n * refexpr, or the base type if that is a domain.) refelemtype is the type of\n * the container's elements; this is saved for the use of the subscripting\n * functions, but is not used by the core code. refrestype, reftypmod, and\n * refcollid describe the type of the SubscriptingRef's result. In a store\n * expression, refrestype will always match refcontainertype; in a fetch,\n * it could be refelemtype for an element fetch, or refcontainertype for a\n * slice fetch, or possibly something else as determined by type-specific\n * subscripting logic. Likewise, reftypmod and refcollid will match the\n * container's properties in a store, but could be different in a fetch.\n *\n * Any internal state data is ignored for the query jumbling.\n *\n * Note: for the cases where a container is returned, if refexpr yields a R/W\n * expanded container, then the implementation is allowed to modify that\n * object in-place and return the same object.\n */\n"
},
"FuncExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* PG_PROC OID of the function */\n"
},
{
"name": "funcid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* PG_TYPE OID of result value */\n"
},
{
"name": "funcresulttype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* true if function returns set */\n"
},
{
"name": "funcretset",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * true if variadic arguments have been combined into an array last\n\t * argument\n\t */\n"
},
{
"name": "funcvariadic",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* how to display this function call */\n"
},
{
"name": "funcformat",
"c_type": "CoercionForm",
"comment": null
},
{
"comment": "\t/* OID of collation of result */\n"
},
{
"name": "funccollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation that function should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* arguments to the function */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * FuncExpr - expression node for a function call\n *\n * Collation information is irrelevant for the query jumbling, only the\n * arguments and the function OID matter.\n */\n"
},
"NamedArgExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* the argument expression */\n"
},
{
"name": "arg",
"c_type": "Expr*",
"comment": null
},
{
"comment": "\t/* the name */\n"
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* argument's number in positional notation */\n"
},
{
"name": "argnumber",
"c_type": "int",
"comment": null
},
{
"comment": "\t/* argument name location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * NamedArgExpr - a named argument of a function\n *\n * This node type can only appear in the args list of a FuncCall or FuncExpr\n * node. We support pure positional call notation (no named arguments),\n * named notation (all arguments are named), and mixed notation (unnamed\n * arguments followed by named ones).\n *\n * Parse analysis sets argnumber to the positional index of the argument,\n * but doesn't rearrange the argument list.\n *\n * The planner will convert argument lists to pure positional notation\n * during expression preprocessing, so execution never sees a NamedArgExpr.\n */\n"
},
"OpExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* PG_OPERATOR OID of the operator */\n"
},
{
"name": "opno",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* PG_PROC OID of underlying function */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* PG_TYPE OID of result value */\n"
},
{
"name": "opresulttype",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* true if operator returns set */\n"
},
{
"name": "opretset",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* OID of collation of result */\n"
},
{
"name": "opcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* OID of collation that operator should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* arguments to the operator (1 or 2) */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * OpExpr - expression node for an operator invocation\n *\n * Semantically, this is essentially the same as a function call.\n *\n * Note that opfuncid is not necessarily filled in immediately on creation\n * of the node. The planner makes sure it is valid before passing the node\n * tree to the executor, but during parsing/planning opfuncid can be 0.\n * Therefore, equal() will accept a zero value as being equal to other values.\n *\n * Internal state information and collation data is irrelevant for the query\n * jumbling.\n */\n"
},
"ScalarArrayOpExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* PG_OPERATOR OID of the operator */\n"
},
{
"name": "opno",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* PG_PROC OID of comparison function */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* PG_PROC OID of hash func or InvalidOid */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* PG_PROC OID of negator of opfuncid function or InvalidOid. See above */\n"
},
{
"comment": ""
},
{
"comment": ""
},
{
"comment": "\t/* true for ANY, false for ALL */\n"
},
{
"name": "useOr",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* OID of collation that operator should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* the scalar and array operands */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * ScalarArrayOpExpr - expression node for \"scalar op ANY/ALL (array)\"\n *\n * The operator must yield boolean. It is applied to the left operand\n * and each element of the righthand array, and the results are combined\n * with OR or AND (for ANY or ALL respectively). The node representation\n * is almost the same as for the underlying operator, but we need a useOr\n * flag to remember whether it's ANY or ALL, and we don't have to store\n * the result type (or the collation) because it must be boolean.\n *\n * A ScalarArrayOpExpr with a valid hashfuncid is evaluated during execution\n * by building a hash table containing the Const values from the RHS arg.\n * This table is probed during expression evaluation. The planner will set\n * hashfuncid to the hash function which must be used to build and probe the\n * hash table. The executor determines if it should use hash-based checks or\n * the more traditional means based on if the hashfuncid is set or not.\n *\n * When performing hashed NOT IN, the negfuncid will also be set to the\n * equality function which the hash table must use to build and probe the hash\n * table. opno and opfuncid will remain set to the <> operator and its\n * corresponding function and won't be used during execution. For\n * non-hashtable based NOT INs, negfuncid will be set to InvalidOid. See\n * convert_saop_to_hashed_saop().\n *\n * Similar to OpExpr, opfuncid, hashfuncid, and negfuncid are not necessarily\n * filled in right away, so will be ignored for equality if they are not set\n * yet.\n *\n * OID entries of the internal function types are irrelevant for the query\n * jumbling, but the operator OID and the arguments are.\n */\n"
},
"BoolExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "boolop",
"c_type": "BoolExprType",
"comment": null
},
{
"name": "args",
"c_type": "List*",
"comment": "/* arguments to this expression */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": null
},
"SubLink": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "subLinkType",
"c_type": "SubLinkType",
"comment": "/* see above */"
},
{
"name": "subLinkId",
"c_type": "int",
"comment": "/* ID (1..n); 0 if not MULTIEXPR */"
},
{
"name": "testexpr",
"c_type": "Node*",
"comment": "/* outer-query test for ALL/ANY/ROWCOMPARE */"
},
{
"comment": "\t/* originally specified operator name */\n"
},
{
"name": "operName",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* subselect as Query* or raw parsetree */\n"
},
{
"name": "subselect",
"c_type": "Node*",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"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"
},
"SubPlan": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* Fields copied from original SubLink: */\n"
},
{
"name": "subLinkType",
"c_type": "SubLinkType",
"comment": "/* see above */"
},
{
"comment": "\t/* The combining operators, transformed to an executable expression: */\n"
},
{
"name": "testexpr",
"c_type": "Node*",
"comment": "/* OpExpr or RowCompareExpr expression tree */"
},
{
"name": "paramIds",
"c_type": "List*",
"comment": "/* IDs of Params embedded in the above */"
},
{
"comment": "\t/* Identification of the Plan tree to use: */\n"
},
{
"name": "plan_id",
"c_type": "int",
"comment": "/* Index (from 1) in PlannedStmt.subplans */"
},
{
"comment": "\t/* Identification of the SubPlan for EXPLAIN and debugging purposes: */\n"
},
{
"name": "plan_name",
"c_type": "char*",
"comment": "/* A name assigned during planning */"
},
{
"comment": "\t/* Extra data useful for determining subplan's output type: */\n"
},
{
"name": "firstColType",
"c_type": "Oid",
"comment": "/* Type of first column of subplan result */"
},
{
"name": "firstColTypmod",
"c_type": "int32",
"comment": "/* Typmod of first column of subplan result */"
},
{
"name": "firstColCollation",
"c_type": "Oid",
"comment": "/* Collation of first column of subplan\n\t\t\t\t\t\t\t\t\t * result */\n"
},
{
"comment": "\t/* Information about execution strategy: */\n"
},
{
"name": "useHashTable",
"c_type": "bool",
"comment": "/* true to store subselect output in a hash\n\t\t\t\t\t\t\t\t * table (implies we are doing \"IN\") */\n"
},
{
"name": "unknownEqFalse",
"c_type": "bool",
"comment": "/* true if it's okay to return FALSE when the\n\t\t\t\t\t\t\t\t * spec result is UNKNOWN; this allows much\n\t\t\t\t\t\t\t\t * simpler handling of null values */\n"
},
{
"name": "parallel_safe",
"c_type": "bool",
"comment": "/* is the subplan parallel-safe? */"
},
{
"comment": "\t/* Note: parallel_safe does not consider contents of testexpr or args */\n"
},
{
"comment": "\t/* Information for passing params into and out of the subselect: */\n"
},
{
"comment": "\t/* setParam and parParam are lists of integers (param IDs) */\n"
},
{
"name": "setParam",
"c_type": "List*",
"comment": "/* initplan and MULTIEXPR subqueries have to\n\t\t\t\t\t\t\t\t * set these Params for parent plan */\n"
},
{
"name": "parParam",
"c_type": "List*",
"comment": "/* indices of input Params from parent plan */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* exprs to pass as parParam values */"
},
{
"comment": "\t/* Estimated execution costs: */\n"
},
{
"name": "startup_cost",
"c_type": "Cost",
"comment": "/* one-time setup cost */"
},
{
"name": "per_call_cost",
"c_type": "Cost",
"comment": "/* cost for each subplan evaluation */"
}
],
"comment": "/*\n * SubPlan - executable expression node for a subplan (sub-SELECT)\n *\n * The planner replaces SubLink nodes in expression trees with SubPlan\n * nodes after it has finished planning the subquery. SubPlan references\n * a sub-plantree stored in the subplans list of the toplevel PlannedStmt.\n * (We avoid a direct link to make it easier to copy expression trees\n * without causing multiple processing of the subplan.)\n *\n * In an ordinary subplan, testexpr points to an executable expression\n * (OpExpr, an AND/OR tree of OpExprs, or RowCompareExpr) for the combining\n * operator(s); the left-hand arguments are the original lefthand expressions,\n * and the right-hand arguments are PARAM_EXEC Param nodes representing the\n * outputs of the sub-select. (NOTE: runtime coercion functions may be\n * inserted as well.) This is just the same expression tree as testexpr in\n * the original SubLink node, but the PARAM_SUBLINK nodes are replaced by\n * suitably numbered PARAM_EXEC nodes.\n *\n * If the sub-select becomes an initplan rather than a subplan, the executable\n * expression is part of the outer plan's expression tree (and the SubPlan\n * node itself is not, but rather is found in the outer plan's initPlan\n * list). In this case testexpr is NULL to avoid duplication.\n *\n * The planner also derives lists of the values that need to be passed into\n * and out of the subplan. Input values are represented as a list \"args\" of\n * expressions to be evaluated in the outer-query context (currently these\n * args are always just Vars, but in principle they could be any expression).\n * The values are assigned to the global PARAM_EXEC params indexed by parParam\n * (the parParam and args lists must have the same ordering). setParam is a\n * list of the PARAM_EXEC params that are computed by the sub-select, if it\n * is an initplan or MULTIEXPR plan; they are listed in order by sub-select\n * output column position. (parParam and setParam are integer Lists, not\n * Bitmapsets, because their ordering is significant.)\n *\n * Also, the planner computes startup and per-call costs for use of the\n * SubPlan. Note that these include the cost of the subquery proper,\n * evaluation of the testexpr if any, and any hashtable management overhead.\n */\n"
},
"AlternativeSubPlan": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "subplans",
"c_type": "List*",
"comment": "/* SubPlan(s) with equivalent results */"
}
],
"comment": "/*\n * AlternativeSubPlan - expression node for a choice among SubPlans\n *\n * This is used only transiently during planning: by the time the plan\n * reaches the executor, all AlternativeSubPlan nodes have been removed.\n *\n * The subplans are given as a List so that the node definition need not\n * change if there's ever more than two alternatives. For the moment,\n * though, there are always exactly two; and the first one is the fast-start\n * plan.\n */\n"
},
"FieldSelect": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "fieldnum",
"c_type": "AttrNumber",
"comment": "/* attribute number of field to extract */"
},
{
"comment": "\t/* type of the field (result type of this node) */\n"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* output typmod (usually -1) */\n"
},
{
"name": "resulttypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation of the field */\n"
},
{
"name": "resultcollid",
"c_type": "Oid",
"comment": null
}
],
"comment": "/* ----------------\n * FieldSelect\n *\n * FieldSelect represents the operation of extracting one field from a tuple\n * value. At runtime, the input expression is expected to yield a rowtype\n * Datum. The specified field number is extracted and returned as a Datum.\n * ----------------\n */\n"
},
"FieldStore": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input tuple value */"
},
{
"name": "newvals",
"c_type": "List*",
"comment": "/* new value(s) for field(s) */"
},
{
"comment": "\t/* integer list of field attnums */\n"
},
{
"name": "fieldnums",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* type of result (same as type of arg) */\n"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* Like RowExpr, we deliberately omit a typmod and collation here */\n"
}
],
"comment": "/* ----------------\n * FieldStore\n *\n * FieldStore represents the operation of modifying one field in a tuple\n * value, yielding a new tuple value (the input is not touched!). Like\n * the assign case of SubscriptingRef, this is used to implement UPDATE of a\n * portion of a column.\n *\n * resulttype is always a named composite type (not a domain). To update\n * a composite domain value, apply CoerceToDomain to the FieldStore.\n *\n * A single FieldStore can actually represent updates of several different\n * fields. The parser only generates FieldStores with single-element lists,\n * but the planner will collapse multiple updates of the same base column\n * into one FieldStore.\n * ----------------\n */\n"
},
"RelabelType": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": "/* output type of coercion expression */"
},
{
"comment": "\t/* output typmod (usually -1) */\n"
},
{
"name": "resulttypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "resultcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "relabelformat",
"c_type": "CoercionForm",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/* ----------------\n * RelabelType\n *\n * RelabelType represents a \"dummy\" type coercion between two binary-\n * compatible datatypes, such as reinterpreting the result of an OID\n * expression as an int4. It is a no-op at runtime; we only need it\n * to provide a place to store the correct type to be attributed to\n * the expression result during type resolution. (We can't get away\n * with just overwriting the type field of the input expression node,\n * so we need a separate node to show the coercion's result type.)\n * ----------------\n */\n"
},
"CoerceViaIO": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": "/* output type of coercion */"
},
{
"comment": "\t/* output typmod is not stored, but is presumed -1 */\n"
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "resultcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "coerceformat",
"c_type": "CoercionForm",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/* ----------------\n * CoerceViaIO\n *\n * CoerceViaIO represents a type coercion between two types whose textual\n * representations are compatible, implemented by invoking the source type's\n * typoutput function then the destination type's typinput function.\n * ----------------\n */\n"
},
"ArrayCoerceExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression (yields an array) */"
},
{
"name": "elemexpr",
"c_type": "Expr*",
"comment": "/* expression representing per-element work */"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": "/* output type of coercion (an array type) */"
},
{
"comment": "\t/* output typmod (also element typmod) */\n"
},
{
"name": "resulttypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "resultcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "coerceformat",
"c_type": "CoercionForm",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/* ----------------\n * ArrayCoerceExpr\n *\n * ArrayCoerceExpr represents a type coercion from one array type to another,\n * which is implemented by applying the per-element coercion expression\n * \"elemexpr\" to each element of the source array. Within elemexpr, the\n * source element is represented by a CaseTestExpr node. Note that even if\n * elemexpr is a no-op (that is, just CaseTestExpr + RelabelType), the\n * coercion still requires some effort: we have to fix the element type OID\n * stored in the array header.\n * ----------------\n */\n"
},
"ConvertRowtypeExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": "/* output type (always a composite type) */"
},
{
"comment": "\t/* Like RowExpr, we deliberately omit a typmod and collation here */\n"
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "convertformat",
"c_type": "CoercionForm",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/* ----------------\n * ConvertRowtypeExpr\n *\n * ConvertRowtypeExpr represents a type coercion from one composite type\n * to another, where the source type is guaranteed to contain all the columns\n * needed for the destination type plus possibly others; the columns need not\n * be in the same positions, but are matched up by name. This is primarily\n * used to convert a whole-row value of an inheritance child table into a\n * valid whole-row value of its parent table's rowtype. Both resulttype\n * and the exposed type of \"arg\" must be named composite types (not domains).\n * ----------------\n */\n"
},
"CollateExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "collOid",
"c_type": "Oid",
"comment": "/* collation's OID */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*----------\n * CollateExpr - COLLATE\n *\n * The planner replaces CollateExpr with RelabelType during expression\n * preprocessing, so execution never sees a CollateExpr.\n *----------\n */\n"
},
"CaseExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type of expression result */\n"
},
{
"name": "casetype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "casecollid",
"c_type": "Oid",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* implicit equality comparison argument */"
},
{
"name": "args",
"c_type": "List*",
"comment": "/* the arguments (list of WHEN clauses) */"
},
{
"name": "defresult",
"c_type": "Expr*",
"comment": "/* the default result (ELSE clause) */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*----------\n * CaseExpr - a CASE expression\n *\n * We support two distinct forms of CASE expression:\n *\t\tCASE WHEN boolexpr THEN expr [ WHEN boolexpr THEN expr ... ]\n *\t\tCASE testexpr WHEN compexpr THEN expr [ WHEN compexpr THEN expr ... ]\n * These are distinguishable by the \"arg\" field being NULL in the first case\n * and the testexpr in the second case.\n *\n * In the raw grammar output for the second form, the condition expressions\n * of the WHEN clauses are just the comparison values. Parse analysis\n * converts these to valid boolean expressions of the form\n *\t\tCaseTestExpr '=' compexpr\n * where the CaseTestExpr node is a placeholder that emits the correct\n * value at runtime. This structure is used so that the testexpr need be\n * evaluated only once. Note that after parse analysis, the condition\n * expressions always yield boolean.\n *\n * Note: we can test whether a CaseExpr has been through parse analysis\n * yet by checking whether casetype is InvalidOid or not.\n *----------\n */\n"
},
"CaseWhen": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "expr",
"c_type": "Expr*",
"comment": "/* condition expression */"
},
{
"name": "result",
"c_type": "Expr*",
"comment": "/* substitution result */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * CaseWhen - one arm of a CASE expression\n */\n"
},
"CaseTestExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "typeId",
"c_type": "Oid",
"comment": "/* type for substituted value */"
},
{
"comment": "\t/* typemod for substituted value */\n"
},
{
"name": "typeMod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* collation for the substituted value */\n"
},
{
"name": "collation",
"c_type": "Oid",
"comment": null
}
],
"comment": "/*\n * Placeholder node for the test value to be processed by a CASE expression.\n * This is effectively like a Param, but can be implemented more simply\n * since we need only one replacement value at a time.\n *\n * We also abuse this node type for some other purposes, including:\n *\t* Placeholder for the current array element value in ArrayCoerceExpr;\n *\t see build_coercion_expression().\n *\t* Nested FieldStore/SubscriptingRef assignment expressions in INSERT/UPDATE;\n *\t see transformAssignmentIndirection().\n *\t* Placeholder for intermediate results in some SQL/JSON expression nodes,\n *\t such as JsonConstructorExpr.\n *\n * The uses in CaseExpr and ArrayCoerceExpr are safe only to the extent that\n * there is not any other CaseExpr or ArrayCoerceExpr between the value source\n * node and its child CaseTestExpr(s). This is true in the parse analysis\n * output, but the planner's function-inlining logic has to be careful not to\n * break it.\n *\n * The nested-assignment-expression case is safe because the only node types\n * that can be above such CaseTestExprs are FieldStore and SubscriptingRef.\n */\n"
},
"ArrayExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type of expression result */\n"
},
{
"name": "array_typeid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "array_collid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* common type of array elements */\n"
},
{
"name": "element_typeid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* the array elements or sub-arrays */\n"
},
{
"name": "elements",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* true if elements are sub-arrays */\n"
},
{
"name": "multidims",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * ArrayExpr - an ARRAY[] expression\n *\n * Note: if multidims is false, the constituent expressions all yield the\n * scalar type identified by element_typeid. If multidims is true, the\n * constituent expressions all yield arrays of element_typeid (ie, the same\n * type as array_typeid); at runtime we must check for compatible subscripts.\n */\n"
},
"RowExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "args",
"c_type": "List*",
"comment": "/* the fields */"
},
{
"comment": ""
},
{
"comment": "\t/* RECORDOID or a composite type's ID */\n"
},
{
"name": "row_typeid",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * row_typeid cannot be a domain over composite, only plain composite. To\n\t * create a composite domain value, apply CoerceToDomain to the RowExpr.\n\t *\n\t * Note: we deliberately do NOT store a typmod. Although a typmod will be\n\t * associated with specific RECORD types at runtime, it will differ for\n\t * different backends, and so cannot safely be stored in stored\n\t * parsetrees. We must assume typmod -1 for a RowExpr node.\n\t *\n\t * We don't need to store a collation either. The result type is\n\t * necessarily composite, and composite types never have a collation.\n\t */\n"
},
{
"comment": ""
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "row_format",
"c_type": "CoercionForm",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* list of String, or NIL */\n"
},
{
"name": "colnames",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * RowExpr - a ROW() expression\n *\n * Note: the list of fields must have a one-for-one correspondence with\n * physical fields of the associated rowtype, although it is okay for it\n * to be shorter than the rowtype. That is, the N'th list element must\n * match up with the N'th physical field. When the N'th physical field\n * is a dropped column (attisdropped) then the N'th list element can just\n * be a NULL constant. (This case can only occur for named composite types,\n * not RECORD types, since those are built from the RowExpr itself rather\n * than vice versa.) It is important not to assume that length(args) is\n * the same as the number of columns logically present in the rowtype.\n *\n * colnames provides field names if the ROW() result is of type RECORD.\n * Names *must* be provided if row_typeid is RECORDOID; but if it is a\n * named composite type, colnames will be ignored in favor of using the\n * type's cataloged field names, so colnames should be NIL. Like the\n * args list, colnames is defined to be one-for-one with physical fields\n * of the rowtype (although dropped columns shouldn't appear in the\n * RECORD case, so this fine point is currently moot).\n */\n"
},
"RowCompareExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* LT LE GE or GT, never EQ or NE */\n"
},
{
"name": "rctype",
"c_type": "RowCompareType",
"comment": null
},
{
"comment": "\t/* OID list of pairwise comparison ops */\n"
},
{
"name": "opnos",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of containing operator families */\n"
},
{
"name": "opfamilies",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* OID list of collations for comparisons */\n"
},
{
"name": "inputcollids",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* the left-hand input arguments */\n"
},
{
"name": "largs",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* the right-hand input arguments */\n"
},
{
"name": "rargs",
"c_type": "List*",
"comment": null
}
],
"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"
},
"CoalesceExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type of expression result */\n"
},
{
"name": "coalescetype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "coalescecollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* the arguments */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * CoalesceExpr - a COALESCE expression\n */\n"
},
"MinMaxExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* common type of arguments and result */\n"
},
{
"name": "minmaxtype",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation of result */\n"
},
{
"name": "minmaxcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* OID of collation that function should use */\n"
},
{
"name": "inputcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* function to execute */\n"
},
{
"name": "op",
"c_type": "MinMaxOp",
"comment": null
},
{
"comment": "\t/* the arguments */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * MinMaxExpr - a GREATEST or LEAST function\n */\n"
},
"SQLValueFunction": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "op",
"c_type": "SQLValueFunctionOp",
"comment": "/* which function this is */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Result type/typmod. Type is fully determined by \"op\", so no need to\n\t * include this Oid in the query jumbling.\n\t */\n"
},
{
"name": "type",
"c_type": "Oid",
"comment": null
},
{
"name": "typmod",
"c_type": "int32",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": null
},
"XmlExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* xml function ID */\n"
},
{
"name": "op",
"c_type": "XmlExprOp",
"comment": null
},
{
"comment": "\t/* name in xml(NAME foo ...) syntaxes */\n"
},
{
"name": "name",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* non-XML expressions for xml_attributes */\n"
},
{
"name": "named_args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* parallel list of String values */\n"
},
{
"name": "arg_names",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* list of expressions */\n"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* DOCUMENT or CONTENT */\n"
},
{
"name": "xmloption",
"c_type": "XmlOptionType",
"comment": null
},
{
"comment": "\t/* INDENT option for XMLSERIALIZE */\n"
},
{
"name": "indent",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* target type/typmod for XMLSERIALIZE */\n"
},
{
"name": "type",
"c_type": "Oid",
"comment": null
},
{
"name": "typmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": null
},
"JsonFormat": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "format_type",
"c_type": "JsonFormatType",
"comment": "/* format type */"
},
{
"name": "encoding",
"c_type": "JsonEncoding",
"comment": "/* JSON encoding */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonFormat -\n *\t\trepresentation of JSON FORMAT clause\n */\n"
},
"JsonReturning": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": "/* output JSON format */"
},
{
"name": "typid",
"c_type": "Oid",
"comment": "/* target type Oid */"
},
{
"name": "typmod",
"c_type": "int32",
"comment": "/* target type modifier */"
}
],
"comment": "/*\n * JsonReturning -\n *\t\ttransformed representation of JSON RETURNING clause\n */\n"
},
"JsonValueExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "raw_expr",
"c_type": "Expr*",
"comment": "/* raw expression */"
},
{
"name": "formatted_expr",
"c_type": "Expr*",
"comment": "/* formatted expression */"
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": "/* FORMAT clause, if specified */"
}
],
"comment": "/*\n * JsonValueExpr -\n *\t\trepresentation of JSON value expression (expr [FORMAT JsonFormat])\n *\n * The actual value is obtained by evaluating formatted_expr. raw_expr is\n * only there for displaying the original user-written expression and is not\n * evaluated by ExecInterpExpr() and eval_const_expressions_mutator().\n */\n"
},
"JsonConstructorExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "type",
"c_type": "JsonConstructorType",
"comment": "/* constructor type */"
},
{
"name": "args",
"c_type": "List*",
"comment": null
},
{
"name": "func",
"c_type": "Expr*",
"comment": "/* underlying json[b]_xxx() function call */"
},
{
"name": "coercion",
"c_type": "Expr*",
"comment": "/* coercion to RETURNING type */"
},
{
"name": "returning",
"c_type": "JsonReturning*",
"comment": "/* RETURNING clause */"
},
{
"name": "absent_on_null",
"c_type": "bool",
"comment": "/* ABSENT ON NULL? */"
},
{
"name": "unique",
"c_type": "bool",
"comment": "/* WITH UNIQUE KEYS? (JSON_OBJECT[AGG] only) */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * JsonConstructorExpr -\n *\t\twrapper over FuncExpr/Aggref/WindowFunc for SQL/JSON constructors\n */\n"
},
"JsonIsPredicate": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "expr",
"c_type": "Node*",
"comment": "/* subject expression */"
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": "/* FORMAT clause, if specified */"
},
{
"name": "item_type",
"c_type": "JsonValueType",
"comment": "/* JSON item type */"
},
{
"name": "unique_keys",
"c_type": "bool",
"comment": "/* check key uniqueness? */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonIsPredicate -\n *\t\trepresentation of IS JSON predicate\n */\n"
},
"JsonBehavior": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "btype",
"c_type": "JsonBehaviorType",
"comment": null
},
{
"name": "expr",
"c_type": "Node*",
"comment": null
},
{
"name": "coerce",
"c_type": "bool",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * JsonBehavior\n *\t\tSpecifications for ON ERROR / ON EMPTY behaviors of SQL/JSON\n *\t\tquery functions specified by a JsonExpr\n *\n * 'expr' is the expression to emit when a given behavior (EMPTY or ERROR)\n * occurs on evaluating the SQL/JSON query function. 'coerce' is set to true\n * if 'expr' isn't already of the expected target type given by\n * JsonExpr.returning.\n */\n"
},
"JsonExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": ""
},
{
"name": "op",
"c_type": "JsonExprOp",
"comment": null
},
{
"comment": ""
},
{
"name": "column_name",
"c_type": "char*",
"comment": "/* JSON_TABLE() column name or NULL if this is\n\t\t\t\t\t\t\t\t * not for a JSON_TABLE() */\n"
},
{
"comment": ""
},
{
"comment": "\t/* jsonb-valued expression to query */\n"
},
{
"name": "formatted_expr",
"c_type": "Node*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Format of the above expression needed by ruleutils.c */\n"
},
{
"name": "format",
"c_type": "JsonFormat*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* jsonpath-valued expression containing the query pattern */\n"
},
{
"name": "path_spec",
"c_type": "Node*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Expected type/format of the output. */\n"
},
{
"name": "returning",
"c_type": "JsonReturning*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Information about the PASSING argument expressions */\n"
},
{
"name": "passing_names",
"c_type": "List*",
"comment": null
},
{
"name": "passing_values",
"c_type": "List*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* User-specified or default ON EMPTY and ON ERROR behaviors */\n"
},
{
"name": "on_empty",
"c_type": "JsonBehavior*",
"comment": null
},
{
"name": "on_error",
"c_type": "JsonBehavior*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * Information about converting the result of jsonpath functions\n\t * JsonPathQuery() and JsonPathValue() to the RETURNING type.\n\t */\n"
},
{
"name": "use_io_coercion",
"c_type": "bool",
"comment": null
},
{
"name": "use_json_coercion",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* WRAPPER specification for JSON_QUERY */\n"
},
{
"name": "wrapper",
"c_type": "JsonWrapper",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* KEEP or OMIT QUOTES for singleton scalars returned by JSON_QUERY() */\n"
},
{
"name": "omit_quotes",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* JsonExpr's collation. */\n"
},
{
"name": "collation",
"c_type": "Oid",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Original JsonFuncExpr's location */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * JsonExpr -\n *\t\tTransformed representation of JSON_VALUE(), JSON_QUERY(), and\n *\t\tJSON_EXISTS()\n */\n"
},
"JsonTablePath": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"comment": ""
},
{
"name": "value",
"c_type": "Const*",
"comment": null
},
{
"name": "name",
"c_type": "char*",
"comment": null
}
],
"comment": "/*\n * JsonTablePath\n *\t\tA JSON path expression to be computed as part of evaluating\n *\t\ta JSON_TABLE plan node\n */\n"
},
"JsonTablePlan": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
}
],
"comment": "/*\n * JsonTablePlan -\n *\t\tAbstract class to represent different types of JSON_TABLE \"plans\".\n *\t\tA plan is used to generate a \"row pattern\" value by evaluating a JSON\n *\t\tpath expression against an input JSON document, which is then used for\n *\t\tpopulating JSON_TABLE() columns\n */\n"
},
"JsonTablePathScan": {
"fields": [
{
"name": "plan",
"c_type": "JsonTablePlan",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* JSON path to evaluate */\n"
},
{
"name": "path",
"c_type": "JsonTablePath*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * ERROR/EMPTY ON ERROR behavior; only significant in the plan for the\n\t * top-level path.\n\t */\n"
},
{
"name": "errorOnError",
"c_type": "bool",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/* Plan(s) for nested columns, if any. */\n"
},
{
"name": "child",
"c_type": "JsonTablePlan*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * 0-based index in TableFunc.colvalexprs of the 1st and the last column\n\t * covered by this plan. Both are -1 if all columns are nested and thus\n\t * computed by the child plan(s).\n\t */\n"
},
{
"name": "colMin",
"c_type": "int",
"comment": null
},
{
"name": "colMax",
"c_type": "int",
"comment": null
}
],
"comment": "/*\n * JSON_TABLE plan to evaluate a JSON path expression and NESTED paths, if\n * any.\n */\n"
},
"JsonTableSiblingJoin": {
"fields": [
{
"name": "plan",
"c_type": "JsonTablePlan",
"comment": null
},
{
"comment": ""
},
{
"name": "lplan",
"c_type": "JsonTablePlan*",
"comment": null
},
{
"name": "rplan",
"c_type": "JsonTablePlan*",
"comment": null
}
],
"comment": "/*\n * JsonTableSiblingJoin -\n *\t\tPlan to join rows of sibling NESTED COLUMNS clauses in the same parent\n *\t\tCOLUMNS clause\n */\n"
},
"NullTest": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "nulltesttype",
"c_type": "NullTestType",
"comment": "/* IS NULL, IS NOT NULL */"
},
{
"comment": "\t/* T to perform field-by-field null checks */\n"
},
{
"name": "argisrow",
"c_type": "bool",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"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"
},
"BooleanTest": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "booltesttype",
"c_type": "BoolTestType",
"comment": "/* test type */"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if 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"
},
"MergeAction": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "matchKind",
"c_type": "MergeMatchKind",
"comment": "/* MATCHED/NOT MATCHED BY SOURCE/TARGET */"
},
{
"name": "commandType",
"c_type": "CmdType",
"comment": "/* INSERT/UPDATE/DELETE/DO NOTHING */"
},
{
"comment": "\t/* OVERRIDING clause */\n"
},
{
"name": "override",
"c_type": "OverridingKind",
"comment": null
},
{
"name": "qual",
"c_type": "Node*",
"comment": "/* transformed WHEN conditions */"
},
{
"name": "targetList",
"c_type": "List*",
"comment": "/* the target list (of TargetEntry) */"
},
{
"comment": "\t/* target attribute numbers of an UPDATE */\n"
},
{
"name": "updateColnos",
"c_type": "List*",
"comment": null
}
],
"comment": null
},
"CoerceToDomain": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "arg",
"c_type": "Expr*",
"comment": "/* input expression */"
},
{
"name": "resulttype",
"c_type": "Oid",
"comment": "/* domain type ID (result type) */"
},
{
"comment": "\t/* output typmod (currently always -1) */\n"
},
{
"name": "resulttypmod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* OID of collation, or InvalidOid if none */\n"
},
{
"name": "resultcollid",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* how to display this node */\n"
},
{
"name": "coercionformat",
"c_type": "CoercionForm",
"comment": null
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": "/* token location, or -1 if unknown */"
}
],
"comment": "/*\n * CoerceToDomain\n *\n * CoerceToDomain represents the operation of coercing a value to a domain\n * type. At runtime (and not before) the precise set of constraints to be\n * checked will be determined. If the value passes, it is returned as the\n * result; if not, an error is raised. Note that this is equivalent to\n * RelabelType in the scenario where no constraints are applied.\n */\n"
},
"CoerceToDomainValue": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type for substituted value */\n"
},
{
"name": "typeId",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* typemod for substituted value */\n"
},
{
"name": "typeMod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* collation for the substituted value */\n"
},
{
"name": "collation",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * Placeholder node for the value to be processed by a domain's check\n * constraint. This is effectively like a Param, but can be implemented more\n * simply since we need only one replacement value at a time.\n *\n * Note: the typeId/typeMod/collation will be set from the domain's base type,\n * not the domain itself. This is because we shouldn't consider the value\n * to be a member of the domain if we haven't yet checked its constraints.\n */\n"
},
"SetToDefault": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* type for substituted value */\n"
},
{
"name": "typeId",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* typemod for substituted value */\n"
},
{
"name": "typeMod",
"c_type": "int32",
"comment": null
},
{
"comment": "\t/* collation for the substituted value */\n"
},
{
"name": "collation",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* token location, or -1 if unknown */\n"
},
{
"name": "location",
"c_type": "ParseLoc",
"comment": null
}
],
"comment": "/*\n * Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.\n *\n * This is not an executable expression: it must be replaced by the actual\n * column default expression during rewriting. But it is convenient to\n * treat it as an expression node during parsing and rewriting.\n */\n"
},
"CurrentOfExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "cvarno",
"c_type": "Index",
"comment": "/* RT index of target relation */"
},
{
"name": "cursor_name",
"c_type": "char*",
"comment": "/* name of referenced cursor, or NULL */"
},
{
"name": "cursor_param",
"c_type": "int",
"comment": "/* refcursor parameter number, or 0 */"
}
],
"comment": "/*\n * Node representing [WHERE] CURRENT OF cursor_name\n *\n * CURRENT OF is a bit like a Var, in that it carries the rangetable index\n * of the target relation being constrained; this aids placing the expression\n * correctly during planning. We can assume however that its \"levelsup\" is\n * always zero, due to the syntactic constraints on where it can appear.\n * Also, cvarno will always be a true RT index, never INNER_VAR etc.\n *\n * The referenced cursor can be represented either as a hardwired string\n * or as a reference to a run-time parameter of type REFCURSOR. The latter\n * case is for the convenience of plpgsql.\n */\n"
},
"NextValueExpr": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "seqid",
"c_type": "Oid",
"comment": null
},
{
"name": "typeId",
"c_type": "Oid",
"comment": null
}
],
"comment": "/*\n * NextValueExpr - get next value from sequence\n *\n * This has the same effect as calling the nextval() function, but it does not\n * check permissions on the sequence. This is used for identity columns,\n * where the sequence is an implicit dependency without its own permissions.\n */\n"
},
"InferenceElem": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"name": "expr",
"c_type": "Node*",
"comment": "/* expression to infer from, or NULL */"
},
{
"name": "infercollid",
"c_type": "Oid",
"comment": "/* OID of collation, or InvalidOid */"
},
{
"name": "inferopclass",
"c_type": "Oid",
"comment": "/* OID of att opclass, or InvalidOid */"
}
],
"comment": "/*\n * InferenceElem - an element of a unique index inference specification\n *\n * This mostly matches the structure of IndexElems, but having a dedicated\n * primnode allows for a clean separation between the use of index parameters\n * by utility commands, and this node.\n */\n"
},
"TargetEntry": {
"fields": [
{
"name": "xpr",
"c_type": "Expr",
"comment": null
},
{
"comment": "\t/* expression to evaluate */\n"
},
{
"name": "expr",
"c_type": "Expr*",
"comment": null
},
{
"comment": "\t/* attribute number (see notes above) */\n"
},
{
"name": "resno",
"c_type": "AttrNumber",
"comment": null
},
{
"comment": "\t/* name of the column (could be NULL) */\n"
},
{
"name": "resname",
"c_type": "char*",
"comment": null
},
{
"comment": "\t/* nonzero if referenced by a sort/group clause */\n"
},
{
"name": "ressortgroupref",
"c_type": "Index",
"comment": null
},
{
"comment": "\t/* OID of column's source table */\n"
},
{
"name": "resorigtbl",
"c_type": "Oid",
"comment": null
},
{
"comment": "\t/* column's number in source table */\n"
},
{
"name": "resorigcol",
"c_type": "AttrNumber",
"comment": null
},
{
"comment": "\t/* set to true to eliminate the attribute from final target list */\n"
},
{
"name": "resjunk",
"c_type": "bool",
"comment": null
}
],
"comment": "/*--------------------\n * TargetEntry -\n *\t a target entry (used in query target lists)\n *\n * Strictly speaking, a TargetEntry isn't an expression node (since it can't\n * be evaluated by ExecEvalExpr). But we treat it as one anyway, since in\n * very many places it's convenient to process a whole query targetlist as a\n * single expression tree.\n *\n * In a SELECT's targetlist, resno should always be equal to the item's\n * ordinal position (counting from 1). However, in an INSERT or UPDATE\n * targetlist, resno represents the attribute number of the destination\n * column for the item; so there may be missing or out-of-order resnos.\n * It is even legal to have duplicated resnos; consider\n *\t\tUPDATE table SET arraycol[1] = ..., arraycol[2] = ..., ...\n * In an INSERT, the rewriter and planner will normalize the tlist by\n * reordering it into physical column order and filling in default values\n * for any columns not assigned values by the original query. In an UPDATE,\n * after the rewriter merges multiple assignments for the same column, the\n * planner extracts the target-column numbers into a separate \"update_colnos\"\n * list, and then renumbers the tlist elements serially. Thus, tlist resnos\n * match ordinal position in all tlists seen by the executor; but it is wrong\n * to assume that before planning has happened.\n *\n * resname is required to represent the correct column name in non-resjunk\n * entries of top-level SELECT targetlists, since it will be used as the\n * column title sent to the frontend. In most other contexts it is only\n * a debugging aid, and may be wrong or even NULL. (In particular, it may\n * be wrong in a tlist from a stored rule, if the referenced column has been\n * renamed by ALTER TABLE since the rule was made. Also, the planner tends\n * to store NULL rather than look up a valid name for tlist entries in\n * non-toplevel plan nodes.) In resjunk entries, resname should be either\n * a specific system-generated name (such as \"ctid\") or NULL; anything else\n * risks confusing ExecGetJunkAttribute!\n *\n * ressortgroupref is used in the representation of ORDER BY, GROUP BY, and\n * DISTINCT items. Targetlist entries with ressortgroupref=0 are not\n * sort/group items. If ressortgroupref>0, then this item is an ORDER BY,\n * GROUP BY, and/or DISTINCT target value. No two entries in a targetlist\n * may have the same nonzero ressortgroupref --- but there is no particular\n * meaning to the nonzero values, except as tags. (For example, one must\n * not assume that lower ressortgroupref means a more significant sort key.)\n * The order of the associated SortGroupClause lists determine the semantics.\n *\n * resorigtbl/resorigcol identify the source of the column, if it is a\n * simple reference to a column of a base table (or view). If it is not\n * a simple reference, these fields are zeroes.\n *\n * If resjunk is true then the column is a working column (such as a sort key)\n * that should be removed from the final output of the query. Resjunk columns\n * must have resnos that cannot duplicate any regular column's resno. Also\n * note that there are places that assume resjunk columns come after non-junk\n * columns.\n *--------------------\n */\n"
},
"RangeTblRef": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "rtindex",
"c_type": "int",
"comment": null
}
],
"comment": "/*\n * RangeTblRef - reference to an entry in the query's rangetable\n *\n * We could use direct pointers to the RT entries and skip having these\n * nodes, but multiple pointers to the same node in a querytree cause\n * lots of headaches, so it seems better to store an index into the RT.\n */\n"
},
"JoinExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "jointype",
"c_type": "JoinType",
"comment": "/* type of join */"
},
{
"name": "isNatural",
"c_type": "bool",
"comment": "/* Natural join? Will need to shape table */"
},
{
"name": "larg",
"c_type": "Node*",
"comment": "/* left subtree */"
},
{
"name": "rarg",
"c_type": "Node*",
"comment": "/* right subtree */"
},
{
"comment": "\t/* USING clause, if any (list of String) */\n"
},
{
"name": "usingClause",
"c_type": "List*",
"comment": null
},
{
"comment": "\t/* alias attached to USING clause, if any */\n"
},
{
"name": "join_using_alias",
"c_type": "Alias*",
"comment": null
},
{
"comment": "\t/* qualifiers on join, if any */\n"
},
{
"name": "quals",
"c_type": "Node*",
"comment": null
},
{
"comment": "\t/* user-written alias clause, if any */\n"
},
{
"name": "alias",
"c_type": "Alias*",
"comment": null
},
{
"comment": "\t/* RT index assigned for join, or 0 */\n"
},
{
"name": "rtindex",
"c_type": "int",
"comment": null
}
],
"comment": "/*----------\n * JoinExpr - for SQL JOIN expressions\n *\n * isNatural, usingClause, and quals are interdependent. The user can write\n * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).\n * If he writes NATURAL then parse analysis generates the equivalent USING()\n * list, and from that fills in \"quals\" with the right equality comparisons.\n * If he writes USING() then \"quals\" is filled with equality comparisons.\n * If he writes ON() then only \"quals\" is set. Note that NATURAL/USING\n * are not equivalent to ON() since they also affect the output column list.\n *\n * alias is an Alias node representing the AS alias-clause attached to the\n * join expression, or NULL if no clause. NB: presence or absence of the\n * alias has a critical impact on semantics, because a join with an alias\n * restricts visibility of the tables/columns inside it.\n *\n * join_using_alias is an Alias node representing the join correlation\n * name that SQL:2016 and later allow to be attached to JOIN/USING.\n * Its column alias list includes only the common column names from USING,\n * and it does not restrict visibility of the join's input tables.\n *\n * During parse analysis, an RTE is created for the Join, and its index\n * is filled into rtindex. This RTE is present mainly so that Vars can\n * be created that refer to the outputs of the join. The planner sometimes\n * generates JoinExprs internally; these can have rtindex = 0 if there are\n * no join alias variables referencing such joins.\n *----------\n */\n"
},
"FromExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "fromlist",
"c_type": "List*",
"comment": "/* List of join subtrees */"
},
{
"name": "quals",
"c_type": "Node*",
"comment": "/* qualifiers on join, if any */"
}
],
"comment": "/*----------\n * FromExpr - represents a FROM ... WHERE ... construct\n *\n * This is both more flexible than a JoinExpr (it can have any number of\n * children, including zero) and less so --- we don't need to deal with\n * aliases and so on. The output column set is implicitly just the union\n * of the outputs of the children.\n *----------\n */\n"
},
"OnConflictExpr": {
"fields": [
{
"name": "type",
"c_type": "NodeTag",
"comment": null
},
{
"name": "action",
"c_type": "OnConflictAction",
"comment": "/* DO NOTHING or UPDATE? */"
},
{
"comment": ""
},
{
"comment": "\t/* Arbiter */\n"
},
{
"name": "arbiterElems",
"c_type": "List*",
"comment": "/* unique index arbiter list (of\n\t\t\t\t\t\t\t\t * InferenceElem's) */\n"
},
{
"name": "arbiterWhere",
"c_type": "Node*",
"comment": "/* unique index arbiter WHERE clause */"
},
{
"name": "constraint",
"c_type": "Oid",
"comment": "/* pg_constraint OID for arbiter */"
},
{
"comment": ""
},
{
"comment": "\t/* ON CONFLICT UPDATE */\n"
},
{
"name": "onConflictSet",
"c_type": "List*",
"comment": "/* List of ON CONFLICT SET TargetEntrys */"
},
{
"name": "onConflictWhere",
"c_type": "Node*",
"comment": "/* qualifiers to restrict UPDATE to */"
},
{
"name": "exclRelIndex",
"c_type": "int",
"comment": "/* RT index of 'excluded' relation */"
},
{
"name": "exclRelTlist",
"c_type": "List*",
"comment": "/* tlist of the EXCLUDED pseudo relation */"
}
],
"comment": "/*----------\n * OnConflictExpr - represents an ON CONFLICT DO ... expression\n *\n * The optimizer requires a list of inference elements, and optionally a WHERE\n * clause to infer a unique index. The unique index (or, occasionally,\n * indexes) inferred are used to arbitrate whether or not the alternative ON\n * CONFLICT path is taken.\n *----------\n */\n"
}
},
"nodes/lockoptions": {
},
"nodes/nodes": {
},
"nodes/params": {
"ParamExternData": {
"fields": [
{
"name": "value",
"c_type": "Datum",
"comment": "/* parameter value */"
},
{
"name": "isnull",
"c_type": "bool",
"comment": "/* is it NULL? */"
},
{
"name": "pflags",
"c_type": "uint16",
"comment": "/* flag bits, see above */"
},
{
"name": "ptype",
"c_type": "Oid",
"comment": "/* parameter's datatype, or 0 */"
}
],
"comment": "/*\n *\t ParamListInfo\n *\n *\t ParamListInfo structures are used to pass parameters into the executor\n *\t for parameterized plans. We support two basic approaches to supplying\n *\t parameter values, the \"static\" way and the \"dynamic\" way.\n *\n *\t In the static approach, per-parameter data is stored in an array of\n *\t ParamExternData structs appended to the ParamListInfo struct.\n *\t Each entry in the array defines the value to be substituted for a\n *\t PARAM_EXTERN parameter. The \"paramid\" of a PARAM_EXTERN Param\n *\t can range from 1 to numParams.\n *\n *\t Although parameter numbers are normally consecutive, we allow\n *\t ptype == InvalidOid to signal an unused array entry.\n *\n *\t pflags is a flags field. Currently the only used bit is:\n *\t PARAM_FLAG_CONST signals the planner that it may treat this parameter\n *\t as a constant (i.e., generate a plan that works only for this value\n *\t of the parameter).\n *\n *\t In the dynamic approach, all access to parameter values is done through\n *\t hook functions found in the ParamListInfo struct. In this case,\n *\t the ParamExternData array is typically unused and not allocated;\n *\t but the legal range of paramid is still 1 to numParams.\n *\n *\t Although the data structure is really an array, not a list, we keep\n *\t the old typedef name to avoid unnecessary code changes.\n *\n *\t There are 3 hook functions that can be associated with a ParamListInfo\n *\t structure:\n *\n *\t If paramFetch isn't null, it is called to fetch the ParamExternData\n *\t for a particular param ID, rather than accessing the relevant element\n *\t of the ParamExternData array. This supports the case where the array\n *\t isn't there at all, as well as cases where the data in the array\n *\t might be obsolete or lazily evaluated. paramFetch must return the\n *\t address of a ParamExternData struct describing the specified param ID;\n *\t the convention above about ptype == InvalidOid signaling an invalid\n *\t param ID still applies. The returned struct can either be placed in\n *\t the \"workspace\" supplied by the caller, or it can be in storage\n *\t controlled by the paramFetch hook if that's more convenient.\n *\t (In either case, the struct is not expected to be long-lived.)\n *\t If \"speculative\" is true, the paramFetch hook should not risk errors\n *\t in trying to fetch the parameter value, and should report an invalid\n *\t parameter instead.\n *\n *\t If paramCompile isn't null, then it controls what execExpr.c compiles\n *\t for PARAM_EXTERN Param nodes --- typically, this hook would emit a\n *\t EEOP_PARAM_CALLBACK step. This allows unnecessary work to be\n *\t optimized away in compiled expressions.\n *\n *\t If parserSetup isn't null, then it is called to re-instantiate the\n *\t original parsing hooks when a query needs to be re-parsed/planned.\n *\t This is especially useful if the types of parameters might change\n *\t from time to time, since it can replace the need to supply a fixed\n *\t list of parameter types to the parser.\n *\n *\t Notice that the paramFetch and paramCompile hooks are actually passed\n *\t the ParamListInfo struct's address; they can therefore access all\n *\t three of the \"arg\" fields, and the distinction between paramFetchArg\n *\t and paramCompileArg is rather arbitrary.\n */\n"
},
"ParamListInfoData": {
"fields": [
{
"name": "paramFetch",
"c_type": "ParamFetchHook",
"comment": "/* parameter fetch hook */"
},
{
"name": "paramFetchArg",
"c_type": "void*",
"comment": null
},
{
"name": "paramCompile",
"c_type": "ParamCompileHook",
"comment": "/* parameter compile hook */"
},
{
"name": "paramCompileArg",
"c_type": "void*",
"comment": null
},
{
"name": "parserSetup",
"c_type": "ParserSetupHook",
"comment": "/* parser setup hook */"
},
{
"name": "parserSetupArg",
"c_type": "void*",
"comment": null
},
{
"name": "paramValuesStr",
"c_type": "char*",
"comment": "/* params as a single string for errors */"
},
{
"name": "numParams",
"c_type": "int",
"comment": "/* nominal/maximum # of Params represented */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * params[] may be of length zero if paramFetch is supplied; otherwise it\n\t * must be of length numParams.\n\t */\n"
}
],
"comment": "/*\n *\t ParamListInfo\n *\n *\t ParamListInfo structures are used to pass parameters into the executor\n *\t for parameterized plans. We support two basic approaches to supplying\n *\t parameter values, the \"static\" way and the \"dynamic\" way.\n *\n *\t In the static approach, per-parameter data is stored in an array of\n *\t ParamExternData structs appended to the ParamListInfo struct.\n *\t Each entry in the array defines the value to be substituted for a\n *\t PARAM_EXTERN parameter. The \"paramid\" of a PARAM_EXTERN Param\n *\t can range from 1 to numParams.\n *\n *\t Although parameter numbers are normally consecutive, we allow\n *\t ptype == InvalidOid to signal an unused array entry.\n *\n *\t pflags is a flags field. Currently the only used bit is:\n *\t PARAM_FLAG_CONST signals the planner that it may treat this parameter\n *\t as a constant (i.e., generate a plan that works only for this value\n *\t of the parameter).\n *\n *\t In the dynamic approach, all access to parameter values is done through\n *\t hook functions found in the ParamListInfo struct. In this case,\n *\t the ParamExternData array is typically unused and not allocated;\n *\t but the legal range of paramid is still 1 to numParams.\n *\n *\t Although the data structure is really an array, not a list, we keep\n *\t the old typedef name to avoid unnecessary code changes.\n *\n *\t There are 3 hook functions that can be associated with a ParamListInfo\n *\t structure:\n *\n *\t If paramFetch isn't null, it is called to fetch the ParamExternData\n *\t for a particular param ID, rather than accessing the relevant element\n *\t of the ParamExternData array. This supports the case where the array\n *\t isn't there at all, as well as cases where the data in the array\n *\t might be obsolete or lazily evaluated. paramFetch must return the\n *\t address of a ParamExternData struct describing the specified param ID;\n *\t the convention above about ptype == InvalidOid signaling an invalid\n *\t param ID still applies. The returned struct can either be placed in\n *\t the \"workspace\" supplied by the caller, or it can be in storage\n *\t controlled by the paramFetch hook if that's more convenient.\n *\t (In either case, the struct is not expected to be long-lived.)\n *\t If \"speculative\" is true, the paramFetch hook should not risk errors\n *\t in trying to fetch the parameter value, and should report an invalid\n *\t parameter instead.\n *\n *\t If paramCompile isn't null, then it controls what execExpr.c compiles\n *\t for PARAM_EXTERN Param nodes --- typically, this hook would emit a\n *\t EEOP_PARAM_CALLBACK step. This allows unnecessary work to be\n *\t optimized away in compiled expressions.\n *\n *\t If parserSetup isn't null, then it is called to re-instantiate the\n *\t original parsing hooks when a query needs to be re-parsed/planned.\n *\t This is especially useful if the types of parameters might change\n *\t from time to time, since it can replace the need to supply a fixed\n *\t list of parameter types to the parser.\n *\n *\t Notice that the paramFetch and paramCompile hooks are actually passed\n *\t the ParamListInfo struct's address; they can therefore access all\n *\t three of the \"arg\" fields, and the distinction between paramFetchArg\n *\t and paramCompileArg is rather arbitrary.\n */\n"
},
"ParamExecData": {
"fields": [
{
"name": "execPlan",
"c_type": "void*",
"comment": "/* should be \"SubPlanState *\" */"
},
{
"name": "value",
"c_type": "Datum",
"comment": null
},
{
"name": "isnull",
"c_type": "bool",
"comment": null
}
],
"comment": "/* ----------------\n *\t ParamExecData\n *\n *\t ParamExecData entries are used for executor internal parameters\n *\t (that is, values being passed into or out of a sub-query). The\n *\t paramid of a PARAM_EXEC Param is a (zero-based) index into an\n *\t array of ParamExecData records, which is referenced through\n *\t es_param_exec_vals or ecxt_param_exec_vals.\n *\n *\t If execPlan is not NULL, it points to a SubPlanState node that needs\n *\t to be executed to produce the value. (This is done so that we can have\n *\t lazy evaluation of InitPlans: they aren't executed until/unless a\n *\t result value is needed.)\tOtherwise the value is assumed to be valid\n *\t when needed.\n * ----------------\n */\n"
},
"ParamsErrorCbData": {
"fields": [
{
"name": "portalName",
"c_type": "char*",
"comment": null
},
{
"name": "params",
"c_type": "ParamListInfo",
"comment": null
}
],
"comment": "/* type of argument for ParamsErrorCallback */\n"
}
},
"access/attnum": {
},
"c": {
},
"postgres": {
"NullableDatum": {
"fields": [
{
"name": "value",
"c_type": "Datum",
"comment": null
},
{
"comment": ""
},
{
"name": "isnull",
"c_type": "bool",
"comment": null
},
{
"comment": "\t/* due to alignment padding this could be used for flags for free */\n"
}
],
"comment": "/*\n * A NullableDatum is used in places where both a Datum and its nullness needs\n * to be stored. This can be more efficient than storing datums and nullness\n * in separate arrays, due to better spatial locality, even if more space may\n * be wasted due to padding.\n */\n"
}
},
"postgres_ext": {
},
"commands/vacuum": {
"VacAttrStats": {
"fields": [
{
"comment": "\t/*\n\t * These fields are set up by the main ANALYZE code before invoking the\n\t * type-specific typanalyze function. They don't necessarily match what\n\t * is in pg_attribute, because some index opclasses store a different type\n\t * than the underlying column/expression. Therefore, use these fields for\n\t * information about the datatype being fed to the typanalyze function.\n\t */\n"
},
{
"name": "attstattarget",
"c_type": "int",
"comment": "/* -1 to use default */"
},
{
"name": "attrtypid",
"c_type": "Oid",
"comment": "/* type of data being analyzed */"
},
{
"name": "attrtypmod",
"c_type": "int32",
"comment": "/* typmod of data being analyzed */"
},
{
"name": "attrtype",
"c_type": "Form_pg_type",
"comment": "/* copy of pg_type row for attrtypid */"
},
{
"name": "attrcollid",
"c_type": "Oid",
"comment": "/* collation of data being analyzed */"
},
{
"name": "anl_context",
"c_type": "MemoryContext",
"comment": "/* where to save long-lived data */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields must be filled in by the typanalyze routine, unless it\n\t * returns false.\n\t */\n"
},
{
"name": "compute_stats",
"c_type": "AnalyzeAttrComputeStatsFunc",
"comment": "/* function pointer */"
},
{
"name": "minrows",
"c_type": "int",
"comment": "/* Minimum # of rows wanted for stats */"
},
{
"name": "extra_data",
"c_type": "void*",
"comment": "/* for extra type-specific data */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields are to be filled in by the compute_stats routine. (They\n\t * are initialized to zero when the struct is created.)\n\t */\n"
},
{
"name": "stats_valid",
"c_type": "bool",
"comment": null
},
{
"name": "stanullfrac",
"c_type": "float4",
"comment": "/* fraction of entries that are NULL */"
},
{
"name": "stawidth",
"c_type": "int32",
"comment": "/* average width of column values */"
},
{
"name": "stadistinct",
"c_type": "float4",
"comment": "/* # distinct values */"
},
{
"name": "stakind[STATISTIC_NUM_SLOTS]",
"c_type": "int16",
"comment": null
},
{
"name": "staop[STATISTIC_NUM_SLOTS]",
"c_type": "Oid",
"comment": null
},
{
"name": "stacoll[STATISTIC_NUM_SLOTS]",
"c_type": "Oid",
"comment": null
},
{
"name": "numnumbers[STATISTIC_NUM_SLOTS]",
"c_type": "int",
"comment": null
},
{
"name": "stanumbers[STATISTIC_NUM_SLOTS]",
"c_type": "float4*",
"comment": null
},
{
"name": "numvalues[STATISTIC_NUM_SLOTS]",
"c_type": "int",
"comment": null
},
{
"name": "stavalues[STATISTIC_NUM_SLOTS]",
"c_type": "Datum*",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields describe the stavalues[n] element types. They will be\n\t * initialized to match attrtypid, but a custom typanalyze function might\n\t * want to store an array of something other than the analyzed column's\n\t * elements. It should then overwrite these fields.\n\t */\n"
},
{
"name": "statypid[STATISTIC_NUM_SLOTS]",
"c_type": "Oid",
"comment": null
},
{
"name": "statyplen[STATISTIC_NUM_SLOTS]",
"c_type": "int16",
"comment": null
},
{
"name": "statypbyval[STATISTIC_NUM_SLOTS]",
"c_type": "bool",
"comment": null
},
{
"name": "statypalign[STATISTIC_NUM_SLOTS]",
"c_type": "char",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * These fields are private to the main ANALYZE code and should not be\n\t * looked at by type-specific functions.\n\t */\n"
},
{
"name": "tupattnum",
"c_type": "int",
"comment": "/* attribute number within tuples */"
},
{
"name": "rows",
"c_type": "HeapTuple*",
"comment": "/* access info for std fetch function */"
},
{
"name": "tupDesc",
"c_type": "TupleDesc",
"comment": null
},
{
"name": "exprvals",
"c_type": "Datum*",
"comment": "/* access info for index fetch function */"
},
{
"name": "exprnulls",
"c_type": "bool*",
"comment": null
},
{
"name": "rowstride",
"c_type": "int",
"comment": null
}
],
"comment": null
},
"VacuumParams": {
"fields": [
{
"name": "options",
"c_type": "bits32",
"comment": "/* bitmask of VACOPT_* */"
},
{
"name": "freeze_min_age",
"c_type": "int",
"comment": "/* min freeze age, -1 to use default */"
},
{
"name": "freeze_table_age",
"c_type": "int",
"comment": "/* age at which to scan whole table */"
},
{
"name": "multixact_freeze_min_age",
"c_type": "int",
"comment": "/* min multixact freeze age, -1 to\n\t\t\t\t\t\t\t\t\t\t\t * use default */\n"
},
{
"name": "multixact_freeze_table_age",
"c_type": "int",
"comment": "/* multixact age at which to scan\n\t\t\t\t\t\t\t\t\t\t\t * whole table */\n"
},
{
"name": "is_wraparound",
"c_type": "bool",
"comment": "/* force a for-wraparound vacuum */"
},
{
"name": "log_min_duration",
"c_type": "int",
"comment": "/* minimum execution threshold in ms at\n\t\t\t\t\t\t\t\t\t * which autovacuum is logged, -1 to use\n\t\t\t\t\t\t\t\t\t * default */\n"
},
{
"name": "index_cleanup",
"c_type": "VacOptValue",
"comment": "/* Do index vacuum and cleanup */"
},
{
"name": "truncate",
"c_type": "VacOptValue",
"comment": "/* Truncate empty pages at the end */"
},
{
"name": "toast_parent",
"c_type": "Oid",
"comment": "/* for privilege checks when recursing */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * The number of parallel vacuum workers. 0 by default which means choose\n\t * based on the number of indexes. -1 indicates parallel vacuum is\n\t * disabled.\n\t */\n"
},
{
"name": "nworkers",
"c_type": "int",
"comment": null
}
],
"comment": "/*\n * Parameters customizing behavior of VACUUM and ANALYZE.\n *\n * Note that at least one of VACOPT_VACUUM and VACOPT_ANALYZE must be set\n * in options.\n *\n * When adding a new VacuumParam member, consider adding it to vacuumdb as\n * well.\n */\n"
},
"VacuumCutoffs": {
"fields": [
{
"comment": "\t/*\n\t * Existing pg_class fields at start of VACUUM\n\t */\n"
},
{
"name": "relfrozenxid",
"c_type": "TransactionId",
"comment": null
},
{
"name": "relminmxid",
"c_type": "MultiXactId",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * OldestXmin is the Xid below which tuples deleted by any xact (that\n\t * committed) should be considered DEAD, not just RECENTLY_DEAD.\n\t *\n\t * OldestMxact is the Mxid below which MultiXacts are definitely not seen\n\t * as visible by any running transaction.\n\t *\n\t * OldestXmin and OldestMxact are also the most recent values that can\n\t * ever be passed to vac_update_relstats() as frozenxid and minmulti\n\t * arguments at the end of VACUUM. These same values should be passed\n\t * when it turns out that VACUUM will leave no unfrozen XIDs/MXIDs behind\n\t * in the table.\n\t */\n"
},
{
"name": "OldestXmin",
"c_type": "TransactionId",
"comment": null
},
{
"name": "OldestMxact",
"c_type": "MultiXactId",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * FreezeLimit is the Xid below which all Xids are definitely frozen or\n\t * removed in pages VACUUM scans and cleanup locks.\n\t *\n\t * MultiXactCutoff is the value below which all MultiXactIds are\n\t * definitely removed from Xmax in pages VACUUM scans and cleanup locks.\n\t */\n"
},
{
"name": "FreezeLimit",
"c_type": "TransactionId",
"comment": null
},
{
"name": "MultiXactCutoff",
"c_type": "MultiXactId",
"comment": null
}
],
"comment": "/*\n * VacuumCutoffs is immutable state that describes the cutoffs used by VACUUM.\n * Established at the beginning of each VACUUM operation.\n */\n"
},
"VacDeadItemsInfo": {
"fields": [
{
"name": "max_bytes",
"c_type": "size_t",
"comment": "/* the maximum bytes TidStore can use */"
},
{
"name": "num_items",
"c_type": "int64",
"comment": "/* current # of entries */"
}
],
"comment": "/*\n * VacDeadItemsInfo stores supplemental information for dead tuple TID\n * storage (i.e. TidStore).\n */\n"
}
},
"storage/block": {
"BlockIdData": {
"fields": [
{
"name": "bi_hi",
"c_type": "uint16",
"comment": null
},
{
"name": "bi_lo",
"c_type": "uint16",
"comment": null
}
],
"comment": "/*\n * BlockId:\n *\n * this is a storage type for BlockNumber. in other words, this type\n * is used for on-disk structures (e.g., in HeapTupleData) whereas\n * BlockNumber is the type on which calculations are performed (e.g.,\n * in access method code).\n *\n * there doesn't appear to be any reason to have separate types except\n * for the fact that BlockIds can be SHORTALIGN'd (and therefore any\n * structures that contains them, such as ItemPointerData, can also be\n * SHORTALIGN'd). this is an important consideration for reducing the\n * space requirements of the line pointer (ItemIdData) array on each\n * page and the header of each heap or index tuple, so it doesn't seem\n * wise to change this without good reason.\n */\n"
}
},
"access/sdir": {
},
"mb/pg_wchar": {
},
"../backend/parser/gram": {
"YYLTYPE": {
"fields": [
{
"name": "first_line",
"c_type": "int",
"comment": null
},
{
"name": "first_column",
"c_type": "int",
"comment": null
},
{
"name": "last_line",
"c_type": "int",
"comment": null
},
{
"name": "last_column",
"c_type": "int",
"comment": null
}
],
"comment": "/* Line 1529 of yacc.c. */\n"
}
},
"../backend/parser/gramparse": {
"base_yy_extra_type": {
"fields": [
{
"comment": "\t/*\n\t * Fields used by the core scanner.\n\t */\n"
},
{
"name": "core_yy_extra",
"c_type": "core_yy_extra_type",
"comment": null
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * State variables for base_yylex().\n\t */\n"
},
{
"name": "have_lookahead",
"c_type": "bool",
"comment": "/* is lookahead info valid? */"
},
{
"name": "lookahead_token",
"c_type": "int",
"comment": "/* one-token lookahead */"
},
{
"name": "lookahead_yylval",
"c_type": "core_YYSTYPE",
"comment": "/* yylval for lookahead token */"
},
{
"name": "lookahead_yylloc",
"c_type": "YYLTYPE",
"comment": "/* yylloc for lookahead token */"
},
{
"name": "lookahead_end",
"c_type": "char*",
"comment": "/* end of current token */"
},
{
"name": "lookahead_hold_char",
"c_type": "char",
"comment": "/* to be put back at *lookahead_end */"
},
{
"comment": ""
},
{
"comment": "\t/*\n\t * State variables that belong to the grammar.\n\t */\n"
},
{
"name": "parsetree",
"c_type": "List*",
"comment": "/* final parse result is delivered here */"
}
],
"comment": "/*\n * The YY_EXTRA data that a flex scanner allows us to pass around. Private\n * state needed for raw parsing/lexing goes here.\n */\n"
}
},
"nodes/value": {
"Integer": {
"fields": [
{
"name": "ival",
"c_type": "long"
}
]
},
"Float": {
"fields": [
{
"name": "fval",
"c_type": "char*"
}
]
},
"Boolean": {
"fields": [
{
"name": "boolval",
"c_type": "bool"
}
]
},
"String": {
"fields": [
{
"name": "sval",
"c_type": "char*"
}
]
},
"BitString": {
"fields": [
{
"name": "bsval",
"c_type": "char*"
}
]
},
"A_Const": {
"fields": [
{
"name": "isnull",
"c_type": "bool"
},
{
"name": "val",
"c_type": "Node"
}
]
}
},
"nodes/pg_list": {
"List": {
"fields": [
{
"name": "items",
"c_type": "[]Node"
}
]
}
}
}