| 1 |
/*------------------------------------------------------------------------- |
| 2 |
* |
| 3 |
* parse_node.h |
| 4 |
* Internal definitions for parser |
| 5 |
* |
| 6 |
* |
| 7 |
* Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group |
| 8 |
* Portions Copyright (c) 1994, Regents of the University of California |
| 9 |
* |
| 10 |
* src/include/parser/parse_node.h |
| 11 |
* |
| 12 |
*------------------------------------------------------------------------- |
| 13 |
*/ |
| 14 |
#ifndef PARSE_NODE_H |
| 15 |
#define PARSE_NODE_H |
| 16 |
|
| 17 |
#include "nodes/parsenodes.h" |
| 18 |
#include "utils/queryenvironment.h" |
| 19 |
#include "utils/relcache.h" |
| 20 |
|
| 21 |
|
| 22 |
/* Forward references for some structs declared below */ |
| 23 |
typedef struct ParseState ParseState; |
| 24 |
typedef struct ParseNamespaceItem ParseNamespaceItem; |
| 25 |
typedef struct ParseNamespaceColumn ParseNamespaceColumn; |
| 26 |
|
| 27 |
/* |
| 28 |
* Expression kinds distinguished by transformExpr(). Many of these are not |
| 29 |
* semantically distinct so far as expression transformation goes; rather, |
| 30 |
* we distinguish them so that context-specific error messages can be printed. |
| 31 |
* |
| 32 |
* Note: EXPR_KIND_OTHER is not used in the core code, but is left for use |
| 33 |
* by extension code that might need to call transformExpr(). The core code |
| 34 |
* will not enforce any context-driven restrictions on EXPR_KIND_OTHER |
| 35 |
* expressions, so the caller would have to check for sub-selects, aggregates, |
| 36 |
* window functions, SRFs, etc if those need to be disallowed. |
| 37 |
*/ |
| 38 |
typedef enum ParseExprKind |
| 39 |
{ |
| 40 |
EXPR_KIND_NONE = 0, /* "not in an expression" */ |
| 41 |
EXPR_KIND_OTHER, /* reserved for extensions */ |
| 42 |
EXPR_KIND_JOIN_ON, /* JOIN ON */ |
| 43 |
EXPR_KIND_JOIN_USING, /* JOIN USING */ |
| 44 |
EXPR_KIND_FROM_SUBSELECT, /* sub-SELECT in FROM clause */ |
| 45 |
EXPR_KIND_FROM_FUNCTION, /* function in FROM clause */ |
| 46 |
EXPR_KIND_WHERE, /* WHERE */ |
| 47 |
EXPR_KIND_HAVING, /* HAVING */ |
| 48 |
EXPR_KIND_FILTER, /* FILTER */ |
| 49 |
EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */ |
| 50 |
EXPR_KIND_WINDOW_ORDER, /* window definition ORDER BY */ |
| 51 |
EXPR_KIND_WINDOW_FRAME_RANGE, /* window frame clause with RANGE */ |
| 52 |
EXPR_KIND_WINDOW_FRAME_ROWS, /* window frame clause with ROWS */ |
| 53 |
EXPR_KIND_WINDOW_FRAME_GROUPS, /* window frame clause with GROUPS */ |
| 54 |
EXPR_KIND_SELECT_TARGET, /* SELECT target list item */ |
| 55 |
EXPR_KIND_INSERT_TARGET, /* INSERT target list item */ |
| 56 |
EXPR_KIND_UPDATE_SOURCE, /* UPDATE assignment source item */ |
| 57 |
EXPR_KIND_UPDATE_TARGET, /* UPDATE assignment target item */ |
| 58 |
EXPR_KIND_MERGE_WHEN, /* MERGE WHEN [NOT] MATCHED condition */ |
| 59 |
EXPR_KIND_GROUP_BY, /* GROUP BY */ |
| 60 |
EXPR_KIND_ORDER_BY, /* ORDER BY */ |
| 61 |
EXPR_KIND_DISTINCT_ON, /* DISTINCT ON */ |
| 62 |
EXPR_KIND_LIMIT, /* LIMIT */ |
| 63 |
EXPR_KIND_OFFSET, /* OFFSET */ |
| 64 |
EXPR_KIND_RETURNING, /* RETURNING in INSERT/UPDATE/DELETE */ |
| 65 |
EXPR_KIND_MERGE_RETURNING, /* RETURNING in MERGE */ |
| 66 |
EXPR_KIND_VALUES, /* VALUES */ |
| 67 |
EXPR_KIND_VALUES_SINGLE, /* single-row VALUES (in INSERT only) */ |
| 68 |
EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */ |
| 69 |
EXPR_KIND_DOMAIN_CHECK, /* CHECK constraint for a domain */ |
| 70 |
EXPR_KIND_COLUMN_DEFAULT, /* default value for a table column */ |
| 71 |
EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */ |
| 72 |
EXPR_KIND_INDEX_EXPRESSION, /* index expression */ |
| 73 |
EXPR_KIND_INDEX_PREDICATE, /* index predicate */ |
| 74 |
EXPR_KIND_STATS_EXPRESSION, /* extended statistics expression */ |
| 75 |
EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */ |
| 76 |
EXPR_KIND_EXECUTE_PARAMETER, /* parameter value in EXECUTE */ |
| 77 |
EXPR_KIND_TRIGGER_WHEN, /* WHEN condition in CREATE TRIGGER */ |
| 78 |
EXPR_KIND_POLICY, /* USING or WITH CHECK expr in policy */ |
| 79 |
EXPR_KIND_PARTITION_BOUND, /* partition bound expression */ |
| 80 |
EXPR_KIND_PARTITION_EXPRESSION, /* PARTITION BY expression */ |
| 81 |
EXPR_KIND_CALL_ARGUMENT, /* procedure argument in CALL */ |
| 82 |
EXPR_KIND_COPY_WHERE, /* WHERE condition in COPY FROM */ |
| 83 |
EXPR_KIND_GENERATED_COLUMN, /* generation expression for a column */ |
| 84 |
EXPR_KIND_CYCLE_MARK, /* cycle mark value */ |
| 85 |
} ParseExprKind; |
| 86 |
|
| 87 |
|
| 88 |
/* |
| 89 |
* Function signatures for parser hooks |
| 90 |
*/ |
| 91 |
typedef Node *(*PreParseColumnRefHook) (ParseState *pstate, ColumnRef *cref); |
| 92 |
typedef Node *(*PostParseColumnRefHook) (ParseState *pstate, ColumnRef *cref, Node *var); |
| 93 |
typedef Node *(*ParseParamRefHook) (ParseState *pstate, ParamRef *pref); |
| 94 |
typedef Node *(*CoerceParamHook) (ParseState *pstate, Param *param, |
| 95 |
Oid targetTypeId, int32 targetTypeMod, |
| 96 |
int location); |
| 97 |
|
| 98 |
|
| 99 |
/* |
| 100 |
* State information used during parse analysis |
| 101 |
* |
| 102 |
* parentParseState: NULL in a top-level ParseState. When parsing a subquery, |
| 103 |
* links to current parse state of outer query. |
| 104 |
* |
| 105 |
* p_sourcetext: source string that generated the raw parsetree being |
| 106 |
* analyzed, or NULL if not available. (The string is used only to |
| 107 |
* generate cursor positions in error messages: we need it to convert |
| 108 |
* byte-wise locations in parse structures to character-wise cursor |
| 109 |
* positions.) |
| 110 |
* |
| 111 |
* p_rtable: list of RTEs that will become the rangetable of the query. |
| 112 |
* Note that neither relname nor refname of these entries are necessarily |
| 113 |
* unique; searching the rtable by name is a bad idea. |
| 114 |
* |
| 115 |
* p_rteperminfos: list of RTEPermissionInfo containing an entry corresponding |
| 116 |
* to each RTE_RELATION entry in p_rtable. |
| 117 |
* |
| 118 |
* p_joinexprs: list of JoinExpr nodes associated with p_rtable entries. |
| 119 |
* This is one-for-one with p_rtable, but contains NULLs for non-join |
| 120 |
* RTEs, and may be shorter than p_rtable if the last RTE(s) aren't joins. |
| 121 |
* |
| 122 |
* p_nullingrels: list of Bitmapsets associated with p_rtable entries, each |
| 123 |
* containing the set of outer-join RTE indexes that can null that relation |
| 124 |
* at the current point in the parse tree. This is one-for-one with p_rtable, |
| 125 |
* but may be shorter than p_rtable, in which case the missing entries are |
| 126 |
* implicitly empty (NULL). That rule allows us to save work when the query |
| 127 |
* contains no outer joins. |
| 128 |
* |
| 129 |
* p_joinlist: list of join items (RangeTblRef and JoinExpr nodes) that |
| 130 |
* will become the fromlist of the query's top-level FromExpr node. |
| 131 |
* |
| 132 |
* p_namespace: list of ParseNamespaceItems that represents the current |
| 133 |
* namespace for table and column lookup. (The RTEs listed here may be just |
| 134 |
* a subset of the whole rtable. See ParseNamespaceItem comments below.) |
| 135 |
* |
| 136 |
* p_lateral_active: true if we are currently parsing a LATERAL subexpression |
| 137 |
* of this parse level. This makes p_lateral_only namespace items visible, |
| 138 |
* whereas they are not visible when p_lateral_active is FALSE. |
| 139 |
* |
| 140 |
* p_ctenamespace: list of CommonTableExprs (WITH items) that are visible |
| 141 |
* at the moment. This is entirely different from p_namespace because a CTE |
| 142 |
* is not an RTE, rather "visibility" means you could make an RTE from it. |
| 143 |
* |
| 144 |
* p_future_ctes: list of CommonTableExprs (WITH items) that are not yet |
| 145 |
* visible due to scope rules. This is used to help improve error messages. |
| 146 |
* |
| 147 |
* p_parent_cte: CommonTableExpr that immediately contains the current query, |
| 148 |
* if any. |
| 149 |
* |
| 150 |
* p_target_relation: target relation, if query is INSERT/UPDATE/DELETE/MERGE |
| 151 |
* |
| 152 |
* p_target_nsitem: target relation's ParseNamespaceItem. |
| 153 |
* |
| 154 |
* p_grouping_nsitem: the ParseNamespaceItem that represents the grouping step. |
| 155 |
* |
| 156 |
* p_is_insert: true to process assignment expressions like INSERT, false |
| 157 |
* to process them like UPDATE. (Note this can change intra-statement, for |
| 158 |
* cases like INSERT ON CONFLICT UPDATE.) |
| 159 |
* |
| 160 |
* p_windowdefs: list of WindowDefs representing WINDOW and OVER clauses. |
| 161 |
* We collect these while transforming expressions and then transform them |
| 162 |
* afterwards (so that any resjunk tlist items needed for the sort/group |
| 163 |
* clauses end up at the end of the query tlist). A WindowDef's location in |
| 164 |
* this list, counting from 1, is the winref number to use to reference it. |
| 165 |
* |
| 166 |
* p_expr_kind: kind of expression we're currently parsing, as per enum above; |
| 167 |
* EXPR_KIND_NONE when not in an expression. |
| 168 |
* |
| 169 |
* p_next_resno: next TargetEntry.resno to assign, starting from 1. |
| 170 |
* |
| 171 |
* p_multiassign_exprs: partially-processed MultiAssignRef source expressions. |
| 172 |
* |
| 173 |
* p_locking_clause: query's FOR UPDATE/FOR SHARE clause, if any. |
| 174 |
* |
| 175 |
* p_locked_from_parent: true if parent query level applies FOR UPDATE/SHARE |
| 176 |
* to this subquery as a whole. |
| 177 |
* |
| 178 |
* p_resolve_unknowns: resolve unknown-type SELECT output columns as type TEXT |
| 179 |
* (this is true by default). |
| 180 |
* |
| 181 |
* p_hasAggs, p_hasWindowFuncs, etc: true if we've found any of the indicated |
| 182 |
* constructs in the query. |
| 183 |
* |
| 184 |
* p_last_srf: the set-returning FuncExpr or OpExpr most recently found in |
| 185 |
* the query, or NULL if none. |
| 186 |
* |
| 187 |
* p_pre_columnref_hook, etc: optional parser hook functions for modifying the |
| 188 |
* interpretation of ColumnRefs and ParamRefs. |
| 189 |
* |
| 190 |
* p_ref_hook_state: passthrough state for the parser hook functions. |
| 191 |
*/ |
| 192 |
struct ParseState |
| 193 |
{ |
| 194 |
ParseState *parentParseState; /* stack link */ |
| 195 |
const char *p_sourcetext; /* source text, or NULL if not available */ |
| 196 |
List *p_rtable; /* range table so far */ |
| 197 |
List *p_rteperminfos; /* list of RTEPermissionInfo nodes for each |
| 198 |
* RTE_RELATION entry in rtable */ |
| 199 |
List *p_joinexprs; /* JoinExprs for RTE_JOIN p_rtable entries */ |
| 200 |
List *p_nullingrels; /* Bitmapsets showing nulling outer joins */ |
| 201 |
List *p_joinlist; /* join items so far (will become FromExpr |
| 202 |
* node's fromlist) */ |
| 203 |
List *p_namespace; /* currently-referenceable RTEs (List of |
| 204 |
* ParseNamespaceItem) */ |
| 205 |
bool p_lateral_active; /* p_lateral_only items visible? */ |
| 206 |
List *p_ctenamespace; /* current namespace for common table exprs */ |
| 207 |
List *p_future_ctes; /* common table exprs not yet in namespace */ |
| 208 |
CommonTableExpr *p_parent_cte; /* this query's containing CTE */ |
| 209 |
Relation p_target_relation; /* INSERT/UPDATE/DELETE/MERGE target rel */ |
| 210 |
ParseNamespaceItem *p_target_nsitem; /* target rel's NSItem, or NULL */ |
| 211 |
ParseNamespaceItem *p_grouping_nsitem; /* NSItem for grouping, or NULL */ |
| 212 |
bool p_is_insert; /* process assignment like INSERT not UPDATE */ |
| 213 |
List *p_windowdefs; /* raw representations of window clauses */ |
| 214 |
ParseExprKind p_expr_kind; /* what kind of expression we're parsing */ |
| 215 |
int p_next_resno; /* next targetlist resno to assign */ |
| 216 |
List *p_multiassign_exprs; /* junk tlist entries for multiassign */ |
| 217 |
List *p_locking_clause; /* raw FOR UPDATE/FOR SHARE info */ |
| 218 |
bool p_locked_from_parent; /* parent has marked this subquery |
| 219 |
* with FOR UPDATE/FOR SHARE */ |
| 220 |
bool p_resolve_unknowns; /* resolve unknown-type SELECT outputs as |
| 221 |
* type text */ |
| 222 |
|
| 223 |
QueryEnvironment *p_queryEnv; /* curr env, incl refs to enclosing env */ |
| 224 |
|
| 225 |
/* Flags telling about things found in the query: */ |
| 226 |
bool p_hasAggs; |
| 227 |
bool p_hasWindowFuncs; |
| 228 |
bool p_hasTargetSRFs; |
| 229 |
bool p_hasSubLinks; |
| 230 |
bool p_hasModifyingCTE; |
| 231 |
|
| 232 |
Node *p_last_srf; /* most recent set-returning func/op found */ |
| 233 |
|
| 234 |
/* |
| 235 |
* Optional hook functions for parser callbacks. These are null unless |
| 236 |
* set up by the caller of make_parsestate. |
| 237 |
*/ |
| 238 |
PreParseColumnRefHook p_pre_columnref_hook; |
| 239 |
PostParseColumnRefHook p_post_columnref_hook; |
| 240 |
ParseParamRefHook p_paramref_hook; |
| 241 |
CoerceParamHook p_coerce_param_hook; |
| 242 |
void *p_ref_hook_state; /* common passthrough link for above */ |
| 243 |
}; |
| 244 |
|
| 245 |
/* |
| 246 |
* An element of a namespace list. |
| 247 |
* |
| 248 |
* p_names contains the table name and column names exposed by this nsitem. |
| 249 |
* (Typically it's equal to p_rte->eref, but for a JOIN USING alias it's |
| 250 |
* equal to p_rte->join_using_alias. Since the USING columns will be the |
| 251 |
* join's first N columns, the net effect is just that we expose only those |
| 252 |
* join columns via this nsitem.) |
| 253 |
* |
| 254 |
* p_rte and p_rtindex link to the underlying rangetable entry, and |
| 255 |
* p_perminfo to the entry in rteperminfos. |
| 256 |
* |
| 257 |
* The p_nscolumns array contains info showing how to construct Vars |
| 258 |
* referencing the names appearing in the p_names->colnames list. |
| 259 |
* |
| 260 |
* Namespace items with p_rel_visible set define which RTEs are accessible by |
| 261 |
* qualified names, while those with p_cols_visible set define which RTEs are |
| 262 |
* accessible by unqualified names. These sets are different because a JOIN |
| 263 |
* without an alias does not hide the contained tables (so they must be |
| 264 |
* visible for qualified references) but it does hide their columns |
| 265 |
* (unqualified references to the columns refer to the JOIN, not the member |
| 266 |
* tables, so we must not complain that such a reference is ambiguous). |
| 267 |
* Conversely, a subquery without an alias does not hide the columns selected |
| 268 |
* by the subquery, but it does hide the auto-generated relation name (so the |
| 269 |
* subquery columns are visible for unqualified references only). Various |
| 270 |
* special RTEs such as NEW/OLD for rules may also appear with only one flag |
| 271 |
* set. |
| 272 |
* |
| 273 |
* While processing the FROM clause, namespace items may appear with |
| 274 |
* p_lateral_only set, meaning they are visible only to LATERAL |
| 275 |
* subexpressions. (The pstate's p_lateral_active flag tells whether we are |
| 276 |
* inside such a subexpression at the moment.) If p_lateral_ok is not set, |
| 277 |
* it's an error to actually use such a namespace item. One might think it |
| 278 |
* would be better to just exclude such items from visibility, but the wording |
| 279 |
* of SQL:2008 requires us to do it this way. We also use p_lateral_ok to |
| 280 |
* forbid LATERAL references to an UPDATE/DELETE target table. |
| 281 |
* |
| 282 |
* While processing the RETURNING clause, special namespace items are added to |
| 283 |
* refer to the OLD and NEW state of the result relation. These namespace |
| 284 |
* items have p_returning_type set appropriately, for use when creating Vars. |
| 285 |
* For convenience, this information is duplicated on each namespace column. |
| 286 |
* |
| 287 |
* At no time should a namespace list contain two entries that conflict |
| 288 |
* according to the rules in checkNameSpaceConflicts; but note that those |
| 289 |
* are more complicated than "must have different alias names", so in practice |
| 290 |
* code searching a namespace list has to check for ambiguous references. |
| 291 |
*/ |
| 292 |
struct ParseNamespaceItem |
| 293 |
{ |
| 294 |
Alias *p_names; /* Table and column names */ |
| 295 |
RangeTblEntry *p_rte; /* The relation's rangetable entry */ |
| 296 |
int p_rtindex; /* The relation's index in the rangetable */ |
| 297 |
RTEPermissionInfo *p_perminfo; /* The relation's rteperminfos entry */ |
| 298 |
/* array of same length as p_names->colnames: */ |
| 299 |
ParseNamespaceColumn *p_nscolumns; /* per-column data */ |
| 300 |
bool p_rel_visible; /* Relation name is visible? */ |
| 301 |
bool p_cols_visible; /* Column names visible as unqualified refs? */ |
| 302 |
bool p_lateral_only; /* Is only visible to LATERAL expressions? */ |
| 303 |
bool p_lateral_ok; /* If so, does join type allow use? */ |
| 304 |
VarReturningType p_returning_type; /* Is OLD/NEW for use in RETURNING? */ |
| 305 |
}; |
| 306 |
|
| 307 |
/* |
| 308 |
* Data about one column of a ParseNamespaceItem. |
| 309 |
* |
| 310 |
* We track the info needed to construct a Var referencing the column |
| 311 |
* (but only for user-defined columns; system column references and |
| 312 |
* whole-row references are handled separately). |
| 313 |
* |
| 314 |
* p_varno and p_varattno identify the semantic referent, which is a |
| 315 |
* base-relation column unless the reference is to a join USING column that |
| 316 |
* isn't semantically equivalent to either join input column (because it is a |
| 317 |
* FULL join or the input column requires a type coercion). In those cases |
| 318 |
* p_varno and p_varattno refer to the JOIN RTE. |
| 319 |
* |
| 320 |
* p_varnosyn and p_varattnosyn are either identical to p_varno/p_varattno, |
| 321 |
* or they specify the column's position in an aliased JOIN RTE that hides |
| 322 |
* the semantic referent RTE's refname. (That could be either the JOIN RTE |
| 323 |
* in which this ParseNamespaceColumn entry exists, or some lower join level.) |
| 324 |
* |
| 325 |
* If an RTE contains a dropped column, its ParseNamespaceColumn struct |
| 326 |
* is all-zeroes. (Conventionally, test for p_varno == 0 to detect this.) |
| 327 |
*/ |
| 328 |
struct ParseNamespaceColumn |
| 329 |
{ |
| 330 |
Index p_varno; /* rangetable index */ |
| 331 |
AttrNumber p_varattno; /* attribute number of the column */ |
| 332 |
Oid p_vartype; /* pg_type OID */ |
| 333 |
int32 p_vartypmod; /* type modifier value */ |
| 334 |
Oid p_varcollid; /* OID of collation, or InvalidOid */ |
| 335 |
VarReturningType p_varreturningtype; /* for RETURNING OLD/NEW */ |
| 336 |
Index p_varnosyn; /* rangetable index of syntactic referent */ |
| 337 |
AttrNumber p_varattnosyn; /* attribute number of syntactic referent */ |
| 338 |
bool p_dontexpand; /* not included in star expansion */ |
| 339 |
}; |
| 340 |
|
| 341 |
/* Support for parser_errposition_callback function */ |
| 342 |
typedef struct ParseCallbackState |
| 343 |
{ |
| 344 |
ParseState *pstate; |
| 345 |
int location; |
| 346 |
ErrorContextCallback errcallback; |
| 347 |
} ParseCallbackState; |
| 348 |
|
| 349 |
|
| 350 |
extern ParseState *make_parsestate(ParseState *parentParseState); |
| 351 |
extern void free_parsestate(ParseState *pstate); |
| 352 |
extern int parser_errposition(ParseState *pstate, int location); |
| 353 |
|
| 354 |
extern void setup_parser_errposition_callback(ParseCallbackState *pcbstate, |
| 355 |
ParseState *pstate, int location); |
| 356 |
extern void cancel_parser_errposition_callback(ParseCallbackState *pcbstate); |
| 357 |
|
| 358 |
extern void transformContainerType(Oid *containerType, int32 *containerTypmod); |
| 359 |
|
| 360 |
extern SubscriptingRef *transformContainerSubscripts(ParseState *pstate, |
| 361 |
Node *containerBase, |
| 362 |
Oid containerType, |
| 363 |
int32 containerTypMod, |
| 364 |
List *indirection, |
| 365 |
bool isAssignment); |
| 366 |
extern Const *make_const(ParseState *pstate, A_Const *aconst); |
| 367 |
|
| 368 |
#endif /* PARSE_NODE_H */ |