1/*-------------------------------------------------------------------------
2 *
3 * parse_node.h
4 * Internal definitions for parser
5 *
6 *
7 * Portions Copyright (c) 1996-2019, 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/*
23 * Expression kinds distinguished by transformExpr(). Many of these are not
24 * semantically distinct so far as expression transformation goes; rather,
25 * we distinguish them so that context-specific error messages can be printed.
26 *
27 * Note: EXPR_KIND_OTHER is not used in the core code, but is left for use
28 * by extension code that might need to call transformExpr(). The core code
29 * will not enforce any context-driven restrictions on EXPR_KIND_OTHER
30 * expressions, so the caller would have to check for sub-selects, aggregates,
31 * window functions, SRFs, etc if those need to be disallowed.
32 */
33typedef enum ParseExprKind
34{
35 EXPR_KIND_NONE = 0, /* "not in an expression" */
36 EXPR_KIND_OTHER, /* reserved for extensions */
37 EXPR_KIND_JOIN_ON, /* JOIN ON */
38 EXPR_KIND_JOIN_USING, /* JOIN USING */
39 EXPR_KIND_FROM_SUBSELECT, /* sub-SELECT in FROM clause */
40 EXPR_KIND_FROM_FUNCTION, /* function in FROM clause */
41 EXPR_KIND_WHERE, /* WHERE */
42 EXPR_KIND_HAVING, /* HAVING */
43 EXPR_KIND_FILTER, /* FILTER */
44 EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */
45 EXPR_KIND_WINDOW_ORDER, /* window definition ORDER BY */
46 EXPR_KIND_WINDOW_FRAME_RANGE, /* window frame clause with RANGE */
47 EXPR_KIND_WINDOW_FRAME_ROWS, /* window frame clause with ROWS */
48 EXPR_KIND_WINDOW_FRAME_GROUPS, /* window frame clause with GROUPS */
49 EXPR_KIND_SELECT_TARGET, /* SELECT target list item */
50 EXPR_KIND_INSERT_TARGET, /* INSERT target list item */
51 EXPR_KIND_UPDATE_SOURCE, /* UPDATE assignment source item */
52 EXPR_KIND_UPDATE_TARGET, /* UPDATE assignment target item */
53 EXPR_KIND_GROUP_BY, /* GROUP BY */
54 EXPR_KIND_ORDER_BY, /* ORDER BY */
55 EXPR_KIND_DISTINCT_ON, /* DISTINCT ON */
56 EXPR_KIND_LIMIT, /* LIMIT */
57 EXPR_KIND_OFFSET, /* OFFSET */
58 EXPR_KIND_RETURNING, /* RETURNING */
59 EXPR_KIND_VALUES, /* VALUES */
60 EXPR_KIND_VALUES_SINGLE, /* single-row VALUES (in INSERT only) */
61 EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */
62 EXPR_KIND_DOMAIN_CHECK, /* CHECK constraint for a domain */
63 EXPR_KIND_COLUMN_DEFAULT, /* default value for a table column */
64 EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */
65 EXPR_KIND_INDEX_EXPRESSION, /* index expression */
66 EXPR_KIND_INDEX_PREDICATE, /* index predicate */
67 EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */
68 EXPR_KIND_EXECUTE_PARAMETER, /* parameter value in EXECUTE */
69 EXPR_KIND_TRIGGER_WHEN, /* WHEN condition in CREATE TRIGGER */
70 EXPR_KIND_POLICY, /* USING or WITH CHECK expr in policy */
71 EXPR_KIND_PARTITION_BOUND, /* partition bound expression */
72 EXPR_KIND_PARTITION_EXPRESSION, /* PARTITION BY expression */
73 EXPR_KIND_CALL_ARGUMENT, /* procedure argument in CALL */
74 EXPR_KIND_COPY_WHERE, /* WHERE condition in COPY FROM */
75 EXPR_KIND_GENERATED_COLUMN, /* generation expression for a column */
76} ParseExprKind;
77
78
79/*
80 * Function signatures for parser hooks
81 */
82typedef struct ParseState ParseState;
83
84typedef Node *(*PreParseColumnRefHook) (ParseState *pstate, ColumnRef *cref);
85typedef Node *(*PostParseColumnRefHook) (ParseState *pstate, ColumnRef *cref, Node *var);
86typedef Node *(*ParseParamRefHook) (ParseState *pstate, ParamRef *pref);
87typedef Node *(*CoerceParamHook) (ParseState *pstate, Param *param,
88 Oid targetTypeId, int32 targetTypeMod,
89 int location);
90
91
92/*
93 * State information used during parse analysis
94 *
95 * parentParseState: NULL in a top-level ParseState. When parsing a subquery,
96 * links to current parse state of outer query.
97 *
98 * p_sourcetext: source string that generated the raw parsetree being
99 * analyzed, or NULL if not available. (The string is used only to
100 * generate cursor positions in error messages: we need it to convert
101 * byte-wise locations in parse structures to character-wise cursor
102 * positions.)
103 *
104 * p_rtable: list of RTEs that will become the rangetable of the query.
105 * Note that neither relname nor refname of these entries are necessarily
106 * unique; searching the rtable by name is a bad idea.
107 *
108 * p_joinexprs: list of JoinExpr nodes associated with p_rtable entries.
109 * This is one-for-one with p_rtable, but contains NULLs for non-join
110 * RTEs, and may be shorter than p_rtable if the last RTE(s) aren't joins.
111 *
112 * p_joinlist: list of join items (RangeTblRef and JoinExpr nodes) that
113 * will become the fromlist of the query's top-level FromExpr node.
114 *
115 * p_namespace: list of ParseNamespaceItems that represents the current
116 * namespace for table and column lookup. (The RTEs listed here may be just
117 * a subset of the whole rtable. See ParseNamespaceItem comments below.)
118 *
119 * p_lateral_active: true if we are currently parsing a LATERAL subexpression
120 * of this parse level. This makes p_lateral_only namespace items visible,
121 * whereas they are not visible when p_lateral_active is FALSE.
122 *
123 * p_ctenamespace: list of CommonTableExprs (WITH items) that are visible
124 * at the moment. This is entirely different from p_namespace because a CTE
125 * is not an RTE, rather "visibility" means you could make an RTE from it.
126 *
127 * p_future_ctes: list of CommonTableExprs (WITH items) that are not yet
128 * visible due to scope rules. This is used to help improve error messages.
129 *
130 * p_parent_cte: CommonTableExpr that immediately contains the current query,
131 * if any.
132 *
133 * p_target_relation: target relation, if query is INSERT, UPDATE, or DELETE.
134 *
135 * p_target_rangetblentry: target relation's entry in the rtable list.
136 *
137 * p_is_insert: true to process assignment expressions like INSERT, false
138 * to process them like UPDATE. (Note this can change intra-statement, for
139 * cases like INSERT ON CONFLICT UPDATE.)
140 *
141 * p_windowdefs: list of WindowDefs representing WINDOW and OVER clauses.
142 * We collect these while transforming expressions and then transform them
143 * afterwards (so that any resjunk tlist items needed for the sort/group
144 * clauses end up at the end of the query tlist). A WindowDef's location in
145 * this list, counting from 1, is the winref number to use to reference it.
146 *
147 * p_expr_kind: kind of expression we're currently parsing, as per enum above;
148 * EXPR_KIND_NONE when not in an expression.
149 *
150 * p_next_resno: next TargetEntry.resno to assign, starting from 1.
151 *
152 * p_multiassign_exprs: partially-processed MultiAssignRef source expressions.
153 *
154 * p_locking_clause: query's FOR UPDATE/FOR SHARE clause, if any.
155 *
156 * p_locked_from_parent: true if parent query level applies FOR UPDATE/SHARE
157 * to this subquery as a whole.
158 *
159 * p_resolve_unknowns: resolve unknown-type SELECT output columns as type TEXT
160 * (this is true by default).
161 *
162 * p_hasAggs, p_hasWindowFuncs, etc: true if we've found any of the indicated
163 * constructs in the query.
164 *
165 * p_last_srf: the set-returning FuncExpr or OpExpr most recently found in
166 * the query, or NULL if none.
167 *
168 * p_pre_columnref_hook, etc: optional parser hook functions for modifying the
169 * interpretation of ColumnRefs and ParamRefs.
170 *
171 * p_ref_hook_state: passthrough state for the parser hook functions.
172 */
173struct ParseState
174{
175 struct ParseState *parentParseState; /* stack link */
176 const char *p_sourcetext; /* source text, or NULL if not available */
177 List *p_rtable; /* range table so far */
178 List *p_joinexprs; /* JoinExprs for RTE_JOIN p_rtable entries */
179 List *p_joinlist; /* join items so far (will become FromExpr
180 * node's fromlist) */
181 List *p_namespace; /* currently-referenceable RTEs (List of
182 * ParseNamespaceItem) */
183 bool p_lateral_active; /* p_lateral_only items visible? */
184 List *p_ctenamespace; /* current namespace for common table exprs */
185 List *p_future_ctes; /* common table exprs not yet in namespace */
186 CommonTableExpr *p_parent_cte; /* this query's containing CTE */
187 Relation p_target_relation; /* INSERT/UPDATE/DELETE target rel */
188 RangeTblEntry *p_target_rangetblentry; /* target rel's RTE */
189 bool p_is_insert; /* process assignment like INSERT not UPDATE */
190 List *p_windowdefs; /* raw representations of window clauses */
191 ParseExprKind p_expr_kind; /* what kind of expression we're parsing */
192 int p_next_resno; /* next targetlist resno to assign */
193 List *p_multiassign_exprs; /* junk tlist entries for multiassign */
194 List *p_locking_clause; /* raw FOR UPDATE/FOR SHARE info */
195 bool p_locked_from_parent; /* parent has marked this subquery
196 * with FOR UPDATE/FOR SHARE */
197 bool p_resolve_unknowns; /* resolve unknown-type SELECT outputs as
198 * type text */
199
200 QueryEnvironment *p_queryEnv; /* curr env, incl refs to enclosing env */
201
202 /* Flags telling about things found in the query: */
203 bool p_hasAggs;
204 bool p_hasWindowFuncs;
205 bool p_hasTargetSRFs;
206 bool p_hasSubLinks;
207 bool p_hasModifyingCTE;
208
209 Node *p_last_srf; /* most recent set-returning func/op found */
210
211 /*
212 * Optional hook functions for parser callbacks. These are null unless
213 * set up by the caller of make_parsestate.
214 */
215 PreParseColumnRefHook p_pre_columnref_hook;
216 PostParseColumnRefHook p_post_columnref_hook;
217 ParseParamRefHook p_paramref_hook;
218 CoerceParamHook p_coerce_param_hook;
219 void *p_ref_hook_state; /* common passthrough link for above */
220};
221
222/*
223 * An element of a namespace list.
224 *
225 * Namespace items with p_rel_visible set define which RTEs are accessible by
226 * qualified names, while those with p_cols_visible set define which RTEs are
227 * accessible by unqualified names. These sets are different because a JOIN
228 * without an alias does not hide the contained tables (so they must be
229 * visible for qualified references) but it does hide their columns
230 * (unqualified references to the columns refer to the JOIN, not the member
231 * tables, so we must not complain that such a reference is ambiguous).
232 * Various special RTEs such as NEW/OLD for rules may also appear with only
233 * one flag set.
234 *
235 * While processing the FROM clause, namespace items may appear with
236 * p_lateral_only set, meaning they are visible only to LATERAL
237 * subexpressions. (The pstate's p_lateral_active flag tells whether we are
238 * inside such a subexpression at the moment.) If p_lateral_ok is not set,
239 * it's an error to actually use such a namespace item. One might think it
240 * would be better to just exclude such items from visibility, but the wording
241 * of SQL:2008 requires us to do it this way. We also use p_lateral_ok to
242 * forbid LATERAL references to an UPDATE/DELETE target table.
243 *
244 * At no time should a namespace list contain two entries that conflict
245 * according to the rules in checkNameSpaceConflicts; but note that those
246 * are more complicated than "must have different alias names", so in practice
247 * code searching a namespace list has to check for ambiguous references.
248 */
249typedef struct ParseNamespaceItem
250{
251 RangeTblEntry *p_rte; /* The relation's rangetable entry */
252 bool p_rel_visible; /* Relation name is visible? */
253 bool p_cols_visible; /* Column names visible as unqualified refs? */
254 bool p_lateral_only; /* Is only visible to LATERAL expressions? */
255 bool p_lateral_ok; /* If so, does join type allow use? */
256} ParseNamespaceItem;
257
258/* Support for parser_errposition_callback function */
259typedef struct ParseCallbackState
260{
261 ParseState *pstate;
262 int location;
263 ErrorContextCallback errcallback;
264} ParseCallbackState;
265
266
267extern ParseState *make_parsestate(ParseState *parentParseState);
268extern void free_parsestate(ParseState *pstate);
269extern int parser_errposition(ParseState *pstate, int location);
270
271extern void setup_parser_errposition_callback(ParseCallbackState *pcbstate,
272 ParseState *pstate, int location);
273extern void cancel_parser_errposition_callback(ParseCallbackState *pcbstate);
274
275extern Var *make_var(ParseState *pstate, RangeTblEntry *rte, int attrno,
276 int location);
277extern Oid transformContainerType(Oid *containerType, int32 *containerTypmod);
278
279extern SubscriptingRef *transformContainerSubscripts(ParseState *pstate,
280 Node *containerBase,
281 Oid containerType,
282 Oid elementType,
283 int32 containerTypMod,
284 List *indirection,
285 Node *assignFrom);
286extern Const *make_const(ParseState *pstate, Value *value, int location);
287
288#endif /* PARSE_NODE_H */
289