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