Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * analyze.c
4 : * transform the raw parse tree into a query tree
5 : *
6 : * For optimizable statements, we are careful to obtain a suitable lock on
7 : * each referenced table, and other modules of the backend preserve or
8 : * re-obtain these locks before depending on the results. It is therefore
9 : * okay to do significant semantic analysis of these statements. For
10 : * utility commands, no locks are obtained here (and if they were, we could
11 : * not be sure we'd still have them at execution). Hence the general rule
12 : * for utility commands is to just dump them into a Query node untransformed.
13 : * DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are exceptions because they
14 : * contain optimizable statements, which we should transform.
15 : *
16 : *
17 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
18 : * Portions Copyright (c) 1994, Regents of the University of California
19 : *
20 : * src/backend/parser/analyze.c
21 : *
22 : *-------------------------------------------------------------------------
23 : */
24 :
25 : #include "postgres.h"
26 :
27 : #include "access/stratnum.h"
28 : #include "access/sysattr.h"
29 : #include "catalog/dependency.h"
30 : #include "catalog/pg_am.h"
31 : #include "catalog/pg_operator.h"
32 : #include "catalog/pg_proc.h"
33 : #include "catalog/pg_type.h"
34 : #include "commands/defrem.h"
35 : #include "miscadmin.h"
36 : #include "nodes/makefuncs.h"
37 : #include "nodes/nodeFuncs.h"
38 : #include "nodes/queryjumble.h"
39 : #include "optimizer/optimizer.h"
40 : #include "parser/analyze.h"
41 : #include "parser/parse_agg.h"
42 : #include "parser/parse_clause.h"
43 : #include "parser/parse_coerce.h"
44 : #include "parser/parse_collate.h"
45 : #include "parser/parse_cte.h"
46 : #include "parser/parse_expr.h"
47 : #include "parser/parse_func.h"
48 : #include "parser/parse_merge.h"
49 : #include "parser/parse_oper.h"
50 : #include "parser/parse_param.h"
51 : #include "parser/parse_relation.h"
52 : #include "parser/parse_target.h"
53 : #include "parser/parse_type.h"
54 : #include "parser/parsetree.h"
55 : #include "utils/backend_status.h"
56 : #include "utils/builtins.h"
57 : #include "utils/fmgroids.h"
58 : #include "utils/guc.h"
59 : #include "utils/lsyscache.h"
60 : #include "utils/rangetypes.h"
61 : #include "utils/rel.h"
62 : #include "utils/syscache.h"
63 :
64 :
65 : /* Passthrough data for transformPLAssignStmtTarget */
66 : typedef struct SelectStmtPassthrough
67 : {
68 : PLAssignStmt *stmt; /* the assignment statement */
69 : Node *target; /* node representing the target variable */
70 : List *indirection; /* indirection yet to be applied to target */
71 : } SelectStmtPassthrough;
72 :
73 : /* Hook for plugins to get control at end of parse analysis */
74 : post_parse_analyze_hook_type post_parse_analyze_hook = NULL;
75 :
76 : static Query *transformOptionalSelectInto(ParseState *pstate, Node *parseTree);
77 : static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
78 : static Query *transformInsertStmt(ParseState *pstate, InsertStmt *stmt);
79 : static OnConflictExpr *transformOnConflictClause(ParseState *pstate,
80 : OnConflictClause *onConflictClause);
81 : static ForPortionOfExpr *transformForPortionOfClause(ParseState *pstate,
82 : int rtindex,
83 : const ForPortionOfClause *forPortionOf,
84 : const Node *whereClause,
85 : bool isUpdate);
86 : static int count_rowexpr_columns(ParseState *pstate, Node *expr);
87 : static Query *transformSelectStmt(ParseState *pstate, SelectStmt *stmt,
88 : SelectStmtPassthrough *passthru);
89 : static Query *transformValuesClause(ParseState *pstate, SelectStmt *stmt);
90 : static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
91 : static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
92 : bool isTopLevel, List **targetlist);
93 : static void determineRecursiveColTypes(ParseState *pstate,
94 : Node *larg, List *nrtargetlist);
95 : static Query *transformReturnStmt(ParseState *pstate, ReturnStmt *stmt);
96 : static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
97 : static Query *transformPLAssignStmt(ParseState *pstate,
98 : PLAssignStmt *stmt);
99 : static List *transformPLAssignStmtTarget(ParseState *pstate, List *tlist,
100 : SelectStmtPassthrough *passthru);
101 : static Query *transformDeclareCursorStmt(ParseState *pstate,
102 : DeclareCursorStmt *stmt);
103 : static Query *transformExplainStmt(ParseState *pstate,
104 : ExplainStmt *stmt);
105 : static Query *transformCreateTableAsStmt(ParseState *pstate,
106 : CreateTableAsStmt *stmt);
107 : static Query *transformCallStmt(ParseState *pstate,
108 : CallStmt *stmt);
109 : static void transformLockingClause(ParseState *pstate, Query *qry,
110 : LockingClause *lc, bool pushedDown);
111 : #ifdef DEBUG_NODE_TESTS_ENABLED
112 : static bool test_raw_expression_coverage(Node *node, void *context);
113 : #endif
114 :
115 :
116 : /*
117 : * parse_analyze_fixedparams
118 : * Analyze a raw parse tree and transform it to Query form.
119 : *
120 : * Optionally, information about $n parameter types can be supplied.
121 : * References to $n indexes not defined by paramTypes[] are disallowed.
122 : *
123 : * The result is a Query node. Optimizable statements require considerable
124 : * transformation, while utility-type statements are simply hung off
125 : * a dummy CMD_UTILITY Query node.
126 : */
127 : Query *
128 487018 : parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText,
129 : const Oid *paramTypes, int numParams,
130 : QueryEnvironment *queryEnv)
131 : {
132 487018 : ParseState *pstate = make_parsestate(NULL);
133 : Query *query;
134 487018 : JumbleState *jstate = NULL;
135 :
136 : Assert(sourceText != NULL); /* required as of 8.4 */
137 :
138 487018 : pstate->p_sourcetext = sourceText;
139 :
140 487018 : if (numParams > 0)
141 1646 : setup_parse_fixed_parameters(pstate, paramTypes, numParams);
142 :
143 487018 : pstate->p_queryEnv = queryEnv;
144 :
145 487018 : query = transformTopLevelStmt(pstate, parseTree);
146 :
147 481195 : if (IsQueryIdEnabled())
148 75934 : jstate = JumbleQuery(query);
149 :
150 481195 : if (post_parse_analyze_hook)
151 75761 : (*post_parse_analyze_hook) (pstate, query, jstate);
152 :
153 481195 : free_parsestate(pstate);
154 :
155 481195 : pgstat_report_query_id(query->queryId, false);
156 :
157 481195 : return query;
158 : }
159 :
160 : /*
161 : * parse_analyze_varparams
162 : *
163 : * This variant is used when it's okay to deduce information about $n
164 : * symbol datatypes from context. The passed-in paramTypes[] array can
165 : * be modified or enlarged (via repalloc).
166 : */
167 : Query *
168 6975 : parse_analyze_varparams(RawStmt *parseTree, const char *sourceText,
169 : Oid **paramTypes, int *numParams,
170 : QueryEnvironment *queryEnv)
171 : {
172 6975 : ParseState *pstate = make_parsestate(NULL);
173 : Query *query;
174 6975 : JumbleState *jstate = NULL;
175 :
176 : Assert(sourceText != NULL); /* required as of 8.4 */
177 :
178 6975 : pstate->p_sourcetext = sourceText;
179 :
180 6975 : setup_parse_variable_parameters(pstate, paramTypes, numParams);
181 :
182 6975 : pstate->p_queryEnv = queryEnv;
183 :
184 6975 : query = transformTopLevelStmt(pstate, parseTree);
185 :
186 : /* make sure all is well with parameter types */
187 6966 : check_variable_parameters(pstate, query);
188 :
189 6966 : if (IsQueryIdEnabled())
190 288 : jstate = JumbleQuery(query);
191 :
192 6966 : if (post_parse_analyze_hook)
193 288 : (*post_parse_analyze_hook) (pstate, query, jstate);
194 :
195 6966 : free_parsestate(pstate);
196 :
197 6966 : pgstat_report_query_id(query->queryId, false);
198 :
199 6966 : return query;
200 : }
201 :
202 : /*
203 : * parse_analyze_withcb
204 : *
205 : * This variant is used when the caller supplies their own parser callback to
206 : * resolve parameters and possibly other things.
207 : */
208 : Query *
209 25142 : parse_analyze_withcb(RawStmt *parseTree, const char *sourceText,
210 : ParserSetupHook parserSetup,
211 : void *parserSetupArg,
212 : QueryEnvironment *queryEnv)
213 : {
214 25142 : ParseState *pstate = make_parsestate(NULL);
215 : Query *query;
216 25142 : JumbleState *jstate = NULL;
217 :
218 : Assert(sourceText != NULL); /* required as of 8.4 */
219 :
220 25142 : pstate->p_sourcetext = sourceText;
221 25142 : pstate->p_queryEnv = queryEnv;
222 25142 : (*parserSetup) (pstate, parserSetupArg);
223 :
224 25142 : query = transformTopLevelStmt(pstate, parseTree);
225 :
226 25067 : if (IsQueryIdEnabled())
227 4212 : jstate = JumbleQuery(query);
228 :
229 25067 : if (post_parse_analyze_hook)
230 4209 : (*post_parse_analyze_hook) (pstate, query, jstate);
231 :
232 25067 : free_parsestate(pstate);
233 :
234 25067 : pgstat_report_query_id(query->queryId, false);
235 :
236 25067 : return query;
237 : }
238 :
239 :
240 : /*
241 : * parse_sub_analyze
242 : * Entry point for recursively analyzing a sub-statement.
243 : */
244 : Query *
245 69999 : parse_sub_analyze(Node *parseTree, ParseState *parentParseState,
246 : CommonTableExpr *parentCTE,
247 : bool locked_from_parent,
248 : bool resolve_unknowns)
249 : {
250 69999 : ParseState *pstate = make_parsestate(parentParseState);
251 : Query *query;
252 :
253 69999 : pstate->p_parent_cte = parentCTE;
254 69999 : pstate->p_locked_from_parent = locked_from_parent;
255 69999 : pstate->p_resolve_unknowns = resolve_unknowns;
256 :
257 69999 : query = transformStmt(pstate, parseTree);
258 :
259 69858 : free_parsestate(pstate);
260 :
261 69858 : return query;
262 : }
263 :
264 : /*
265 : * transformTopLevelStmt -
266 : * transform a Parse tree into a Query tree.
267 : *
268 : * This function is just responsible for transferring statement location data
269 : * from the RawStmt into the finished Query.
270 : */
271 : Query *
272 521533 : transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
273 : {
274 : Query *result;
275 :
276 : /* We're at top level, so allow SELECT INTO */
277 521533 : result = transformOptionalSelectInto(pstate, parseTree->stmt);
278 :
279 515622 : result->stmt_location = parseTree->stmt_location;
280 515622 : result->stmt_len = parseTree->stmt_len;
281 :
282 515622 : return result;
283 : }
284 :
285 : /*
286 : * transformOptionalSelectInto -
287 : * If SELECT has INTO, convert it to CREATE TABLE AS.
288 : *
289 : * The only thing we do here that we don't do in transformStmt() is to
290 : * convert SELECT ... INTO into CREATE TABLE AS. Since utility statements
291 : * aren't allowed within larger statements, this is only allowed at the top
292 : * of the parse tree, and so we only try it before entering the recursive
293 : * transformStmt() processing.
294 : */
295 : static Query *
296 538071 : transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
297 : {
298 538071 : if (IsA(parseTree, SelectStmt))
299 : {
300 235111 : SelectStmt *stmt = (SelectStmt *) parseTree;
301 :
302 : /* If it's a set-operation tree, drill down to leftmost SelectStmt */
303 242168 : while (stmt && stmt->op != SETOP_NONE)
304 7057 : stmt = stmt->larg;
305 : Assert(stmt && IsA(stmt, SelectStmt) && stmt->larg == NULL);
306 :
307 235111 : if (stmt->intoClause)
308 : {
309 71 : CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
310 :
311 71 : ctas->query = parseTree;
312 71 : ctas->into = stmt->intoClause;
313 71 : ctas->objtype = OBJECT_TABLE;
314 71 : ctas->is_select_into = true;
315 :
316 : /*
317 : * Remove the intoClause from the SelectStmt. This makes it safe
318 : * for transformSelectStmt to complain if it finds intoClause set
319 : * (implying that the INTO appeared in a disallowed place).
320 : */
321 71 : stmt->intoClause = NULL;
322 :
323 71 : parseTree = (Node *) ctas;
324 : }
325 : }
326 :
327 538071 : return transformStmt(pstate, parseTree);
328 : }
329 :
330 : /*
331 : * transformStmt -
332 : * recursively transform a Parse tree into a Query tree.
333 : */
334 : Query *
335 620693 : transformStmt(ParseState *pstate, Node *parseTree)
336 : {
337 : Query *result;
338 :
339 : #ifdef DEBUG_NODE_TESTS_ENABLED
340 :
341 : /*
342 : * We apply debug_raw_expression_coverage_test testing to basic DML
343 : * statements; we can't just run it on everything because
344 : * raw_expression_tree_walker() doesn't claim to handle utility
345 : * statements.
346 : */
347 620693 : if (Debug_raw_expression_coverage_test)
348 : {
349 620693 : switch (nodeTag(parseTree))
350 : {
351 370341 : case T_SelectStmt:
352 : case T_InsertStmt:
353 : case T_UpdateStmt:
354 : case T_DeleteStmt:
355 : case T_MergeStmt:
356 370341 : (void) test_raw_expression_coverage(parseTree, NULL);
357 370341 : break;
358 250352 : default:
359 250352 : break;
360 : }
361 : }
362 : #endif /* DEBUG_NODE_TESTS_ENABLED */
363 :
364 : /*
365 : * Caution: when changing the set of statement types that have non-default
366 : * processing here, see also stmt_requires_parse_analysis() and
367 : * analyze_requires_snapshot().
368 : */
369 620693 : switch (nodeTag(parseTree))
370 : {
371 : /*
372 : * Optimizable statements
373 : */
374 42362 : case T_InsertStmt:
375 42362 : result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
376 41367 : break;
377 :
378 3363 : case T_DeleteStmt:
379 3363 : result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
380 3271 : break;
381 :
382 9305 : case T_UpdateStmt:
383 9305 : result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
384 9168 : break;
385 :
386 1383 : case T_MergeStmt:
387 1383 : result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
388 1339 : break;
389 :
390 313928 : case T_SelectStmt:
391 : {
392 313928 : SelectStmt *n = (SelectStmt *) parseTree;
393 :
394 313928 : if (n->valuesLists)
395 5806 : result = transformValuesClause(pstate, n);
396 308122 : else if (n->op == SETOP_NONE)
397 299665 : result = transformSelectStmt(pstate, n, NULL);
398 : else
399 8457 : result = transformSetOperationStmt(pstate, n);
400 : }
401 309174 : break;
402 :
403 2776 : case T_ReturnStmt:
404 2776 : result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
405 2772 : break;
406 :
407 3452 : case T_PLAssignStmt:
408 3452 : result = transformPLAssignStmt(pstate,
409 : (PLAssignStmt *) parseTree);
410 3439 : break;
411 :
412 : /*
413 : * Special cases
414 : */
415 2752 : case T_DeclareCursorStmt:
416 2752 : result = transformDeclareCursorStmt(pstate,
417 : (DeclareCursorStmt *) parseTree);
418 2739 : break;
419 :
420 16538 : case T_ExplainStmt:
421 16538 : result = transformExplainStmt(pstate,
422 : (ExplainStmt *) parseTree);
423 16529 : break;
424 :
425 1318 : case T_CreateTableAsStmt:
426 1318 : result = transformCreateTableAsStmt(pstate,
427 : (CreateTableAsStmt *) parseTree);
428 1308 : break;
429 :
430 312 : case T_CallStmt:
431 312 : result = transformCallStmt(pstate,
432 : (CallStmt *) parseTree);
433 291 : break;
434 :
435 223204 : default:
436 :
437 : /*
438 : * other statements don't require any transformation; just return
439 : * the original parsetree with a Query node plastered on top.
440 : */
441 223204 : result = makeNode(Query);
442 223204 : result->commandType = CMD_UTILITY;
443 223204 : result->utilityStmt = parseTree;
444 223204 : break;
445 : }
446 :
447 : /* Mark as original query until we learn differently */
448 614601 : result->querySource = QSRC_ORIGINAL;
449 614601 : result->canSetTag = true;
450 :
451 614601 : return result;
452 : }
453 :
454 : /*
455 : * stmt_requires_parse_analysis
456 : * Returns true if parse analysis will do anything non-trivial
457 : * with the given raw parse tree.
458 : *
459 : * Generally, this should return true for any statement type for which
460 : * transformStmt() does more than wrap a CMD_UTILITY Query around it.
461 : * When it returns false, the caller can assume that there is no situation
462 : * in which parse analysis of the raw statement could need to be re-done.
463 : *
464 : * Currently, since the rewriter and planner do nothing for CMD_UTILITY
465 : * Queries, a false result means that the entire parse analysis/rewrite/plan
466 : * pipeline will never need to be re-done. If that ever changes, callers
467 : * will likely need adjustment.
468 : */
469 : bool
470 20600837 : stmt_requires_parse_analysis(RawStmt *parseTree)
471 : {
472 : bool result;
473 :
474 20600837 : switch (nodeTag(parseTree->stmt))
475 : {
476 : /*
477 : * Optimizable statements
478 : */
479 20061279 : case T_InsertStmt:
480 : case T_DeleteStmt:
481 : case T_UpdateStmt:
482 : case T_MergeStmt:
483 : case T_SelectStmt:
484 : case T_ReturnStmt:
485 : case T_PLAssignStmt:
486 20061279 : result = true;
487 20061279 : break;
488 :
489 : /*
490 : * Special cases
491 : */
492 32838 : case T_DeclareCursorStmt:
493 : case T_ExplainStmt:
494 : case T_CreateTableAsStmt:
495 : case T_CallStmt:
496 32838 : result = true;
497 32838 : break;
498 :
499 506720 : default:
500 : /* all other statements just get wrapped in a CMD_UTILITY Query */
501 506720 : result = false;
502 506720 : break;
503 : }
504 :
505 20600837 : return result;
506 : }
507 :
508 : /*
509 : * analyze_requires_snapshot
510 : * Returns true if a snapshot must be set before doing parse analysis
511 : * on the given raw parse tree.
512 : */
513 : bool
514 456455 : analyze_requires_snapshot(RawStmt *parseTree)
515 : {
516 : /*
517 : * Currently, this should return true in exactly the same cases that
518 : * stmt_requires_parse_analysis() does, so we just invoke that function
519 : * rather than duplicating it. We keep the two entry points separate for
520 : * clarity of callers, since from the callers' standpoint these are
521 : * different conditions.
522 : *
523 : * While there may someday be a statement type for which transformStmt()
524 : * does something nontrivial and yet no snapshot is needed for that
525 : * processing, it seems likely that making such a choice would be fragile.
526 : * If you want to install an exception, document the reasoning for it in a
527 : * comment.
528 : */
529 456455 : return stmt_requires_parse_analysis(parseTree);
530 : }
531 :
532 : /*
533 : * query_requires_rewrite_plan()
534 : * Returns true if rewriting or planning is non-trivial for this Query.
535 : *
536 : * This is much like stmt_requires_parse_analysis(), but applies one step
537 : * further down the pipeline.
538 : *
539 : * We do not provide an equivalent of analyze_requires_snapshot(): callers
540 : * can assume that any rewriting or planning activity needs a snapshot.
541 : */
542 : bool
543 377287 : query_requires_rewrite_plan(Query *query)
544 : {
545 : bool result;
546 :
547 377287 : if (query->commandType != CMD_UTILITY)
548 : {
549 : /* All optimizable statements require rewriting/planning */
550 377287 : result = true;
551 : }
552 : else
553 : {
554 : /* This list should match stmt_requires_parse_analysis() */
555 0 : switch (nodeTag(query->utilityStmt))
556 : {
557 0 : case T_DeclareCursorStmt:
558 : case T_ExplainStmt:
559 : case T_CreateTableAsStmt:
560 : case T_CallStmt:
561 0 : result = true;
562 0 : break;
563 0 : default:
564 0 : result = false;
565 0 : break;
566 : }
567 : }
568 377287 : return result;
569 : }
570 :
571 : /*
572 : * transformDeleteStmt -
573 : * transforms a Delete Statement
574 : */
575 : static Query *
576 3363 : transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
577 : {
578 3363 : Query *qry = makeNode(Query);
579 : ParseNamespaceItem *nsitem;
580 : Node *qual;
581 :
582 3363 : qry->commandType = CMD_DELETE;
583 :
584 : /* process the WITH clause independently of all else */
585 3363 : if (stmt->withClause)
586 : {
587 20 : qry->hasRecursive = stmt->withClause->recursive;
588 20 : qry->cteList = transformWithClause(pstate, stmt->withClause);
589 20 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
590 : }
591 :
592 : /* set up range table with just the result rel */
593 6722 : qry->resultRelation = setTargetTable(pstate, stmt->relation,
594 3363 : stmt->relation->inh,
595 : true,
596 : ACL_DELETE);
597 3359 : nsitem = pstate->p_target_nsitem;
598 :
599 : /* disallow DELETE ... WHERE CURRENT OF on a view */
600 3359 : if (stmt->whereClause &&
601 2277 : IsA(stmt->whereClause, CurrentOfExpr) &&
602 80 : pstate->p_target_relation->rd_rel->relkind == RELKIND_VIEW)
603 4 : ereport(ERROR,
604 : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
605 : errmsg("WHERE CURRENT OF on a view is not implemented"));
606 :
607 : /* there's no DISTINCT in DELETE */
608 3355 : qry->distinctClause = NIL;
609 :
610 : /* subqueries in USING cannot access the result relation */
611 3355 : nsitem->p_lateral_only = true;
612 3355 : nsitem->p_lateral_ok = false;
613 :
614 : /*
615 : * The USING clause is non-standard SQL syntax, and is equivalent in
616 : * functionality to the FROM list that can be specified for UPDATE. The
617 : * USING keyword is used rather than FROM because FROM is already a
618 : * keyword in the DELETE syntax.
619 : */
620 3355 : transformFromClause(pstate, stmt->usingClause);
621 :
622 : /* remaining clauses can reference the result relation normally */
623 3343 : nsitem->p_lateral_only = false;
624 3343 : nsitem->p_lateral_ok = true;
625 :
626 3343 : if (stmt->forPortionOf)
627 399 : qry->forPortionOf = transformForPortionOfClause(pstate,
628 : qry->resultRelation,
629 451 : stmt->forPortionOf,
630 451 : stmt->whereClause,
631 : false);
632 :
633 3291 : qual = transformWhereClause(pstate, stmt->whereClause,
634 : EXPR_KIND_WHERE, "WHERE");
635 :
636 3275 : transformReturningClause(pstate, qry, stmt->returningClause,
637 : EXPR_KIND_RETURNING);
638 :
639 : /* done building the range table and jointree */
640 3271 : qry->rtable = pstate->p_rtable;
641 3271 : qry->rteperminfos = pstate->p_rteperminfos;
642 3271 : qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
643 :
644 3271 : qry->hasSubLinks = pstate->p_hasSubLinks;
645 3271 : qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
646 3271 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
647 3271 : qry->hasAggs = pstate->p_hasAggs;
648 :
649 3271 : assign_query_collations(pstate, qry);
650 :
651 : /* this must be done after collations, for reliable comparison of exprs */
652 3271 : if (pstate->p_hasAggs)
653 0 : parseCheckAggregates(pstate, qry);
654 :
655 3271 : return qry;
656 : }
657 :
658 : /*
659 : * transformInsertStmt -
660 : * transform an Insert Statement
661 : */
662 : static Query *
663 42362 : transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
664 : {
665 42362 : Query *qry = makeNode(Query);
666 42362 : SelectStmt *selectStmt = (SelectStmt *) stmt->selectStmt;
667 42362 : List *exprList = NIL;
668 : bool isGeneralSelect;
669 : List *sub_rtable;
670 : List *sub_rteperminfos;
671 : List *sub_namespace;
672 : List *icolumns;
673 : List *attrnos;
674 : ParseNamespaceItem *nsitem;
675 : RTEPermissionInfo *perminfo;
676 : ListCell *icols;
677 : ListCell *attnos;
678 : ListCell *lc;
679 : bool requiresUpdatePerm;
680 : AclMode targetPerms;
681 :
682 : /* There can't be any outer WITH to worry about */
683 : Assert(pstate->p_ctenamespace == NIL);
684 :
685 42362 : qry->commandType = CMD_INSERT;
686 :
687 : /* process the WITH clause independently of all else */
688 42362 : if (stmt->withClause)
689 : {
690 190 : qry->hasRecursive = stmt->withClause->recursive;
691 190 : qry->cteList = transformWithClause(pstate, stmt->withClause);
692 190 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
693 : }
694 :
695 42362 : qry->override = stmt->override;
696 :
697 : /*
698 : * ON CONFLICT DO UPDATE and ON CONFLICT DO SELECT FOR UPDATE/SHARE
699 : * require UPDATE permission on the target relation.
700 : */
701 43920 : requiresUpdatePerm = (stmt->onConflictClause &&
702 1558 : (stmt->onConflictClause->action == ONCONFLICT_UPDATE ||
703 626 : (stmt->onConflictClause->action == ONCONFLICT_SELECT &&
704 240 : stmt->onConflictClause->lockStrength != LCS_NONE)));
705 :
706 : /*
707 : * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
708 : * VALUES list, or general SELECT input. We special-case VALUES, both for
709 : * efficiency and so we can handle DEFAULT specifications.
710 : *
711 : * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
712 : * VALUES clause. If we have any of those, treat it as a general SELECT;
713 : * so it will work, but you can't use DEFAULT items together with those.
714 : */
715 74694 : isGeneralSelect = (selectStmt && (selectStmt->valuesLists == NIL ||
716 32332 : selectStmt->sortClause != NIL ||
717 32332 : selectStmt->limitOffset != NULL ||
718 32332 : selectStmt->limitCount != NULL ||
719 32332 : selectStmt->lockingClause != NIL ||
720 32332 : selectStmt->withClause != NULL));
721 :
722 : /*
723 : * If a non-nil rangetable/namespace was passed in, and we are doing
724 : * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
725 : * down to the SELECT. This can only happen if we are inside a CREATE
726 : * RULE, and in that case we want the rule's OLD and NEW rtable entries to
727 : * appear as part of the SELECT's rtable, not as outer references for it.
728 : * (Kluge!) The SELECT's joinlist is not affected however. We must do
729 : * this before adding the target table to the INSERT's rtable.
730 : */
731 42362 : if (isGeneralSelect)
732 : {
733 4500 : sub_rtable = pstate->p_rtable;
734 4500 : pstate->p_rtable = NIL;
735 4500 : sub_rteperminfos = pstate->p_rteperminfos;
736 4500 : pstate->p_rteperminfos = NIL;
737 4500 : sub_namespace = pstate->p_namespace;
738 4500 : pstate->p_namespace = NIL;
739 : }
740 : else
741 : {
742 37862 : sub_rtable = NIL; /* not used, but keep compiler quiet */
743 37862 : sub_rteperminfos = NIL;
744 37862 : sub_namespace = NIL;
745 : }
746 :
747 : /*
748 : * Must get write lock on INSERT target table before scanning SELECT, else
749 : * we will grab the wrong kind of initial lock if the target table is also
750 : * mentioned in the SELECT part. Note that the target table is not added
751 : * to the joinlist or namespace.
752 : */
753 42362 : targetPerms = ACL_INSERT;
754 42362 : if (requiresUpdatePerm)
755 1010 : targetPerms |= ACL_UPDATE;
756 42362 : qry->resultRelation = setTargetTable(pstate, stmt->relation,
757 : false, false, targetPerms);
758 :
759 : /* Validate stmt->cols list, or build default list if no list given */
760 42346 : icolumns = checkInsertTargets(pstate, stmt->cols, &attrnos);
761 : Assert(list_length(icolumns) == list_length(attrnos));
762 :
763 : /*
764 : * Determine which variant of INSERT we have.
765 : */
766 42314 : if (selectStmt == NULL)
767 : {
768 : /*
769 : * We have INSERT ... DEFAULT VALUES. We can handle this case by
770 : * emitting an empty targetlist --- all columns will be defaulted when
771 : * the planner expands the targetlist.
772 : */
773 5530 : exprList = NIL;
774 : }
775 36784 : else if (isGeneralSelect)
776 : {
777 : /*
778 : * We make the sub-pstate a child of the outer pstate so that it can
779 : * see any Param definitions supplied from above. Since the outer
780 : * pstate's rtable and namespace are presently empty, there are no
781 : * side-effects of exposing names the sub-SELECT shouldn't be able to
782 : * see.
783 : */
784 4500 : ParseState *sub_pstate = make_parsestate(pstate);
785 : Query *selectQuery;
786 :
787 : /*
788 : * Process the source SELECT.
789 : *
790 : * It is important that this be handled just like a standalone SELECT;
791 : * otherwise the behavior of SELECT within INSERT might be different
792 : * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
793 : * bugs of just that nature...)
794 : *
795 : * The sole exception is that we prevent resolving unknown-type
796 : * outputs as TEXT. This does not change the semantics since if the
797 : * column type matters semantically, it would have been resolved to
798 : * something else anyway. Doing this lets us resolve such outputs as
799 : * the target column's type, which we handle below.
800 : */
801 4500 : sub_pstate->p_rtable = sub_rtable;
802 4500 : sub_pstate->p_rteperminfos = sub_rteperminfos;
803 4500 : sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */
804 4500 : sub_pstate->p_nullingrels = NIL;
805 4500 : sub_pstate->p_namespace = sub_namespace;
806 4500 : sub_pstate->p_resolve_unknowns = false;
807 :
808 4500 : selectQuery = transformStmt(sub_pstate, stmt->selectStmt);
809 :
810 4496 : free_parsestate(sub_pstate);
811 :
812 : /* The grammar should have produced a SELECT */
813 4496 : if (!IsA(selectQuery, Query) ||
814 4496 : selectQuery->commandType != CMD_SELECT)
815 0 : elog(ERROR, "unexpected non-SELECT command in INSERT ... SELECT");
816 :
817 : /*
818 : * Make the source be a subquery in the INSERT's rangetable, and add
819 : * it to the INSERT's joinlist (but not the namespace).
820 : */
821 4496 : nsitem = addRangeTableEntryForSubquery(pstate,
822 : selectQuery,
823 : NULL,
824 : false,
825 : false);
826 4496 : addNSItemToQuery(pstate, nsitem, true, false, false);
827 :
828 : /*----------
829 : * Generate an expression list for the INSERT that selects all the
830 : * non-resjunk columns from the subquery. (INSERT's tlist must be
831 : * separate from the subquery's tlist because we may add columns,
832 : * insert datatype coercions, etc.)
833 : *
834 : * HACK: unknown-type constants and params in the SELECT's targetlist
835 : * are copied up as-is rather than being referenced as subquery
836 : * outputs. This is to ensure that when we try to coerce them to
837 : * the target column's datatype, the right things happen (see
838 : * special cases in coerce_type). Otherwise, this fails:
839 : * INSERT INTO foo SELECT 'bar', ... FROM baz
840 : *----------
841 : */
842 4496 : exprList = NIL;
843 15750 : foreach(lc, selectQuery->targetList)
844 : {
845 11254 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
846 : Expr *expr;
847 :
848 11254 : if (tle->resjunk)
849 64 : continue;
850 11190 : if (tle->expr &&
851 13875 : (IsA(tle->expr, Const) || IsA(tle->expr, Param)) &&
852 2685 : exprType((Node *) tle->expr) == UNKNOWNOID)
853 837 : expr = tle->expr;
854 : else
855 : {
856 10353 : Var *var = makeVarFromTargetEntry(nsitem->p_rtindex, tle);
857 :
858 10353 : var->location = exprLocation((Node *) tle->expr);
859 10353 : expr = (Expr *) var;
860 : }
861 11190 : exprList = lappend(exprList, expr);
862 : }
863 :
864 : /* Prepare row for assignment to target table */
865 4496 : exprList = transformInsertRow(pstate, exprList,
866 : stmt->cols,
867 : icolumns, attrnos,
868 : false);
869 : }
870 32284 : else if (list_length(selectStmt->valuesLists) > 1)
871 : {
872 : /*
873 : * Process INSERT ... VALUES with multiple VALUES sublists. We
874 : * generate a VALUES RTE holding the transformed expression lists, and
875 : * build up a targetlist containing Vars that reference the VALUES
876 : * RTE.
877 : */
878 3355 : List *exprsLists = NIL;
879 3355 : List *coltypes = NIL;
880 3355 : List *coltypmods = NIL;
881 3355 : List *colcollations = NIL;
882 3355 : int sublist_length = -1;
883 3355 : bool lateral = false;
884 :
885 : Assert(selectStmt->intoClause == NULL);
886 :
887 14764 : foreach(lc, selectStmt->valuesLists)
888 : {
889 11409 : List *sublist = (List *) lfirst(lc);
890 :
891 : /*
892 : * Do basic expression transformation (same as a ROW() expr, but
893 : * allow SetToDefault at top level)
894 : */
895 11409 : sublist = transformExpressionList(pstate, sublist,
896 : EXPR_KIND_VALUES, true);
897 :
898 : /*
899 : * All the sublists must be the same length, *after*
900 : * transformation (which might expand '*' into multiple items).
901 : * The VALUES RTE can't handle anything different.
902 : */
903 11409 : if (sublist_length < 0)
904 : {
905 : /* Remember post-transformation length of first sublist */
906 3355 : sublist_length = list_length(sublist);
907 : }
908 8054 : else if (sublist_length != list_length(sublist))
909 : {
910 0 : ereport(ERROR,
911 : (errcode(ERRCODE_SYNTAX_ERROR),
912 : errmsg("VALUES lists must all be the same length"),
913 : parser_errposition(pstate,
914 : exprLocation((Node *) sublist))));
915 : }
916 :
917 : /*
918 : * Prepare row for assignment to target table. We process any
919 : * indirection on the target column specs normally but then strip
920 : * off the resulting field/array assignment nodes, since we don't
921 : * want the parsed statement to contain copies of those in each
922 : * VALUES row. (It's annoying to have to transform the
923 : * indirection specs over and over like this, but avoiding it
924 : * would take some really messy refactoring of
925 : * transformAssignmentIndirection.)
926 : */
927 11409 : sublist = transformInsertRow(pstate, sublist,
928 : stmt->cols,
929 : icolumns, attrnos,
930 : true);
931 :
932 : /*
933 : * We must assign collations now because assign_query_collations
934 : * doesn't process rangetable entries. We just assign all the
935 : * collations independently in each row, and don't worry about
936 : * whether they are consistent vertically. The outer INSERT query
937 : * isn't going to care about the collations of the VALUES columns,
938 : * so it's not worth the effort to identify a common collation for
939 : * each one here. (But note this does have one user-visible
940 : * consequence: INSERT ... VALUES won't complain about conflicting
941 : * explicit COLLATEs in a column, whereas the same VALUES
942 : * construct in another context would complain.)
943 : */
944 11409 : assign_list_collations(pstate, sublist);
945 :
946 11409 : exprsLists = lappend(exprsLists, sublist);
947 : }
948 :
949 : /*
950 : * Construct column type/typmod/collation lists for the VALUES RTE.
951 : * Every expression in each column has been coerced to the type/typmod
952 : * of the corresponding target column or subfield, so it's sufficient
953 : * to look at the exprType/exprTypmod of the first row. We don't care
954 : * about the collation labeling, so just fill in InvalidOid for that.
955 : */
956 9736 : foreach(lc, (List *) linitial(exprsLists))
957 : {
958 6381 : Node *val = (Node *) lfirst(lc);
959 :
960 6381 : coltypes = lappend_oid(coltypes, exprType(val));
961 6381 : coltypmods = lappend_int(coltypmods, exprTypmod(val));
962 6381 : colcollations = lappend_oid(colcollations, InvalidOid);
963 : }
964 :
965 : /*
966 : * Ordinarily there can't be any current-level Vars in the expression
967 : * lists, because the namespace was empty ... but if we're inside
968 : * CREATE RULE, then NEW/OLD references might appear. In that case we
969 : * have to mark the VALUES RTE as LATERAL.
970 : */
971 3373 : if (list_length(pstate->p_rtable) != 1 &&
972 18 : contain_vars_of_level((Node *) exprsLists, 0))
973 18 : lateral = true;
974 :
975 : /*
976 : * Generate the VALUES RTE
977 : */
978 3355 : nsitem = addRangeTableEntryForValues(pstate, exprsLists,
979 : coltypes, coltypmods, colcollations,
980 : NULL, lateral, true);
981 3355 : addNSItemToQuery(pstate, nsitem, true, false, false);
982 :
983 : /*
984 : * Generate list of Vars referencing the RTE
985 : */
986 3355 : exprList = expandNSItemVars(pstate, nsitem, 0, -1, NULL);
987 :
988 : /*
989 : * Re-apply any indirection on the target column specs to the Vars
990 : */
991 3355 : exprList = transformInsertRow(pstate, exprList,
992 : stmt->cols,
993 : icolumns, attrnos,
994 : false);
995 : }
996 : else
997 : {
998 : /*
999 : * Process INSERT ... VALUES with a single VALUES sublist. We treat
1000 : * this case separately for efficiency. The sublist is just computed
1001 : * directly as the Query's targetlist, with no VALUES RTE. So it
1002 : * works just like a SELECT without any FROM.
1003 : */
1004 28929 : List *valuesLists = selectStmt->valuesLists;
1005 :
1006 : Assert(list_length(valuesLists) == 1);
1007 : Assert(selectStmt->intoClause == NULL);
1008 :
1009 : /*
1010 : * Do basic expression transformation (same as a ROW() expr, but allow
1011 : * SetToDefault at top level)
1012 : */
1013 28929 : exprList = transformExpressionList(pstate,
1014 28929 : (List *) linitial(valuesLists),
1015 : EXPR_KIND_VALUES_SINGLE,
1016 : true);
1017 :
1018 : /* Prepare row for assignment to target table */
1019 28913 : exprList = transformInsertRow(pstate, exprList,
1020 : stmt->cols,
1021 : icolumns, attrnos,
1022 : false);
1023 : }
1024 :
1025 : /*
1026 : * Generate query's target list using the computed list of expressions.
1027 : * Also, mark all the target columns as needing insert permissions.
1028 : */
1029 41443 : perminfo = pstate->p_target_nsitem->p_perminfo;
1030 41443 : qry->targetList = NIL;
1031 : Assert(list_length(exprList) <= list_length(icolumns));
1032 122088 : forthree(lc, exprList, icols, icolumns, attnos, attrnos)
1033 : {
1034 80645 : Expr *expr = (Expr *) lfirst(lc);
1035 80645 : ResTarget *col = lfirst_node(ResTarget, icols);
1036 80645 : AttrNumber attr_num = (AttrNumber) lfirst_int(attnos);
1037 : TargetEntry *tle;
1038 :
1039 80645 : tle = makeTargetEntry(expr,
1040 : attr_num,
1041 : col->name,
1042 : false);
1043 80645 : qry->targetList = lappend(qry->targetList, tle);
1044 :
1045 80645 : perminfo->insertedCols = bms_add_member(perminfo->insertedCols,
1046 : attr_num - FirstLowInvalidHeapAttributeNumber);
1047 : }
1048 :
1049 : /*
1050 : * If we have any clauses yet to process, set the query namespace to
1051 : * contain only the target relation, removing any entries added in a
1052 : * sub-SELECT or VALUES list.
1053 : */
1054 41443 : if (stmt->onConflictClause || stmt->returningClause)
1055 : {
1056 2206 : pstate->p_namespace = NIL;
1057 2206 : addNSItemToQuery(pstate, pstate->p_target_nsitem,
1058 : false, true, true);
1059 : }
1060 :
1061 : /* ON CONFLICT DO SELECT requires a RETURNING clause */
1062 41443 : if (stmt->onConflictClause &&
1063 1558 : stmt->onConflictClause->action == ONCONFLICT_SELECT &&
1064 240 : !stmt->returningClause)
1065 4 : ereport(ERROR,
1066 : errcode(ERRCODE_SYNTAX_ERROR),
1067 : errmsg("ON CONFLICT DO SELECT requires a RETURNING clause"),
1068 : parser_errposition(pstate, stmt->onConflictClause->location));
1069 :
1070 : /* Process ON CONFLICT, if any. */
1071 41439 : if (stmt->onConflictClause)
1072 1554 : qry->onConflict = transformOnConflictClause(pstate,
1073 : stmt->onConflictClause);
1074 :
1075 : /* Process RETURNING, if any. */
1076 41399 : if (stmt->returningClause)
1077 1099 : transformReturningClause(pstate, qry, stmt->returningClause,
1078 : EXPR_KIND_RETURNING);
1079 :
1080 : /* done building the range table and jointree */
1081 41367 : qry->rtable = pstate->p_rtable;
1082 41367 : qry->rteperminfos = pstate->p_rteperminfos;
1083 41367 : qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
1084 :
1085 41367 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1086 41367 : qry->hasSubLinks = pstate->p_hasSubLinks;
1087 :
1088 41367 : assign_query_collations(pstate, qry);
1089 :
1090 41367 : return qry;
1091 : }
1092 :
1093 : /*
1094 : * Prepare an INSERT row for assignment to the target table.
1095 : *
1096 : * exprlist: transformed expressions for source values; these might come from
1097 : * a VALUES row, or be Vars referencing a sub-SELECT or VALUES RTE output.
1098 : * stmtcols: original target-columns spec for INSERT (we just test for NIL)
1099 : * icolumns: effective target-columns spec (list of ResTarget)
1100 : * attrnos: integer column numbers (must be same length as icolumns)
1101 : * strip_indirection: if true, remove any field/array assignment nodes
1102 : */
1103 : List *
1104 48829 : transformInsertRow(ParseState *pstate, List *exprlist,
1105 : List *stmtcols, List *icolumns, List *attrnos,
1106 : bool strip_indirection)
1107 : {
1108 : List *result;
1109 : ListCell *lc;
1110 : ListCell *icols;
1111 : ListCell *attnos;
1112 :
1113 : /*
1114 : * Check length of expr list. It must not have more expressions than
1115 : * there are target columns. We allow fewer, but only if no explicit
1116 : * columns list was given (the remaining columns are implicitly
1117 : * defaulted). Note we must check this *after* transformation because
1118 : * that could expand '*' into multiple items.
1119 : */
1120 48829 : if (list_length(exprlist) > list_length(icolumns))
1121 17 : ereport(ERROR,
1122 : (errcode(ERRCODE_SYNTAX_ERROR),
1123 : errmsg("INSERT has more expressions than target columns"),
1124 : parser_errposition(pstate,
1125 : exprLocation(list_nth(exprlist,
1126 : list_length(icolumns))))));
1127 59773 : if (stmtcols != NIL &&
1128 10961 : list_length(exprlist) < list_length(icolumns))
1129 : {
1130 : /*
1131 : * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
1132 : * where the user accidentally created a RowExpr instead of separate
1133 : * columns. Add a suitable hint if that seems to be the problem,
1134 : * because the main error message is quite misleading for this case.
1135 : * (If there's no stmtcols, you'll get something about data type
1136 : * mismatch, which is less misleading so we don't worry about giving a
1137 : * hint in that case.)
1138 : */
1139 8 : ereport(ERROR,
1140 : (errcode(ERRCODE_SYNTAX_ERROR),
1141 : errmsg("INSERT has more target columns than expressions"),
1142 : ((list_length(exprlist) == 1 &&
1143 : count_rowexpr_columns(pstate, linitial(exprlist)) ==
1144 : list_length(icolumns)) ?
1145 : errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
1146 : parser_errposition(pstate,
1147 : exprLocation(list_nth(icolumns,
1148 : list_length(exprlist))))));
1149 : }
1150 :
1151 : /*
1152 : * Prepare columns for assignment to target table.
1153 : */
1154 48804 : result = NIL;
1155 155912 : forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
1156 : {
1157 107934 : Expr *expr = (Expr *) lfirst(lc);
1158 107934 : ResTarget *col = lfirst_node(ResTarget, icols);
1159 107934 : int attno = lfirst_int(attnos);
1160 :
1161 107934 : expr = transformAssignedExpr(pstate, expr,
1162 : EXPR_KIND_INSERT_TARGET,
1163 107934 : col->name,
1164 : attno,
1165 : col->indirection,
1166 : col->location);
1167 :
1168 107108 : if (strip_indirection)
1169 : {
1170 : /*
1171 : * We need to remove top-level FieldStores and SubscriptingRefs,
1172 : * as well as any CoerceToDomain appearing above one of those ---
1173 : * but not a CoerceToDomain that isn't above one of those.
1174 : */
1175 25319 : while (expr)
1176 : {
1177 25319 : Expr *subexpr = expr;
1178 :
1179 25495 : while (IsA(subexpr, CoerceToDomain))
1180 : {
1181 176 : subexpr = ((CoerceToDomain *) subexpr)->arg;
1182 : }
1183 25319 : if (IsA(subexpr, FieldStore))
1184 : {
1185 144 : FieldStore *fstore = (FieldStore *) subexpr;
1186 :
1187 144 : expr = (Expr *) linitial(fstore->newvals);
1188 : }
1189 25175 : else if (IsA(subexpr, SubscriptingRef))
1190 : {
1191 232 : SubscriptingRef *sbsref = (SubscriptingRef *) subexpr;
1192 :
1193 232 : if (sbsref->refassgnexpr == NULL)
1194 0 : break;
1195 :
1196 232 : expr = sbsref->refassgnexpr;
1197 : }
1198 : else
1199 24943 : break;
1200 : }
1201 : }
1202 :
1203 107108 : result = lappend(result, expr);
1204 : }
1205 :
1206 47978 : return result;
1207 : }
1208 :
1209 : /*
1210 : * transformOnConflictClause -
1211 : * transforms an OnConflictClause in an INSERT
1212 : */
1213 : static OnConflictExpr *
1214 1554 : transformOnConflictClause(ParseState *pstate,
1215 : OnConflictClause *onConflictClause)
1216 : {
1217 1554 : ParseNamespaceItem *exclNSItem = NULL;
1218 : List *arbiterElems;
1219 : Node *arbiterWhere;
1220 : Oid arbiterConstraint;
1221 1554 : List *onConflictSet = NIL;
1222 1554 : Node *onConflictWhere = NULL;
1223 1554 : int exclRelIndex = 0;
1224 1554 : List *exclRelTlist = NIL;
1225 : OnConflictExpr *result;
1226 :
1227 : /*
1228 : * If this is ON CONFLICT DO SELECT/UPDATE, first create the range table
1229 : * entry for the EXCLUDED pseudo relation, so that that will be present
1230 : * while processing arbiter expressions. (You can't actually reference it
1231 : * from there, but this provides a useful error message if you try.)
1232 : */
1233 1554 : if (onConflictClause->action == ONCONFLICT_UPDATE ||
1234 622 : onConflictClause->action == ONCONFLICT_SELECT)
1235 : {
1236 1168 : Relation targetrel = pstate->p_target_relation;
1237 : RangeTblEntry *exclRte;
1238 :
1239 1168 : exclNSItem = addRangeTableEntryForRelation(pstate,
1240 : targetrel,
1241 : RowExclusiveLock,
1242 : makeAlias("excluded", NIL),
1243 : false, false);
1244 1168 : exclRte = exclNSItem->p_rte;
1245 1168 : exclRelIndex = exclNSItem->p_rtindex;
1246 :
1247 : /*
1248 : * relkind is set to composite to signal that we're not dealing with
1249 : * an actual relation, and no permission checks are required on it.
1250 : * (We'll check the actual target relation, instead.)
1251 : */
1252 1168 : exclRte->relkind = RELKIND_COMPOSITE_TYPE;
1253 :
1254 : /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
1255 1168 : exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel,
1256 : exclRelIndex);
1257 : }
1258 :
1259 : /* Process the arbiter clause, ON CONFLICT ON (...) */
1260 1554 : transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems,
1261 : &arbiterWhere, &arbiterConstraint);
1262 :
1263 : /* Process DO SELECT/UPDATE */
1264 1534 : if (onConflictClause->action == ONCONFLICT_UPDATE ||
1265 610 : onConflictClause->action == ONCONFLICT_SELECT)
1266 : {
1267 : /*
1268 : * Add the EXCLUDED pseudo relation to the query namespace, making it
1269 : * available in SET and WHERE subexpressions.
1270 : */
1271 1160 : addNSItemToQuery(pstate, exclNSItem, false, true, true);
1272 :
1273 : /* Process the UPDATE SET clause */
1274 1160 : if (onConflictClause->action == ONCONFLICT_UPDATE)
1275 : onConflictSet =
1276 924 : transformUpdateTargetList(pstate, onConflictClause->targetList, NULL);
1277 :
1278 : /* Process the SELECT/UPDATE WHERE clause */
1279 1140 : onConflictWhere = transformWhereClause(pstate,
1280 : onConflictClause->whereClause,
1281 : EXPR_KIND_WHERE, "WHERE");
1282 :
1283 : /*
1284 : * Remove the EXCLUDED pseudo relation from the query namespace, since
1285 : * it's not supposed to be available in RETURNING. (Maybe someday we
1286 : * could allow that, and drop this step.)
1287 : */
1288 : Assert((ParseNamespaceItem *) llast(pstate->p_namespace) == exclNSItem);
1289 1140 : pstate->p_namespace = list_delete_last(pstate->p_namespace);
1290 : }
1291 :
1292 : /* Finally, build ON CONFLICT DO [NOTHING | SELECT | UPDATE] expression */
1293 1514 : result = makeNode(OnConflictExpr);
1294 :
1295 1514 : result->action = onConflictClause->action;
1296 1514 : result->arbiterElems = arbiterElems;
1297 1514 : result->arbiterWhere = arbiterWhere;
1298 1514 : result->constraint = arbiterConstraint;
1299 1514 : result->lockStrength = onConflictClause->lockStrength;
1300 1514 : result->onConflictSet = onConflictSet;
1301 1514 : result->onConflictWhere = onConflictWhere;
1302 1514 : result->exclRelIndex = exclRelIndex;
1303 1514 : result->exclRelTlist = exclRelTlist;
1304 :
1305 1514 : return result;
1306 : }
1307 :
1308 : /*
1309 : * transformForPortionOfClause
1310 : *
1311 : * Transforms a ForPortionOfClause in an UPDATE/DELETE statement.
1312 : *
1313 : * - Look up the range/period requested.
1314 : * - Build a compatible range value from the FROM and TO expressions.
1315 : * - Build an "overlaps" expression for filtering, used later by the
1316 : * rewriter.
1317 : * - For UPDATEs, build an "intersects" expression the rewriter can add
1318 : * to the targetList to change the temporal bounds.
1319 : */
1320 : static ForPortionOfExpr *
1321 1041 : transformForPortionOfClause(ParseState *pstate,
1322 : int rtindex,
1323 : const ForPortionOfClause *forPortionOf,
1324 : const Node *whereClause,
1325 : bool isUpdate)
1326 : {
1327 1041 : Relation targetrel = pstate->p_target_relation;
1328 1041 : int range_attno = InvalidAttrNumber;
1329 : Form_pg_attribute attr;
1330 : Oid attbasetype;
1331 : Oid opclass;
1332 : Oid opfamily;
1333 : Oid opcintype;
1334 1041 : Oid funcid = InvalidOid;
1335 : StrategyNumber strat;
1336 : Oid opid;
1337 : OpExpr *op;
1338 : ForPortionOfExpr *result;
1339 : Var *rangeVar;
1340 :
1341 : /* disallow FOR PORTION OF ... WHERE CURRENT OF */
1342 1041 : if (whereClause && IsA(whereClause, CurrentOfExpr))
1343 8 : ereport(ERROR,
1344 : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1345 : errmsg("WHERE CURRENT OF with FOR PORTION OF is not implemented"));
1346 :
1347 1033 : result = makeNode(ForPortionOfExpr);
1348 :
1349 : /* Look up the FOR PORTION OF name requested. */
1350 1033 : range_attno = attnameAttNum(targetrel, forPortionOf->range_name, false);
1351 1033 : if (range_attno == InvalidAttrNumber)
1352 8 : ereport(ERROR,
1353 : (errcode(ERRCODE_UNDEFINED_COLUMN),
1354 : errmsg("column \"%s\" of relation \"%s\" does not exist",
1355 : forPortionOf->range_name,
1356 : RelationGetRelationName(targetrel)),
1357 : parser_errposition(pstate, forPortionOf->location)));
1358 1025 : attr = TupleDescAttr(targetrel->rd_att, range_attno - 1);
1359 :
1360 1025 : attbasetype = getBaseType(attr->atttypid);
1361 :
1362 1025 : rangeVar = makeVar(rtindex,
1363 : range_attno,
1364 : attr->atttypid,
1365 : attr->atttypmod,
1366 : attr->attcollation,
1367 : 0);
1368 1025 : rangeVar->location = forPortionOf->location;
1369 1025 : result->rangeVar = rangeVar;
1370 :
1371 : /* Require SELECT privilege on the application-time column. */
1372 1025 : markVarForSelectPriv(pstate, rangeVar);
1373 :
1374 : /*
1375 : * Use the basetype for the target, which shouldn't be required to follow
1376 : * domain rules. The table's column type is in the Var if we need it.
1377 : */
1378 1025 : result->rangeType = attbasetype;
1379 1025 : result->isDomain = attbasetype != attr->atttypid;
1380 :
1381 1025 : if (forPortionOf->target)
1382 : {
1383 200 : Oid declared_target_type = attbasetype;
1384 : Oid actual_target_type;
1385 :
1386 : /*
1387 : * We were already given an expression for the target, so we don't
1388 : * have to build anything. We still have to make sure we got the right
1389 : * type. NULL will be caught be the executor.
1390 : */
1391 :
1392 400 : result->targetRange = transformExpr(pstate,
1393 200 : forPortionOf->target,
1394 : EXPR_KIND_FOR_PORTION);
1395 :
1396 200 : actual_target_type = exprType(result->targetRange);
1397 :
1398 200 : if (!can_coerce_type(1, &actual_target_type, &declared_target_type, COERCION_IMPLICIT))
1399 32 : ereport(ERROR,
1400 : (errcode(ERRCODE_DATATYPE_MISMATCH),
1401 : errmsg("could not coerce FOR PORTION OF target from %s to %s",
1402 : format_type_be(actual_target_type),
1403 : format_type_be(declared_target_type)),
1404 : parser_errposition(pstate, exprLocation(forPortionOf->target))));
1405 :
1406 168 : result->targetRange = coerce_type(pstate,
1407 : result->targetRange,
1408 : actual_target_type,
1409 : declared_target_type,
1410 : -1,
1411 : COERCION_IMPLICIT,
1412 : COERCE_IMPLICIT_CAST,
1413 168 : exprLocation(forPortionOf->target));
1414 :
1415 : /*
1416 : * XXX: For now we only support ranges and multiranges, so we fail on
1417 : * anything else.
1418 : */
1419 168 : if (!type_is_range(attbasetype) && !type_is_multirange(attbasetype))
1420 24 : ereport(ERROR,
1421 : (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1422 : errmsg("column \"%s\" of relation \"%s\" is not a range or multirange type",
1423 : forPortionOf->range_name,
1424 : RelationGetRelationName(targetrel)),
1425 : parser_errposition(pstate, forPortionOf->location)));
1426 :
1427 : }
1428 : else
1429 : {
1430 : Oid rngsubtype;
1431 : Oid declared_arg_types[2];
1432 : Oid actual_arg_types[2];
1433 : List *args;
1434 :
1435 : /*
1436 : * Make sure it's a range column. XXX: We could support this syntax on
1437 : * multirange columns too, if we just built a one-range multirange
1438 : * from the FROM/TO phrases.
1439 : */
1440 825 : if (!type_is_range(attbasetype))
1441 8 : ereport(ERROR,
1442 : (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1443 : errmsg("column \"%s\" of relation \"%s\" is not a range type",
1444 : forPortionOf->range_name,
1445 : RelationGetRelationName(targetrel)),
1446 : parser_errposition(pstate, forPortionOf->location)));
1447 :
1448 817 : rngsubtype = get_range_subtype(attbasetype);
1449 817 : declared_arg_types[0] = rngsubtype;
1450 817 : declared_arg_types[1] = rngsubtype;
1451 :
1452 : /*
1453 : * Build a range from the FROM ... TO ... bounds. This should give a
1454 : * constant result, so we accept functions like NOW() but not column
1455 : * references, subqueries, etc.
1456 : */
1457 1618 : result->targetFrom = transformExpr(pstate,
1458 817 : forPortionOf->target_start,
1459 : EXPR_KIND_FOR_PORTION);
1460 1602 : result->targetTo = transformExpr(pstate,
1461 801 : forPortionOf->target_end,
1462 : EXPR_KIND_FOR_PORTION);
1463 801 : actual_arg_types[0] = exprType(result->targetFrom);
1464 801 : actual_arg_types[1] = exprType(result->targetTo);
1465 801 : args = list_make2(copyObject(result->targetFrom),
1466 : copyObject(result->targetTo));
1467 :
1468 : /*
1469 : * Check the bound types separately, for better error message and
1470 : * location
1471 : */
1472 801 : if (!can_coerce_type(1, actual_arg_types, declared_arg_types, COERCION_IMPLICIT))
1473 8 : ereport(ERROR,
1474 : (errcode(ERRCODE_DATATYPE_MISMATCH),
1475 : errmsg("could not coerce FOR PORTION OF %s bound from %s to %s",
1476 : "FROM",
1477 : format_type_be(actual_arg_types[0]),
1478 : format_type_be(declared_arg_types[0])),
1479 : parser_errposition(pstate, exprLocation(forPortionOf->target_start))));
1480 793 : if (!can_coerce_type(1, &actual_arg_types[1], &declared_arg_types[1], COERCION_IMPLICIT))
1481 8 : ereport(ERROR,
1482 : (errcode(ERRCODE_DATATYPE_MISMATCH),
1483 : errmsg("could not coerce FOR PORTION OF %s bound from %s to %s",
1484 : "TO",
1485 : format_type_be(actual_arg_types[1]),
1486 : format_type_be(declared_arg_types[1])),
1487 : parser_errposition(pstate, exprLocation(forPortionOf->target_end))));
1488 :
1489 785 : make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
1490 785 : result->targetRange = (Node *) makeFuncExpr(get_range_constructor2(attbasetype),
1491 : attbasetype,
1492 : args,
1493 : InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL);
1494 : }
1495 :
1496 : /*
1497 : * Build overlapsExpr to use as an extra qual. This means we only hit rows
1498 : * matching the FROM & TO bounds. We must look up the overlaps operator
1499 : * (usually "&&").
1500 : */
1501 929 : opclass = GetDefaultOpClass(attr->atttypid, GIST_AM_OID);
1502 929 : if (!OidIsValid(opclass))
1503 0 : ereport(ERROR,
1504 : (errcode(ERRCODE_UNDEFINED_OBJECT),
1505 : errmsg("data type %s has no default operator class for access method \"%s\"",
1506 : format_type_be(attr->atttypid), "gist"),
1507 : errhint("You must define a default operator class for the data type.")));
1508 :
1509 : /* Look up the operators and functions we need. */
1510 929 : GetOperatorFromCompareType(opclass, InvalidOid, COMPARE_OVERLAP, &opid, &strat);
1511 929 : op = makeNode(OpExpr);
1512 929 : op->opno = opid;
1513 929 : op->opfuncid = get_opcode(opid);
1514 929 : op->opresulttype = BOOLOID;
1515 929 : op->args = list_make2(copyObject(rangeVar), copyObject(result->targetRange));
1516 929 : result->overlapsExpr = (Node *) op;
1517 :
1518 : /*
1519 : * Look up the without_portion func. This computes the bounds of temporal
1520 : * leftovers.
1521 : *
1522 : * XXX: Find a more extensible way to look up the function, permitting
1523 : * user-defined types. An opclass support function doesn't make sense,
1524 : * since there is no index involved. Perhaps a type support function.
1525 : */
1526 929 : if (get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
1527 929 : switch (opcintype)
1528 : {
1529 841 : case ANYRANGEOID:
1530 841 : result->withoutPortionProc = F_RANGE_MINUS_MULTI;
1531 841 : break;
1532 88 : case ANYMULTIRANGEOID:
1533 88 : result->withoutPortionProc = F_MULTIRANGE_MINUS_MULTI;
1534 88 : break;
1535 0 : default:
1536 0 : elog(ERROR, "unexpected opcintype: %u", opcintype);
1537 : }
1538 : else
1539 0 : elog(ERROR, "unexpected opclass: %u", opclass);
1540 :
1541 929 : if (isUpdate)
1542 : {
1543 : /*
1544 : * Now make sure we update the start/end time of the record. For a
1545 : * range col (r) this is `r = r * targetRange` (where * is the
1546 : * intersect operator).
1547 : */
1548 : Oid intersectoperoid;
1549 : List *funcArgs;
1550 : Node *rangeTLEExpr;
1551 : TargetEntry *tle;
1552 530 : RTEPermissionInfo *target_perminfo = pstate->p_target_nsitem->p_perminfo;
1553 :
1554 : /*
1555 : * Whatever operator is used for intersect by temporal foreign keys,
1556 : * we can use its backing procedure for intersects in FOR PORTION OF.
1557 : * XXX: Share code with FindFKPeriodOpers?
1558 : */
1559 530 : switch (opcintype)
1560 : {
1561 482 : case ANYRANGEOID:
1562 482 : intersectoperoid = OID_RANGE_INTERSECT_RANGE_OP;
1563 482 : break;
1564 48 : case ANYMULTIRANGEOID:
1565 48 : intersectoperoid = OID_MULTIRANGE_INTERSECT_MULTIRANGE_OP;
1566 48 : break;
1567 0 : default:
1568 0 : elog(ERROR, "unexpected opcintype: %u", opcintype);
1569 : }
1570 530 : funcid = get_opcode(intersectoperoid);
1571 530 : if (!OidIsValid(funcid))
1572 0 : ereport(ERROR,
1573 : errcode(ERRCODE_UNDEFINED_OBJECT),
1574 : errmsg("could not identify an intersect function for type %s",
1575 : format_type_be(opcintype)));
1576 :
1577 530 : funcArgs = list_make2(copyObject(rangeVar),
1578 : copyObject(result->targetRange));
1579 530 : rangeTLEExpr = (Node *) makeFuncExpr(funcid, attbasetype, funcArgs,
1580 : InvalidOid, InvalidOid,
1581 : COERCE_EXPLICIT_CALL);
1582 :
1583 : /*
1584 : * Coerce to domain if necessary. If we skip this, we will allow
1585 : * updating to forbidden values.
1586 : */
1587 530 : rangeTLEExpr = coerce_type(pstate,
1588 : rangeTLEExpr,
1589 : attbasetype,
1590 : attr->atttypid,
1591 : -1,
1592 : COERCION_IMPLICIT,
1593 : COERCE_IMPLICIT_CAST,
1594 530 : exprLocation(forPortionOf->target));
1595 :
1596 : /* Make a TLE to set the range column */
1597 530 : result->rangeTargetList = NIL;
1598 530 : tle = makeTargetEntry((Expr *) rangeTLEExpr, range_attno,
1599 530 : forPortionOf->range_name, false);
1600 530 : result->rangeTargetList = lappend(result->rangeTargetList, tle);
1601 :
1602 : /* Mark the range column as requiring update permissions */
1603 530 : target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
1604 : range_attno - FirstLowInvalidHeapAttributeNumber);
1605 : }
1606 : else
1607 399 : result->rangeTargetList = NIL;
1608 :
1609 929 : result->range_name = forPortionOf->range_name;
1610 929 : result->location = forPortionOf->location;
1611 929 : result->targetLocation = forPortionOf->target_location;
1612 :
1613 929 : return result;
1614 : }
1615 :
1616 : /*
1617 : * BuildOnConflictExcludedTargetlist
1618 : * Create target list for the EXCLUDED pseudo-relation of ON CONFLICT,
1619 : * representing the columns of targetrel with varno exclRelIndex.
1620 : *
1621 : * Note: Exported for use in the rewriter.
1622 : */
1623 : List *
1624 1316 : BuildOnConflictExcludedTargetlist(Relation targetrel,
1625 : Index exclRelIndex)
1626 : {
1627 1316 : List *result = NIL;
1628 : int attno;
1629 : Var *var;
1630 : TargetEntry *te;
1631 :
1632 : /*
1633 : * Note that resnos of the tlist must correspond to attnos of the
1634 : * underlying relation, hence we need entries for dropped columns too.
1635 : */
1636 4719 : for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
1637 : {
1638 3403 : Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
1639 : char *name;
1640 :
1641 3403 : if (attr->attisdropped)
1642 : {
1643 : /*
1644 : * can't use atttypid here, but it doesn't really matter what type
1645 : * the Const claims to be.
1646 : */
1647 74 : var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
1648 74 : name = NULL;
1649 : }
1650 : else
1651 : {
1652 3329 : var = makeVar(exclRelIndex, attno + 1,
1653 : attr->atttypid, attr->atttypmod,
1654 : attr->attcollation,
1655 : 0);
1656 3329 : name = pstrdup(NameStr(attr->attname));
1657 : }
1658 :
1659 3403 : te = makeTargetEntry((Expr *) var,
1660 3403 : attno + 1,
1661 : name,
1662 : false);
1663 :
1664 3403 : result = lappend(result, te);
1665 : }
1666 :
1667 : /*
1668 : * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1669 : * the other entries in the EXCLUDED tlist, its resno must match the Var's
1670 : * varattno, else the wrong things happen while resolving references in
1671 : * setrefs.c. This is against normal conventions for targetlists, but
1672 : * it's okay since we don't use this as a real tlist.
1673 : */
1674 1316 : var = makeVar(exclRelIndex, InvalidAttrNumber,
1675 1316 : targetrel->rd_rel->reltype,
1676 : -1, InvalidOid, 0);
1677 1316 : te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
1678 1316 : result = lappend(result, te);
1679 :
1680 1316 : return result;
1681 : }
1682 :
1683 :
1684 : /*
1685 : * count_rowexpr_columns -
1686 : * get number of columns contained in a ROW() expression;
1687 : * return -1 if expression isn't a RowExpr or a Var referencing one.
1688 : *
1689 : * This is currently used only for hint purposes, so we aren't terribly
1690 : * tense about recognizing all possible cases. The Var case is interesting
1691 : * because that's what we'll get in the INSERT ... SELECT (...) case.
1692 : */
1693 : static int
1694 0 : count_rowexpr_columns(ParseState *pstate, Node *expr)
1695 : {
1696 0 : if (expr == NULL)
1697 0 : return -1;
1698 0 : if (IsA(expr, RowExpr))
1699 0 : return list_length(((RowExpr *) expr)->args);
1700 0 : if (IsA(expr, Var))
1701 : {
1702 0 : Var *var = (Var *) expr;
1703 0 : AttrNumber attnum = var->varattno;
1704 :
1705 0 : if (attnum > 0 && var->vartype == RECORDOID)
1706 : {
1707 : RangeTblEntry *rte;
1708 :
1709 0 : rte = GetRTEByRangeTablePosn(pstate, var->varno, var->varlevelsup);
1710 0 : if (rte->rtekind == RTE_SUBQUERY)
1711 : {
1712 : /* Subselect-in-FROM: examine sub-select's output expr */
1713 0 : TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
1714 : attnum);
1715 :
1716 0 : if (ste == NULL || ste->resjunk)
1717 0 : return -1;
1718 0 : expr = (Node *) ste->expr;
1719 0 : if (IsA(expr, RowExpr))
1720 0 : return list_length(((RowExpr *) expr)->args);
1721 : }
1722 : }
1723 : }
1724 0 : return -1;
1725 : }
1726 :
1727 :
1728 : /*
1729 : * transformSelectStmt -
1730 : * transforms a Select Statement
1731 : *
1732 : * This function is also used to transform the source expression of a
1733 : * PLAssignStmt. In that usage, passthru is non-NULL and we need to
1734 : * call transformPLAssignStmtTarget after the initial transformation of the
1735 : * SELECT's targetlist. (We could generalize this into an arbitrary callback
1736 : * function, but for now that would just be more notation with no benefit.)
1737 : * All the rest is the same as a regular SelectStmt.
1738 : *
1739 : * Note: this covers only cases with no set operations and no VALUES lists;
1740 : * see below for the other cases.
1741 : */
1742 : static Query *
1743 303111 : transformSelectStmt(ParseState *pstate, SelectStmt *stmt,
1744 : SelectStmtPassthrough *passthru)
1745 : {
1746 303111 : Query *qry = makeNode(Query);
1747 : Node *qual;
1748 : ListCell *l;
1749 :
1750 303111 : qry->commandType = CMD_SELECT;
1751 :
1752 : /* process the WITH clause independently of all else */
1753 303111 : if (stmt->withClause)
1754 : {
1755 1650 : qry->hasRecursive = stmt->withClause->recursive;
1756 1650 : qry->cteList = transformWithClause(pstate, stmt->withClause);
1757 1453 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1758 : }
1759 :
1760 : /* Complain if we get called from someplace where INTO is not allowed */
1761 302914 : if (stmt->intoClause)
1762 12 : ereport(ERROR,
1763 : (errcode(ERRCODE_SYNTAX_ERROR),
1764 : errmsg("SELECT ... INTO is not allowed here"),
1765 : parser_errposition(pstate,
1766 : exprLocation((Node *) stmt->intoClause))));
1767 :
1768 : /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
1769 302902 : pstate->p_locking_clause = stmt->lockingClause;
1770 :
1771 : /* make WINDOW info available for window functions, too */
1772 302902 : pstate->p_windowdefs = stmt->windowClause;
1773 :
1774 : /* process the FROM clause */
1775 302902 : transformFromClause(pstate, stmt->fromClause);
1776 :
1777 : /* transform targetlist */
1778 302409 : qry->targetList = transformTargetList(pstate, stmt->targetList,
1779 : EXPR_KIND_SELECT_TARGET);
1780 :
1781 : /*
1782 : * If we're within a PLAssignStmt, do further transformation of the
1783 : * targetlist; that has to happen before we consider sorting or grouping.
1784 : * Otherwise, mark column origins (which are useless in a PLAssignStmt).
1785 : */
1786 298737 : if (passthru)
1787 3446 : qry->targetList = transformPLAssignStmtTarget(pstate, qry->targetList,
1788 : passthru);
1789 : else
1790 295291 : markTargetListOrigins(pstate, qry->targetList);
1791 :
1792 : /* transform WHERE */
1793 298730 : qual = transformWhereClause(pstate, stmt->whereClause,
1794 : EXPR_KIND_WHERE, "WHERE");
1795 :
1796 : /* initial processing of HAVING clause is much like WHERE clause */
1797 298659 : qry->havingQual = transformWhereClause(pstate, stmt->havingClause,
1798 : EXPR_KIND_HAVING, "HAVING");
1799 :
1800 : /*
1801 : * Transform sorting/grouping stuff. Do ORDER BY first because both
1802 : * transformGroupClause and transformDistinctClause need the results. Note
1803 : * that these functions can also change the targetList, so it's passed to
1804 : * them by reference.
1805 : */
1806 298655 : qry->sortClause = transformSortClause(pstate,
1807 : stmt->sortClause,
1808 : &qry->targetList,
1809 : EXPR_KIND_ORDER_BY,
1810 : false /* allow SQL92 rules */ );
1811 :
1812 597254 : qry->groupClause = transformGroupClause(pstate,
1813 : stmt->groupClause,
1814 298635 : stmt->groupByAll,
1815 : &qry->groupingSets,
1816 : &qry->targetList,
1817 : qry->sortClause,
1818 : EXPR_KIND_GROUP_BY,
1819 : false /* allow SQL92 rules */ );
1820 298619 : qry->groupDistinct = stmt->groupDistinct;
1821 298619 : qry->groupByAll = stmt->groupByAll;
1822 :
1823 298619 : if (stmt->distinctClause == NIL)
1824 : {
1825 296175 : qry->distinctClause = NIL;
1826 296175 : qry->hasDistinctOn = false;
1827 : }
1828 2444 : else if (linitial(stmt->distinctClause) == NULL)
1829 : {
1830 : /* We had SELECT DISTINCT */
1831 2277 : qry->distinctClause = transformDistinctClause(pstate,
1832 : &qry->targetList,
1833 : qry->sortClause,
1834 : false);
1835 2277 : qry->hasDistinctOn = false;
1836 : }
1837 : else
1838 : {
1839 : /* We had SELECT DISTINCT ON */
1840 167 : qry->distinctClause = transformDistinctOnClause(pstate,
1841 : stmt->distinctClause,
1842 : &qry->targetList,
1843 : qry->sortClause);
1844 159 : qry->hasDistinctOn = true;
1845 : }
1846 :
1847 : /* transform LIMIT */
1848 298611 : qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
1849 : EXPR_KIND_OFFSET, "OFFSET",
1850 : stmt->limitOption);
1851 298611 : qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
1852 : EXPR_KIND_LIMIT, "LIMIT",
1853 : stmt->limitOption);
1854 298603 : qry->limitOption = stmt->limitOption;
1855 :
1856 : /* transform window clauses after we have seen all window functions */
1857 298603 : qry->windowClause = transformWindowDefinitions(pstate,
1858 : pstate->p_windowdefs,
1859 : &qry->targetList);
1860 :
1861 : /* resolve any still-unresolved output columns as being type text */
1862 298547 : if (pstate->p_resolve_unknowns)
1863 271619 : resolveTargetListUnknowns(pstate, qry->targetList);
1864 :
1865 298547 : qry->rtable = pstate->p_rtable;
1866 298547 : qry->rteperminfos = pstate->p_rteperminfos;
1867 298547 : qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
1868 :
1869 298547 : qry->hasSubLinks = pstate->p_hasSubLinks;
1870 298547 : qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
1871 298547 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
1872 298547 : qry->hasAggs = pstate->p_hasAggs;
1873 :
1874 303533 : foreach(l, stmt->lockingClause)
1875 : {
1876 5014 : transformLockingClause(pstate, qry,
1877 5014 : (LockingClause *) lfirst(l), false);
1878 : }
1879 :
1880 298519 : assign_query_collations(pstate, qry);
1881 :
1882 : /* this must be done after collations, for reliable comparison of exprs */
1883 298491 : if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
1884 27590 : parseCheckAggregates(pstate, qry);
1885 :
1886 298415 : return qry;
1887 : }
1888 :
1889 : /*
1890 : * transformValuesClause -
1891 : * transforms a VALUES clause that's being used as a standalone SELECT
1892 : *
1893 : * We build a Query containing a VALUES RTE, rather as if one had written
1894 : * SELECT * FROM (VALUES ...) AS "*VALUES*"
1895 : */
1896 : static Query *
1897 5806 : transformValuesClause(ParseState *pstate, SelectStmt *stmt)
1898 : {
1899 5806 : Query *qry = makeNode(Query);
1900 5806 : List *exprsLists = NIL;
1901 5806 : List *coltypes = NIL;
1902 5806 : List *coltypmods = NIL;
1903 5806 : List *colcollations = NIL;
1904 5806 : List **colexprs = NULL;
1905 5806 : int sublist_length = -1;
1906 5806 : bool lateral = false;
1907 : ParseNamespaceItem *nsitem;
1908 : ListCell *lc;
1909 : ListCell *lc2;
1910 : int i;
1911 :
1912 5806 : qry->commandType = CMD_SELECT;
1913 :
1914 : /* Most SELECT stuff doesn't apply in a VALUES clause */
1915 : Assert(stmt->distinctClause == NIL);
1916 : Assert(stmt->intoClause == NULL);
1917 : Assert(stmt->targetList == NIL);
1918 : Assert(stmt->fromClause == NIL);
1919 : Assert(stmt->whereClause == NULL);
1920 : Assert(stmt->groupClause == NIL);
1921 : Assert(stmt->havingClause == NULL);
1922 : Assert(stmt->windowClause == NIL);
1923 : Assert(stmt->op == SETOP_NONE);
1924 :
1925 : /* process the WITH clause independently of all else */
1926 5806 : if (stmt->withClause)
1927 : {
1928 40 : qry->hasRecursive = stmt->withClause->recursive;
1929 40 : qry->cteList = transformWithClause(pstate, stmt->withClause);
1930 36 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
1931 : }
1932 :
1933 : /*
1934 : * For each row of VALUES, transform the raw expressions.
1935 : *
1936 : * Note that the intermediate representation we build is column-organized
1937 : * not row-organized. That simplifies the type and collation processing
1938 : * below.
1939 : */
1940 21586 : foreach(lc, stmt->valuesLists)
1941 : {
1942 15789 : List *sublist = (List *) lfirst(lc);
1943 :
1944 : /*
1945 : * Do basic expression transformation (same as a ROW() expr, but here
1946 : * we disallow SetToDefault)
1947 : */
1948 15789 : sublist = transformExpressionList(pstate, sublist,
1949 : EXPR_KIND_VALUES, false);
1950 :
1951 : /*
1952 : * All the sublists must be the same length, *after* transformation
1953 : * (which might expand '*' into multiple items). The VALUES RTE can't
1954 : * handle anything different.
1955 : */
1956 15784 : if (sublist_length < 0)
1957 : {
1958 : /* Remember post-transformation length of first sublist */
1959 5797 : sublist_length = list_length(sublist);
1960 : /* and allocate array for per-column lists */
1961 5797 : colexprs = (List **) palloc0(sublist_length * sizeof(List *));
1962 : }
1963 9987 : else if (sublist_length != list_length(sublist))
1964 : {
1965 0 : ereport(ERROR,
1966 : (errcode(ERRCODE_SYNTAX_ERROR),
1967 : errmsg("VALUES lists must all be the same length"),
1968 : parser_errposition(pstate,
1969 : exprLocation((Node *) sublist))));
1970 : }
1971 :
1972 : /* Build per-column expression lists */
1973 15784 : i = 0;
1974 37670 : foreach(lc2, sublist)
1975 : {
1976 21886 : Node *col = (Node *) lfirst(lc2);
1977 :
1978 21886 : colexprs[i] = lappend(colexprs[i], col);
1979 21886 : i++;
1980 : }
1981 :
1982 : /* Release sub-list's cells to save memory */
1983 15784 : list_free(sublist);
1984 :
1985 : /* Prepare an exprsLists element for this row */
1986 15784 : exprsLists = lappend(exprsLists, NIL);
1987 : }
1988 :
1989 : /*
1990 : * Now resolve the common types of the columns, and coerce everything to
1991 : * those types. Then identify the common typmod and common collation, if
1992 : * any, of each column.
1993 : *
1994 : * We must do collation processing now because (1) assign_query_collations
1995 : * doesn't process rangetable entries, and (2) we need to label the VALUES
1996 : * RTE with column collations for use in the outer query. We don't
1997 : * consider conflict of implicit collations to be an error here; instead
1998 : * the column will just show InvalidOid as its collation, and you'll get a
1999 : * failure later if that results in failure to resolve a collation.
2000 : *
2001 : * Note we modify the per-column expression lists in-place.
2002 : */
2003 13353 : for (i = 0; i < sublist_length; i++)
2004 : {
2005 : Oid coltype;
2006 : int32 coltypmod;
2007 : Oid colcoll;
2008 :
2009 7556 : coltype = select_common_type(pstate, colexprs[i], "VALUES", NULL);
2010 :
2011 29442 : foreach(lc, colexprs[i])
2012 : {
2013 21886 : Node *col = (Node *) lfirst(lc);
2014 :
2015 21886 : col = coerce_to_common_type(pstate, col, coltype, "VALUES");
2016 21886 : lfirst(lc) = col;
2017 : }
2018 :
2019 7556 : coltypmod = select_common_typmod(pstate, colexprs[i], coltype);
2020 7556 : colcoll = select_common_collation(pstate, colexprs[i], true);
2021 :
2022 7556 : coltypes = lappend_oid(coltypes, coltype);
2023 7556 : coltypmods = lappend_int(coltypmods, coltypmod);
2024 7556 : colcollations = lappend_oid(colcollations, colcoll);
2025 : }
2026 :
2027 : /*
2028 : * Finally, rearrange the coerced expressions into row-organized lists.
2029 : */
2030 13353 : for (i = 0; i < sublist_length; i++)
2031 : {
2032 29442 : forboth(lc, colexprs[i], lc2, exprsLists)
2033 : {
2034 21886 : Node *col = (Node *) lfirst(lc);
2035 21886 : List *sublist = lfirst(lc2);
2036 :
2037 21886 : sublist = lappend(sublist, col);
2038 21886 : lfirst(lc2) = sublist;
2039 : }
2040 7556 : list_free(colexprs[i]);
2041 : }
2042 :
2043 : /*
2044 : * Ordinarily there can't be any current-level Vars in the expression
2045 : * lists, because the namespace was empty ... but if we're inside CREATE
2046 : * RULE, then NEW/OLD references might appear. In that case we have to
2047 : * mark the VALUES RTE as LATERAL.
2048 : */
2049 5802 : if (pstate->p_rtable != NIL &&
2050 5 : contain_vars_of_level((Node *) exprsLists, 0))
2051 5 : lateral = true;
2052 :
2053 : /*
2054 : * Generate the VALUES RTE
2055 : */
2056 5797 : nsitem = addRangeTableEntryForValues(pstate, exprsLists,
2057 : coltypes, coltypmods, colcollations,
2058 : NULL, lateral, true);
2059 5797 : addNSItemToQuery(pstate, nsitem, true, true, true);
2060 :
2061 : /*
2062 : * Generate a targetlist as though expanding "*"
2063 : */
2064 : Assert(pstate->p_next_resno == 1);
2065 5797 : qry->targetList = expandNSItemAttrs(pstate, nsitem, 0, true, -1);
2066 :
2067 : /*
2068 : * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
2069 : * VALUES, so cope.
2070 : */
2071 5797 : qry->sortClause = transformSortClause(pstate,
2072 : stmt->sortClause,
2073 : &qry->targetList,
2074 : EXPR_KIND_ORDER_BY,
2075 : false /* allow SQL92 rules */ );
2076 :
2077 5797 : qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
2078 : EXPR_KIND_OFFSET, "OFFSET",
2079 : stmt->limitOption);
2080 5797 : qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
2081 : EXPR_KIND_LIMIT, "LIMIT",
2082 : stmt->limitOption);
2083 5797 : qry->limitOption = stmt->limitOption;
2084 :
2085 5797 : if (stmt->lockingClause)
2086 0 : ereport(ERROR,
2087 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2088 : /*------
2089 : translator: %s is a SQL row locking clause such as FOR UPDATE */
2090 : errmsg("%s cannot be applied to VALUES",
2091 : LCS_asString(((LockingClause *)
2092 : linitial(stmt->lockingClause))->strength))));
2093 :
2094 5797 : qry->rtable = pstate->p_rtable;
2095 5797 : qry->rteperminfos = pstate->p_rteperminfos;
2096 5797 : qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
2097 :
2098 5797 : qry->hasSubLinks = pstate->p_hasSubLinks;
2099 :
2100 5797 : assign_query_collations(pstate, qry);
2101 :
2102 5797 : return qry;
2103 : }
2104 :
2105 : /*
2106 : * transformSetOperationStmt -
2107 : * transforms a set-operations tree
2108 : *
2109 : * A set-operation tree is just a SELECT, but with UNION/INTERSECT/EXCEPT
2110 : * structure to it. We must transform each leaf SELECT and build up a top-
2111 : * level Query that contains the leaf SELECTs as subqueries in its rangetable.
2112 : * The tree of set operations is converted into the setOperations field of
2113 : * the top-level Query.
2114 : */
2115 : static Query *
2116 8457 : transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
2117 : {
2118 8457 : Query *qry = makeNode(Query);
2119 : SelectStmt *leftmostSelect;
2120 : int leftmostRTI;
2121 : Query *leftmostQuery;
2122 : SetOperationStmt *sostmt;
2123 : List *sortClause;
2124 : Node *limitOffset;
2125 : Node *limitCount;
2126 : List *lockingClause;
2127 : WithClause *withClause;
2128 : Node *node;
2129 : ListCell *left_tlist,
2130 : *lct,
2131 : *lcm,
2132 : *lcc,
2133 : *l;
2134 : List *targetvars,
2135 : *targetnames,
2136 : *sv_namespace;
2137 : int sv_rtable_length;
2138 : ParseNamespaceItem *jnsitem;
2139 : ParseNamespaceColumn *sortnscolumns;
2140 : int sortcolindex;
2141 : int tllen;
2142 :
2143 8457 : qry->commandType = CMD_SELECT;
2144 :
2145 : /*
2146 : * Find leftmost leaf SelectStmt. We currently only need to do this in
2147 : * order to deliver a suitable error message if there's an INTO clause
2148 : * there, implying the set-op tree is in a context that doesn't allow
2149 : * INTO. (transformSetOperationTree would throw error anyway, but it
2150 : * seems worth the trouble to throw a different error for non-leftmost
2151 : * INTO, so we produce that error in transformSetOperationTree.)
2152 : */
2153 8457 : leftmostSelect = stmt->larg;
2154 12745 : while (leftmostSelect && leftmostSelect->op != SETOP_NONE)
2155 4288 : leftmostSelect = leftmostSelect->larg;
2156 : Assert(leftmostSelect && IsA(leftmostSelect, SelectStmt) &&
2157 : leftmostSelect->larg == NULL);
2158 8457 : if (leftmostSelect->intoClause)
2159 0 : ereport(ERROR,
2160 : (errcode(ERRCODE_SYNTAX_ERROR),
2161 : errmsg("SELECT ... INTO is not allowed here"),
2162 : parser_errposition(pstate,
2163 : exprLocation((Node *) leftmostSelect->intoClause))));
2164 :
2165 : /*
2166 : * We need to extract ORDER BY and other top-level clauses here and not
2167 : * let transformSetOperationTree() see them --- else it'll just recurse
2168 : * right back here!
2169 : */
2170 8457 : sortClause = stmt->sortClause;
2171 8457 : limitOffset = stmt->limitOffset;
2172 8457 : limitCount = stmt->limitCount;
2173 8457 : lockingClause = stmt->lockingClause;
2174 8457 : withClause = stmt->withClause;
2175 :
2176 8457 : stmt->sortClause = NIL;
2177 8457 : stmt->limitOffset = NULL;
2178 8457 : stmt->limitCount = NULL;
2179 8457 : stmt->lockingClause = NIL;
2180 8457 : stmt->withClause = NULL;
2181 :
2182 : /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
2183 8457 : if (lockingClause)
2184 4 : ereport(ERROR,
2185 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2186 : /*------
2187 : translator: %s is a SQL row locking clause such as FOR UPDATE */
2188 : errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
2189 : LCS_asString(((LockingClause *)
2190 : linitial(lockingClause))->strength))));
2191 :
2192 : /* Process the WITH clause independently of all else */
2193 8453 : if (withClause)
2194 : {
2195 170 : qry->hasRecursive = withClause->recursive;
2196 170 : qry->cteList = transformWithClause(pstate, withClause);
2197 170 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
2198 : }
2199 :
2200 : /*
2201 : * Recursively transform the components of the tree.
2202 : */
2203 8453 : sostmt = castNode(SetOperationStmt,
2204 : transformSetOperationTree(pstate, stmt, true, NULL));
2205 : Assert(sostmt);
2206 8405 : qry->setOperations = (Node *) sostmt;
2207 :
2208 : /*
2209 : * Re-find leftmost SELECT (now it's a sub-query in rangetable)
2210 : */
2211 8405 : node = sostmt->larg;
2212 12681 : while (node && IsA(node, SetOperationStmt))
2213 4276 : node = ((SetOperationStmt *) node)->larg;
2214 : Assert(node && IsA(node, RangeTblRef));
2215 8405 : leftmostRTI = ((RangeTblRef *) node)->rtindex;
2216 8405 : leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
2217 : Assert(leftmostQuery != NULL);
2218 :
2219 : /*
2220 : * Generate dummy targetlist for outer query using column names of
2221 : * leftmost select and common datatypes/collations of topmost set
2222 : * operation. Also make lists of the dummy vars and their names for use
2223 : * in parsing ORDER BY.
2224 : *
2225 : * Note: we use leftmostRTI as the varno of the dummy variables. It
2226 : * shouldn't matter too much which RT index they have, as long as they
2227 : * have one that corresponds to a real RT entry; else funny things may
2228 : * happen when the tree is mashed by rule rewriting.
2229 : */
2230 8405 : qry->targetList = NIL;
2231 8405 : targetvars = NIL;
2232 8405 : targetnames = NIL;
2233 : sortnscolumns = (ParseNamespaceColumn *)
2234 8405 : palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn));
2235 8405 : sortcolindex = 0;
2236 :
2237 28794 : forfour(lct, sostmt->colTypes,
2238 : lcm, sostmt->colTypmods,
2239 : lcc, sostmt->colCollations,
2240 : left_tlist, leftmostQuery->targetList)
2241 : {
2242 20389 : Oid colType = lfirst_oid(lct);
2243 20389 : int32 colTypmod = lfirst_int(lcm);
2244 20389 : Oid colCollation = lfirst_oid(lcc);
2245 20389 : TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
2246 : char *colName;
2247 : TargetEntry *tle;
2248 : Var *var;
2249 :
2250 : Assert(!lefttle->resjunk);
2251 20389 : colName = pstrdup(lefttle->resname);
2252 20389 : var = makeVar(leftmostRTI,
2253 20389 : lefttle->resno,
2254 : colType,
2255 : colTypmod,
2256 : colCollation,
2257 : 0);
2258 20389 : var->location = exprLocation((Node *) lefttle->expr);
2259 20389 : tle = makeTargetEntry((Expr *) var,
2260 20389 : (AttrNumber) pstate->p_next_resno++,
2261 : colName,
2262 : false);
2263 20389 : qry->targetList = lappend(qry->targetList, tle);
2264 20389 : targetvars = lappend(targetvars, var);
2265 20389 : targetnames = lappend(targetnames, makeString(colName));
2266 20389 : sortnscolumns[sortcolindex].p_varno = leftmostRTI;
2267 20389 : sortnscolumns[sortcolindex].p_varattno = lefttle->resno;
2268 20389 : sortnscolumns[sortcolindex].p_vartype = colType;
2269 20389 : sortnscolumns[sortcolindex].p_vartypmod = colTypmod;
2270 20389 : sortnscolumns[sortcolindex].p_varcollid = colCollation;
2271 20389 : sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI;
2272 20389 : sortnscolumns[sortcolindex].p_varattnosyn = lefttle->resno;
2273 20389 : sortcolindex++;
2274 : }
2275 :
2276 : /*
2277 : * As a first step towards supporting sort clauses that are expressions
2278 : * using the output columns, generate a namespace entry that makes the
2279 : * output columns visible. A Join RTE node is handy for this, since we
2280 : * can easily control the Vars generated upon matches.
2281 : *
2282 : * Note: we don't yet do anything useful with such cases, but at least
2283 : * "ORDER BY upper(foo)" will draw the right error message rather than
2284 : * "foo not found".
2285 : */
2286 8405 : sv_rtable_length = list_length(pstate->p_rtable);
2287 :
2288 8405 : jnsitem = addRangeTableEntryForJoin(pstate,
2289 : targetnames,
2290 : sortnscolumns,
2291 : JOIN_INNER,
2292 : 0,
2293 : targetvars,
2294 : NIL,
2295 : NIL,
2296 : NULL,
2297 : NULL,
2298 : false);
2299 :
2300 8405 : sv_namespace = pstate->p_namespace;
2301 8405 : pstate->p_namespace = NIL;
2302 :
2303 : /* add jnsitem to column namespace only */
2304 8405 : addNSItemToQuery(pstate, jnsitem, false, false, true);
2305 :
2306 : /*
2307 : * For now, we don't support resjunk sort clauses on the output of a
2308 : * setOperation tree --- you can only use the SQL92-spec options of
2309 : * selecting an output column by name or number. Enforce by checking that
2310 : * transformSortClause doesn't add any items to tlist. Note, if changing
2311 : * this, add_setop_child_rel_equivalences() will need to be updated.
2312 : */
2313 8405 : tllen = list_length(qry->targetList);
2314 :
2315 8405 : qry->sortClause = transformSortClause(pstate,
2316 : sortClause,
2317 : &qry->targetList,
2318 : EXPR_KIND_ORDER_BY,
2319 : false /* allow SQL92 rules */ );
2320 :
2321 : /* restore namespace, remove join RTE from rtable */
2322 8401 : pstate->p_namespace = sv_namespace;
2323 8401 : pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length);
2324 :
2325 8401 : if (tllen != list_length(qry->targetList))
2326 0 : ereport(ERROR,
2327 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2328 : errmsg("invalid UNION/INTERSECT/EXCEPT ORDER BY clause"),
2329 : errdetail("Only result column names can be used, not expressions or functions."),
2330 : errhint("Add the expression/function to every SELECT, or move the UNION into a FROM clause."),
2331 : parser_errposition(pstate,
2332 : exprLocation(list_nth(qry->targetList, tllen)))));
2333 :
2334 8401 : qry->limitOffset = transformLimitClause(pstate, limitOffset,
2335 : EXPR_KIND_OFFSET, "OFFSET",
2336 : stmt->limitOption);
2337 8401 : qry->limitCount = transformLimitClause(pstate, limitCount,
2338 : EXPR_KIND_LIMIT, "LIMIT",
2339 : stmt->limitOption);
2340 8401 : qry->limitOption = stmt->limitOption;
2341 :
2342 8401 : qry->rtable = pstate->p_rtable;
2343 8401 : qry->rteperminfos = pstate->p_rteperminfos;
2344 8401 : qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
2345 :
2346 8401 : qry->hasSubLinks = pstate->p_hasSubLinks;
2347 8401 : qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2348 8401 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2349 8401 : qry->hasAggs = pstate->p_hasAggs;
2350 :
2351 8401 : foreach(l, lockingClause)
2352 : {
2353 0 : transformLockingClause(pstate, qry,
2354 0 : (LockingClause *) lfirst(l), false);
2355 : }
2356 :
2357 8401 : assign_query_collations(pstate, qry);
2358 :
2359 : /* this must be done after collations, for reliable comparison of exprs */
2360 8401 : if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
2361 0 : parseCheckAggregates(pstate, qry);
2362 :
2363 8401 : return qry;
2364 : }
2365 :
2366 : /*
2367 : * Make a SortGroupClause node for a SetOperationStmt's groupClauses
2368 : *
2369 : * If require_hash is true, the caller is indicating that they need hash
2370 : * support or they will fail. So look extra hard for hash support.
2371 : */
2372 : SortGroupClause *
2373 17366 : makeSortGroupClauseForSetOp(Oid rescoltype, bool require_hash)
2374 : {
2375 17366 : SortGroupClause *grpcl = makeNode(SortGroupClause);
2376 : Oid sortop;
2377 : Oid eqop;
2378 : bool hashable;
2379 :
2380 : /* determine the eqop and optional sortop */
2381 17366 : get_sort_group_operators(rescoltype,
2382 : false, true, false,
2383 : &sortop, &eqop, NULL,
2384 : &hashable);
2385 :
2386 : /*
2387 : * The type cache doesn't believe that record is hashable (see
2388 : * cache_record_field_properties()), but if the caller really needs hash
2389 : * support, we can assume it does. Worst case, if any components of the
2390 : * record don't support hashing, we will fail at execution.
2391 : */
2392 17366 : if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
2393 16 : hashable = true;
2394 :
2395 : /* we don't have a tlist yet, so can't assign sortgrouprefs */
2396 17366 : grpcl->tleSortGroupRef = 0;
2397 17366 : grpcl->eqop = eqop;
2398 17366 : grpcl->sortop = sortop;
2399 17366 : grpcl->reverse_sort = false; /* Sort-op is "less than", or InvalidOid */
2400 17366 : grpcl->nulls_first = false; /* OK with or without sortop */
2401 17366 : grpcl->hashable = hashable;
2402 :
2403 17366 : return grpcl;
2404 : }
2405 :
2406 : /*
2407 : * transformSetOperationTree
2408 : * Recursively transform leaves and internal nodes of a set-op tree
2409 : *
2410 : * In addition to returning the transformed node, if targetlist isn't NULL
2411 : * then we return a list of its non-resjunk TargetEntry nodes. For a leaf
2412 : * set-op node these are the actual targetlist entries; otherwise they are
2413 : * dummy entries created to carry the type, typmod, collation, and location
2414 : * (for error messages) of each output column of the set-op node. This info
2415 : * is needed only during the internal recursion of this function, so outside
2416 : * callers pass NULL for targetlist. Note: the reason for passing the
2417 : * actual targetlist entries of a leaf node is so that upper levels can
2418 : * replace UNKNOWN Consts with properly-coerced constants.
2419 : */
2420 : static Node *
2421 34011 : transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
2422 : bool isTopLevel, List **targetlist)
2423 : {
2424 : bool isLeaf;
2425 :
2426 : Assert(stmt && IsA(stmt, SelectStmt));
2427 :
2428 : /* Guard against stack overflow due to overly complex set-expressions */
2429 34011 : check_stack_depth();
2430 :
2431 : /*
2432 : * Validity-check both leaf and internal SELECTs for disallowed ops.
2433 : */
2434 34011 : if (stmt->intoClause)
2435 0 : ereport(ERROR,
2436 : (errcode(ERRCODE_SYNTAX_ERROR),
2437 : errmsg("INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"),
2438 : parser_errposition(pstate,
2439 : exprLocation((Node *) stmt->intoClause))));
2440 :
2441 : /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
2442 34011 : if (stmt->lockingClause)
2443 0 : ereport(ERROR,
2444 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2445 : /*------
2446 : translator: %s is a SQL row locking clause such as FOR UPDATE */
2447 : errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
2448 : LCS_asString(((LockingClause *)
2449 : linitial(stmt->lockingClause))->strength))));
2450 :
2451 : /*
2452 : * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
2453 : * or WITH clauses attached, we need to treat it like a leaf node to
2454 : * generate an independent sub-Query tree. Otherwise, it can be
2455 : * represented by a SetOperationStmt node underneath the parent Query.
2456 : */
2457 34011 : if (stmt->op == SETOP_NONE)
2458 : {
2459 : Assert(stmt->larg == NULL && stmt->rarg == NULL);
2460 21190 : isLeaf = true;
2461 : }
2462 : else
2463 : {
2464 : Assert(stmt->larg != NULL && stmt->rarg != NULL);
2465 12821 : if (stmt->sortClause || stmt->limitOffset || stmt->limitCount ||
2466 12805 : stmt->lockingClause || stmt->withClause)
2467 40 : isLeaf = true;
2468 : else
2469 12781 : isLeaf = false;
2470 : }
2471 :
2472 34011 : if (isLeaf)
2473 : {
2474 : /* Process leaf SELECT */
2475 : Query *selectQuery;
2476 : ParseNamespaceItem *nsitem;
2477 : RangeTblRef *rtr;
2478 :
2479 : /*
2480 : * Transform SelectStmt into a Query.
2481 : *
2482 : * This works the same as SELECT transformation normally would, except
2483 : * that we prevent resolving unknown-type outputs as TEXT. This does
2484 : * not change the subquery's semantics since if the column type
2485 : * matters semantically, it would have been resolved to something else
2486 : * anyway. Doing this lets us resolve such outputs using
2487 : * select_common_type(), below.
2488 : *
2489 : * Note: previously transformed sub-queries don't affect the parsing
2490 : * of this sub-query, because they are not in the toplevel pstate's
2491 : * namespace list.
2492 : */
2493 21230 : selectQuery = parse_sub_analyze((Node *) stmt, pstate,
2494 : NULL, false, false);
2495 :
2496 : /*
2497 : * Check for bogus references to Vars on the current query level (but
2498 : * upper-level references are okay). Normally this can't happen
2499 : * because the namespace will be empty, but it could happen if we are
2500 : * inside a rule.
2501 : */
2502 21210 : if (pstate->p_namespace)
2503 : {
2504 0 : if (contain_vars_of_level((Node *) selectQuery, 1))
2505 0 : ereport(ERROR,
2506 : (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2507 : errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2508 : parser_errposition(pstate,
2509 : locate_var_of_level((Node *) selectQuery, 1))));
2510 : }
2511 :
2512 : /*
2513 : * Extract a list of the non-junk TLEs for upper-level processing.
2514 : */
2515 21210 : if (targetlist)
2516 : {
2517 : ListCell *tl;
2518 :
2519 21210 : *targetlist = NIL;
2520 80704 : foreach(tl, selectQuery->targetList)
2521 : {
2522 59494 : TargetEntry *tle = (TargetEntry *) lfirst(tl);
2523 :
2524 59494 : if (!tle->resjunk)
2525 59486 : *targetlist = lappend(*targetlist, tle);
2526 : }
2527 : }
2528 :
2529 : /*
2530 : * Make the leaf query be a subquery in the top-level rangetable.
2531 : */
2532 21210 : nsitem = addRangeTableEntryForSubquery(pstate,
2533 : selectQuery,
2534 : NULL,
2535 : false,
2536 : false);
2537 :
2538 : /*
2539 : * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
2540 : */
2541 21210 : rtr = makeNode(RangeTblRef);
2542 21210 : rtr->rtindex = nsitem->p_rtindex;
2543 21210 : return (Node *) rtr;
2544 : }
2545 : else
2546 : {
2547 : /* Process an internal node (set operation node) */
2548 12781 : SetOperationStmt *op = makeNode(SetOperationStmt);
2549 : List *ltargetlist;
2550 : List *rtargetlist;
2551 : const char *context;
2552 13515 : bool recursive = (pstate->p_parent_cte &&
2553 734 : pstate->p_parent_cte->cterecursive);
2554 :
2555 13277 : context = (stmt->op == SETOP_UNION ? "UNION" :
2556 496 : (stmt->op == SETOP_INTERSECT ? "INTERSECT" :
2557 : "EXCEPT"));
2558 :
2559 12781 : op->op = stmt->op;
2560 12781 : op->all = stmt->all;
2561 :
2562 : /*
2563 : * Recursively transform the left child node.
2564 : */
2565 12781 : op->larg = transformSetOperationTree(pstate, stmt->larg,
2566 : false,
2567 : <argetlist);
2568 :
2569 : /*
2570 : * If we are processing a recursive union query, now is the time to
2571 : * examine the non-recursive term's output columns and mark the
2572 : * containing CTE as having those result columns. We should do this
2573 : * only at the topmost setop of the CTE, of course.
2574 : */
2575 12777 : if (isTopLevel && recursive)
2576 638 : determineRecursiveColTypes(pstate, op->larg, ltargetlist);
2577 :
2578 : /*
2579 : * Recursively transform the right child node.
2580 : */
2581 12777 : op->rarg = transformSetOperationTree(pstate, stmt->rarg,
2582 : false,
2583 : &rtargetlist);
2584 :
2585 12761 : constructSetOpTargetlist(pstate, op, ltargetlist, rtargetlist, targetlist,
2586 : context, recursive);
2587 :
2588 12733 : return (Node *) op;
2589 : }
2590 : }
2591 :
2592 : /*
2593 : * constructSetOpTargetlist
2594 : * Compute the types, typmods and collations of the columns in the target
2595 : * list of the given set operation.
2596 : *
2597 : * For every pair of columns in the targetlists of the children, compute the
2598 : * common type, typmod, and collation representing the output (UNION) column.
2599 : * If targetlist is not NULL, also build the dummy output targetlist
2600 : * containing non-resjunk output columns. The values are stored into the
2601 : * given SetOperationStmt node. context is a string for error messages
2602 : * ("UNION" etc.). recursive is true if it is a recursive union.
2603 : */
2604 : void
2605 13143 : constructSetOpTargetlist(ParseState *pstate, SetOperationStmt *op,
2606 : const List *ltargetlist, const List *rtargetlist,
2607 : List **targetlist, const char *context, bool recursive)
2608 : {
2609 : ListCell *ltl;
2610 : ListCell *rtl;
2611 :
2612 : /*
2613 : * Verify that the two children have the same number of non-junk columns,
2614 : * and determine the types of the merged output columns.
2615 : */
2616 13143 : if (list_length(ltargetlist) != list_length(rtargetlist))
2617 0 : ereport(ERROR,
2618 : (errcode(ERRCODE_SYNTAX_ERROR),
2619 : errmsg("each %s query must have the same number of columns",
2620 : context),
2621 : parser_errposition(pstate,
2622 : exprLocation((const Node *) rtargetlist))));
2623 :
2624 13143 : if (targetlist)
2625 4578 : *targetlist = NIL;
2626 13143 : op->colTypes = NIL;
2627 13143 : op->colTypmods = NIL;
2628 13143 : op->colCollations = NIL;
2629 13143 : op->groupClauses = NIL;
2630 :
2631 53131 : forboth(ltl, ltargetlist, rtl, rtargetlist)
2632 : {
2633 40016 : TargetEntry *ltle = (TargetEntry *) lfirst(ltl);
2634 40016 : TargetEntry *rtle = (TargetEntry *) lfirst(rtl);
2635 40016 : Node *lcolnode = (Node *) ltle->expr;
2636 40016 : Node *rcolnode = (Node *) rtle->expr;
2637 40016 : Oid lcoltype = exprType(lcolnode);
2638 40016 : Oid rcoltype = exprType(rcolnode);
2639 : Node *bestexpr;
2640 : int bestlocation;
2641 : Oid rescoltype;
2642 : int32 rescoltypmod;
2643 : Oid rescolcoll;
2644 :
2645 : /* select common type, same as CASE et al */
2646 40016 : rescoltype = select_common_type(pstate,
2647 : list_make2(lcolnode, rcolnode),
2648 : context,
2649 : &bestexpr);
2650 40016 : bestlocation = exprLocation(bestexpr);
2651 :
2652 : /*
2653 : * Verify the coercions are actually possible. If not, we'd fail
2654 : * later anyway, but we want to fail now while we have sufficient
2655 : * context to produce an error cursor position.
2656 : *
2657 : * For all non-UNKNOWN-type cases, we verify coercibility but we don't
2658 : * modify the child's expression, for fear of changing the child
2659 : * query's semantics.
2660 : *
2661 : * If a child expression is an UNKNOWN-type Const or Param, we want to
2662 : * replace it with the coerced expression. This can only happen when
2663 : * the child is a leaf set-op node. It's safe to replace the
2664 : * expression because if the child query's semantics depended on the
2665 : * type of this output column, it'd have already coerced the UNKNOWN
2666 : * to something else. We want to do this because (a) we want to
2667 : * verify that a Const is valid for the target type, or resolve the
2668 : * actual type of an UNKNOWN Param, and (b) we want to avoid
2669 : * unnecessary discrepancies between the output type of the child
2670 : * query and the resolved target type. Such a discrepancy would
2671 : * disable optimization in the planner.
2672 : *
2673 : * If it's some other UNKNOWN-type node, eg a Var, we do nothing
2674 : * (knowing that coerce_to_common_type would fail). The planner is
2675 : * sometimes able to fold an UNKNOWN Var to a constant before it has
2676 : * to coerce the type, so failing now would just break cases that
2677 : * might work.
2678 : */
2679 40016 : if (lcoltype != UNKNOWNOID)
2680 35707 : lcolnode = coerce_to_common_type(pstate, lcolnode,
2681 : rescoltype, context);
2682 4309 : else if (IsA(lcolnode, Const) ||
2683 0 : IsA(lcolnode, Param))
2684 : {
2685 4309 : lcolnode = coerce_to_common_type(pstate, lcolnode,
2686 : rescoltype, context);
2687 4309 : ltle->expr = (Expr *) lcolnode;
2688 : }
2689 :
2690 40016 : if (rcoltype != UNKNOWNOID)
2691 35163 : rcolnode = coerce_to_common_type(pstate, rcolnode,
2692 : rescoltype, context);
2693 4853 : else if (IsA(rcolnode, Const) ||
2694 0 : IsA(rcolnode, Param))
2695 : {
2696 4853 : rcolnode = coerce_to_common_type(pstate, rcolnode,
2697 : rescoltype, context);
2698 4849 : rtle->expr = (Expr *) rcolnode;
2699 : }
2700 :
2701 40012 : rescoltypmod = select_common_typmod(pstate,
2702 : list_make2(lcolnode, rcolnode),
2703 : rescoltype);
2704 :
2705 : /*
2706 : * Select common collation. A common collation is required for all
2707 : * set operators except UNION ALL; see SQL:2008 7.13 <query
2708 : * expression> Syntax Rule 15c. (If we fail to identify a common
2709 : * collation for a UNION ALL column, the colCollations element will be
2710 : * set to InvalidOid, which may result in a runtime error if something
2711 : * at a higher query level wants to use the column's collation.)
2712 : */
2713 40012 : rescolcoll = select_common_collation(pstate,
2714 : list_make2(lcolnode, rcolnode),
2715 40012 : (op->op == SETOP_UNION && op->all));
2716 :
2717 : /* emit results */
2718 39988 : op->colTypes = lappend_oid(op->colTypes, rescoltype);
2719 39988 : op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
2720 39988 : op->colCollations = lappend_oid(op->colCollations, rescolcoll);
2721 :
2722 : /*
2723 : * For all cases except UNION ALL, identify the grouping operators
2724 : * (and, if available, sorting operators) that will be used to
2725 : * eliminate duplicates.
2726 : */
2727 39988 : if (op->op != SETOP_UNION || !op->all)
2728 : {
2729 : ParseCallbackState pcbstate;
2730 :
2731 17350 : setup_parser_errposition_callback(&pcbstate, pstate,
2732 : bestlocation);
2733 :
2734 : /* If it's a recursive union, we need to require hashing support. */
2735 17350 : op->groupClauses = lappend(op->groupClauses,
2736 17350 : makeSortGroupClauseForSetOp(rescoltype, recursive));
2737 :
2738 17350 : cancel_parser_errposition_callback(&pcbstate);
2739 : }
2740 :
2741 : /*
2742 : * Construct a dummy tlist entry to return. We use a SetToDefault
2743 : * node for the expression, since it carries exactly the fields
2744 : * needed, but any other expression node type would do as well.
2745 : */
2746 39988 : if (targetlist)
2747 : {
2748 19224 : SetToDefault *rescolnode = makeNode(SetToDefault);
2749 : TargetEntry *restle;
2750 :
2751 19224 : rescolnode->typeId = rescoltype;
2752 19224 : rescolnode->typeMod = rescoltypmod;
2753 19224 : rescolnode->collation = rescolcoll;
2754 19224 : rescolnode->location = bestlocation;
2755 19224 : restle = makeTargetEntry((Expr *) rescolnode,
2756 : 0, /* no need to set resno */
2757 : NULL,
2758 : false);
2759 19224 : *targetlist = lappend(*targetlist, restle);
2760 : }
2761 : }
2762 13115 : }
2763 :
2764 : /*
2765 : * Process the outputs of the non-recursive term of a recursive union
2766 : * to set up the parent CTE's columns
2767 : */
2768 : static void
2769 638 : determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist)
2770 : {
2771 : Node *node;
2772 : int leftmostRTI;
2773 : Query *leftmostQuery;
2774 : List *targetList;
2775 : ListCell *left_tlist;
2776 : ListCell *nrtl;
2777 : int next_resno;
2778 :
2779 : /*
2780 : * Find leftmost leaf SELECT
2781 : */
2782 638 : node = larg;
2783 642 : while (node && IsA(node, SetOperationStmt))
2784 4 : node = ((SetOperationStmt *) node)->larg;
2785 : Assert(node && IsA(node, RangeTblRef));
2786 638 : leftmostRTI = ((RangeTblRef *) node)->rtindex;
2787 638 : leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
2788 : Assert(leftmostQuery != NULL);
2789 :
2790 : /*
2791 : * Generate dummy targetlist using column names of leftmost select and
2792 : * dummy result expressions of the non-recursive term.
2793 : */
2794 638 : targetList = NIL;
2795 638 : next_resno = 1;
2796 :
2797 1974 : forboth(nrtl, nrtargetlist, left_tlist, leftmostQuery->targetList)
2798 : {
2799 1336 : TargetEntry *nrtle = (TargetEntry *) lfirst(nrtl);
2800 1336 : TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
2801 : char *colName;
2802 : TargetEntry *tle;
2803 :
2804 : Assert(!lefttle->resjunk);
2805 1336 : colName = pstrdup(lefttle->resname);
2806 1336 : tle = makeTargetEntry(nrtle->expr,
2807 1336 : next_resno++,
2808 : colName,
2809 : false);
2810 1336 : targetList = lappend(targetList, tle);
2811 : }
2812 :
2813 : /* Now build CTE's output column info using dummy targetlist */
2814 638 : analyzeCTETargetList(pstate, pstate->p_parent_cte, targetList);
2815 638 : }
2816 :
2817 :
2818 : /*
2819 : * transformReturnStmt -
2820 : * transforms a return statement
2821 : */
2822 : static Query *
2823 2776 : transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
2824 : {
2825 2776 : Query *qry = makeNode(Query);
2826 :
2827 2776 : qry->commandType = CMD_SELECT;
2828 2776 : qry->isReturn = true;
2829 :
2830 2776 : qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
2831 : 1, NULL, false));
2832 :
2833 2772 : if (pstate->p_resolve_unknowns)
2834 2772 : resolveTargetListUnknowns(pstate, qry->targetList);
2835 2772 : qry->rtable = pstate->p_rtable;
2836 2772 : qry->rteperminfos = pstate->p_rteperminfos;
2837 2772 : qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
2838 2772 : qry->hasSubLinks = pstate->p_hasSubLinks;
2839 2772 : qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
2840 2772 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2841 2772 : qry->hasAggs = pstate->p_hasAggs;
2842 :
2843 2772 : assign_query_collations(pstate, qry);
2844 :
2845 2772 : return qry;
2846 : }
2847 :
2848 :
2849 : /*
2850 : * transformUpdateStmt -
2851 : * transforms an update statement
2852 : */
2853 : static Query *
2854 9305 : transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
2855 : {
2856 9305 : Query *qry = makeNode(Query);
2857 : ParseNamespaceItem *nsitem;
2858 : Node *qual;
2859 :
2860 9305 : qry->commandType = CMD_UPDATE;
2861 :
2862 : /* process the WITH clause independently of all else */
2863 9305 : if (stmt->withClause)
2864 : {
2865 55 : qry->hasRecursive = stmt->withClause->recursive;
2866 55 : qry->cteList = transformWithClause(pstate, stmt->withClause);
2867 55 : qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
2868 : }
2869 :
2870 18609 : qry->resultRelation = setTargetTable(pstate, stmt->relation,
2871 9305 : stmt->relation->inh,
2872 : true,
2873 : ACL_UPDATE);
2874 :
2875 : /* disallow UPDATE ... WHERE CURRENT OF on a view */
2876 9304 : if (stmt->whereClause &&
2877 6988 : IsA(stmt->whereClause, CurrentOfExpr) &&
2878 108 : pstate->p_target_relation->rd_rel->relkind == RELKIND_VIEW)
2879 4 : ereport(ERROR,
2880 : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2881 : errmsg("WHERE CURRENT OF on a view is not implemented"));
2882 :
2883 9300 : if (stmt->forPortionOf)
2884 530 : qry->forPortionOf = transformForPortionOfClause(pstate,
2885 : qry->resultRelation,
2886 590 : stmt->forPortionOf,
2887 590 : stmt->whereClause,
2888 : true);
2889 :
2890 9240 : nsitem = pstate->p_target_nsitem;
2891 :
2892 : /* subqueries in FROM cannot access the result relation */
2893 9240 : nsitem->p_lateral_only = true;
2894 9240 : nsitem->p_lateral_ok = false;
2895 :
2896 : /*
2897 : * the FROM clause is non-standard SQL syntax. We used to be able to do
2898 : * this with REPLACE in POSTQUEL so we keep the feature.
2899 : */
2900 9240 : transformFromClause(pstate, stmt->fromClause);
2901 :
2902 : /* remaining clauses can reference the result relation normally */
2903 9224 : nsitem->p_lateral_only = false;
2904 9224 : nsitem->p_lateral_ok = true;
2905 :
2906 9224 : qual = transformWhereClause(pstate, stmt->whereClause,
2907 : EXPR_KIND_WHERE, "WHERE");
2908 :
2909 9216 : transformReturningClause(pstate, qry, stmt->returningClause,
2910 : EXPR_KIND_RETURNING);
2911 :
2912 : /*
2913 : * Now we are done with SELECT-like processing, and can get on with
2914 : * transforming the target list to match the UPDATE target columns.
2915 : */
2916 9204 : qry->targetList = transformUpdateTargetList(pstate, stmt->targetList,
2917 : qry->forPortionOf);
2918 :
2919 9168 : qry->rtable = pstate->p_rtable;
2920 9168 : qry->rteperminfos = pstate->p_rteperminfos;
2921 9168 : qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
2922 :
2923 9168 : qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
2924 9168 : qry->hasSubLinks = pstate->p_hasSubLinks;
2925 :
2926 9168 : assign_query_collations(pstate, qry);
2927 :
2928 9168 : return qry;
2929 : }
2930 :
2931 : /*
2932 : * transformUpdateTargetList -
2933 : * handle SET clause in UPDATE/MERGE/INSERT ... ON CONFLICT UPDATE
2934 : */
2935 : List *
2936 11106 : transformUpdateTargetList(ParseState *pstate, List *origTlist, ForPortionOfExpr *forPortionOf)
2937 : {
2938 11106 : List *tlist = NIL;
2939 : RTEPermissionInfo *target_perminfo;
2940 : ListCell *orig_tl;
2941 : ListCell *tl;
2942 :
2943 11106 : tlist = transformTargetList(pstate, origTlist,
2944 : EXPR_KIND_UPDATE_SOURCE);
2945 :
2946 : /* Prepare to assign non-conflicting resnos to resjunk attributes */
2947 11074 : if (pstate->p_next_resno <= RelationGetNumberOfAttributes(pstate->p_target_relation))
2948 9420 : pstate->p_next_resno = RelationGetNumberOfAttributes(pstate->p_target_relation) + 1;
2949 :
2950 : /* Prepare non-junk columns for assignment to target table */
2951 11074 : target_perminfo = pstate->p_target_nsitem->p_perminfo;
2952 11074 : orig_tl = list_head(origTlist);
2953 :
2954 24780 : foreach(tl, tlist)
2955 : {
2956 13734 : TargetEntry *tle = (TargetEntry *) lfirst(tl);
2957 : ResTarget *origTarget;
2958 : int attrno;
2959 :
2960 13734 : if (tle->resjunk)
2961 : {
2962 : /*
2963 : * Resjunk nodes need no additional processing, but be sure they
2964 : * have resnos that do not match any target columns; else rewriter
2965 : * or planner might get confused. They don't need a resname
2966 : * either.
2967 : */
2968 91 : tle->resno = (AttrNumber) pstate->p_next_resno++;
2969 91 : tle->resname = NULL;
2970 91 : continue;
2971 : }
2972 13643 : if (orig_tl == NULL)
2973 0 : elog(ERROR, "UPDATE target count mismatch --- internal error");
2974 13643 : origTarget = lfirst_node(ResTarget, orig_tl);
2975 :
2976 13643 : attrno = attnameAttNum(pstate->p_target_relation,
2977 13643 : origTarget->name, true);
2978 13643 : if (attrno == InvalidAttrNumber)
2979 16 : ereport(ERROR,
2980 : (errcode(ERRCODE_UNDEFINED_COLUMN),
2981 : errmsg("column \"%s\" of relation \"%s\" does not exist",
2982 : origTarget->name,
2983 : RelationGetRelationName(pstate->p_target_relation)),
2984 : (origTarget->indirection != NIL &&
2985 : strcmp(origTarget->name, pstate->p_target_nsitem->p_names->aliasname) == 0) ?
2986 : errhint("SET target columns cannot be qualified with the relation name.") : 0,
2987 : parser_errposition(pstate, origTarget->location)));
2988 :
2989 : /*
2990 : * If this is a FOR PORTION OF update, forbid directly setting the
2991 : * range column, since that would conflict with the implicit updates.
2992 : */
2993 13627 : if (forPortionOf != NULL)
2994 : {
2995 543 : if (attrno == forPortionOf->rangeVar->varattno)
2996 4 : ereport(ERROR,
2997 : (errcode(ERRCODE_SYNTAX_ERROR),
2998 : errmsg("cannot update column \"%s\" because it is used in FOR PORTION OF",
2999 : origTarget->name),
3000 : parser_errposition(pstate, origTarget->location)));
3001 : }
3002 :
3003 13623 : updateTargetListEntry(pstate, tle, origTarget->name,
3004 : attrno,
3005 : origTarget->indirection,
3006 : origTarget->location);
3007 :
3008 : /* Mark the target column as requiring update permissions */
3009 13615 : target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
3010 : attrno - FirstLowInvalidHeapAttributeNumber);
3011 :
3012 13615 : orig_tl = lnext(origTlist, orig_tl);
3013 : }
3014 11046 : if (orig_tl != NULL)
3015 0 : elog(ERROR, "UPDATE target count mismatch --- internal error");
3016 :
3017 11046 : return tlist;
3018 : }
3019 :
3020 : /*
3021 : * addNSItemForReturning -
3022 : * add a ParseNamespaceItem for the OLD or NEW alias in RETURNING.
3023 : */
3024 : static void
3025 4604 : addNSItemForReturning(ParseState *pstate, const char *aliasname,
3026 : VarReturningType returning_type)
3027 : {
3028 : List *colnames;
3029 : int numattrs;
3030 : ParseNamespaceColumn *nscolumns;
3031 : ParseNamespaceItem *nsitem;
3032 :
3033 : /* copy per-column data from the target relation */
3034 4604 : colnames = pstate->p_target_nsitem->p_rte->eref->colnames;
3035 4604 : numattrs = list_length(colnames);
3036 :
3037 4604 : nscolumns = palloc_array(ParseNamespaceColumn, numattrs);
3038 :
3039 4604 : memcpy(nscolumns, pstate->p_target_nsitem->p_nscolumns,
3040 : numattrs * sizeof(ParseNamespaceColumn));
3041 :
3042 : /* mark all columns as returning OLD/NEW */
3043 18096 : for (int i = 0; i < numattrs; i++)
3044 13492 : nscolumns[i].p_varreturningtype = returning_type;
3045 :
3046 : /* build the nsitem, copying most fields from the target relation */
3047 4604 : nsitem = palloc_object(ParseNamespaceItem);
3048 4604 : nsitem->p_names = makeAlias(aliasname, colnames);
3049 4604 : nsitem->p_rte = pstate->p_target_nsitem->p_rte;
3050 4604 : nsitem->p_rtindex = pstate->p_target_nsitem->p_rtindex;
3051 4604 : nsitem->p_perminfo = pstate->p_target_nsitem->p_perminfo;
3052 4604 : nsitem->p_nscolumns = nscolumns;
3053 4604 : nsitem->p_returning_type = returning_type;
3054 :
3055 : /* add it to the query namespace as a table-only item */
3056 4604 : addNSItemToQuery(pstate, nsitem, false, true, false);
3057 4604 : }
3058 :
3059 : /*
3060 : * transformReturningClause -
3061 : * handle a RETURNING clause in INSERT/UPDATE/DELETE/MERGE
3062 : */
3063 : void
3064 14953 : transformReturningClause(ParseState *pstate, Query *qry,
3065 : ReturningClause *returningClause,
3066 : ParseExprKind exprKind)
3067 : {
3068 14953 : int save_nslen = list_length(pstate->p_namespace);
3069 : int save_next_resno;
3070 :
3071 14953 : if (returningClause == NULL)
3072 12605 : return; /* nothing to do */
3073 :
3074 : /*
3075 : * Scan RETURNING WITH(...) options for OLD/NEW alias names. Complain if
3076 : * there is any conflict with existing relations.
3077 : */
3078 4744 : foreach_node(ReturningOption, option, returningClause->options)
3079 : {
3080 80 : switch (option->option)
3081 : {
3082 36 : case RETURNING_OPTION_OLD:
3083 36 : if (qry->returningOldAlias != NULL)
3084 4 : ereport(ERROR,
3085 : errcode(ERRCODE_SYNTAX_ERROR),
3086 : /* translator: %s is OLD or NEW */
3087 : errmsg("%s cannot be specified multiple times", "OLD"),
3088 : parser_errposition(pstate, option->location));
3089 32 : qry->returningOldAlias = option->value;
3090 32 : break;
3091 :
3092 44 : case RETURNING_OPTION_NEW:
3093 44 : if (qry->returningNewAlias != NULL)
3094 4 : ereport(ERROR,
3095 : errcode(ERRCODE_SYNTAX_ERROR),
3096 : /* translator: %s is OLD or NEW */
3097 : errmsg("%s cannot be specified multiple times", "NEW"),
3098 : parser_errposition(pstate, option->location));
3099 40 : qry->returningNewAlias = option->value;
3100 40 : break;
3101 :
3102 0 : default:
3103 0 : elog(ERROR, "unrecognized returning option: %d", option->option);
3104 : }
3105 :
3106 72 : if (refnameNamespaceItem(pstate, NULL, option->value, -1, NULL) != NULL)
3107 8 : ereport(ERROR,
3108 : errcode(ERRCODE_DUPLICATE_ALIAS),
3109 : errmsg("table name \"%s\" specified more than once",
3110 : option->value),
3111 : parser_errposition(pstate, option->location));
3112 :
3113 64 : addNSItemForReturning(pstate, option->value,
3114 64 : option->option == RETURNING_OPTION_OLD ?
3115 : VAR_RETURNING_OLD : VAR_RETURNING_NEW);
3116 : }
3117 :
3118 : /*
3119 : * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
3120 : * unless masked by existing relations.
3121 : */
3122 4644 : if (qry->returningOldAlias == NULL &&
3123 2312 : refnameNamespaceItem(pstate, NULL, "old", -1, NULL) == NULL)
3124 : {
3125 2272 : qry->returningOldAlias = "old";
3126 2272 : addNSItemForReturning(pstate, "old", VAR_RETURNING_OLD);
3127 : }
3128 4640 : if (qry->returningNewAlias == NULL &&
3129 2308 : refnameNamespaceItem(pstate, NULL, "new", -1, NULL) == NULL)
3130 : {
3131 2268 : qry->returningNewAlias = "new";
3132 2268 : addNSItemForReturning(pstate, "new", VAR_RETURNING_NEW);
3133 : }
3134 :
3135 : /*
3136 : * We need to assign resnos starting at one in the RETURNING list. Save
3137 : * and restore the main tlist's value of p_next_resno, just in case
3138 : * someone looks at it later (probably won't happen).
3139 : */
3140 2332 : save_next_resno = pstate->p_next_resno;
3141 2332 : pstate->p_next_resno = 1;
3142 :
3143 : /* transform RETURNING expressions identically to a SELECT targetlist */
3144 2332 : qry->returningList = transformTargetList(pstate,
3145 : returningClause->exprs,
3146 : exprKind);
3147 :
3148 : /*
3149 : * Complain if the nonempty tlist expanded to nothing (which is possible
3150 : * if it contains only a star-expansion of a zero-column table). If we
3151 : * allow this, the parsed Query will look like it didn't have RETURNING,
3152 : * with results that would probably surprise the user.
3153 : */
3154 2304 : if (qry->returningList == NIL)
3155 4 : ereport(ERROR,
3156 : (errcode(ERRCODE_SYNTAX_ERROR),
3157 : errmsg("RETURNING must have at least one column"),
3158 : parser_errposition(pstate,
3159 : exprLocation(linitial(returningClause->exprs)))));
3160 :
3161 : /* mark column origins */
3162 2300 : markTargetListOrigins(pstate, qry->returningList);
3163 :
3164 : /* resolve any still-unresolved output columns as being type text */
3165 2300 : if (pstate->p_resolve_unknowns)
3166 2300 : resolveTargetListUnknowns(pstate, qry->returningList);
3167 :
3168 : /* restore state */
3169 2300 : pstate->p_namespace = list_truncate(pstate->p_namespace, save_nslen);
3170 2300 : pstate->p_next_resno = save_next_resno;
3171 : }
3172 :
3173 :
3174 : /*
3175 : * transformPLAssignStmt -
3176 : * transform a PL/pgSQL assignment statement
3177 : *
3178 : * If there is no opt_indirection, the transformed statement looks like
3179 : * "SELECT a_expr ...", except the expression has been cast to the type of
3180 : * the target. With indirection, it's still a SELECT, but the expression will
3181 : * incorporate FieldStore and/or assignment SubscriptingRef nodes to compute a
3182 : * new value for a container-type variable represented by the target. The
3183 : * expression references the target as the container source.
3184 : */
3185 : static Query *
3186 3452 : transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
3187 : {
3188 : Query *qry;
3189 3452 : ColumnRef *cref = makeNode(ColumnRef);
3190 3452 : List *indirection = stmt->indirection;
3191 3452 : int nnames = stmt->nnames;
3192 : Node *target;
3193 : SelectStmtPassthrough passthru;
3194 : bool save_resolve_unknowns;
3195 :
3196 : /*
3197 : * First, construct a ColumnRef for the target variable. If the target
3198 : * has more than one dotted name, we have to pull the extra names out of
3199 : * the indirection list.
3200 : */
3201 3452 : cref->fields = list_make1(makeString(stmt->name));
3202 3452 : cref->location = stmt->location;
3203 3452 : if (nnames > 1)
3204 : {
3205 : /* avoid munging the raw parsetree */
3206 261 : indirection = list_copy(indirection);
3207 529 : while (--nnames > 0 && indirection != NIL)
3208 : {
3209 268 : Node *ind = (Node *) linitial(indirection);
3210 :
3211 268 : if (!IsA(ind, String))
3212 0 : elog(ERROR, "invalid name count in PLAssignStmt");
3213 268 : cref->fields = lappend(cref->fields, ind);
3214 268 : indirection = list_delete_first(indirection);
3215 : }
3216 : }
3217 :
3218 : /*
3219 : * Transform the target reference. Typically we will get back a Param
3220 : * node, but there's no reason to be too picky about its type. (Note that
3221 : * we must do this before calling transformSelectStmt. It's tempting to
3222 : * do it inside transformPLAssignStmtTarget, but we need to do it before
3223 : * adding any FROM tables to the pstate's namespace, else we might wrongly
3224 : * resolve the target as a table column.)
3225 : */
3226 3452 : target = transformExpr(pstate, (Node *) cref,
3227 : EXPR_KIND_UPDATE_TARGET);
3228 :
3229 : /* Set up passthrough data for transformPLAssignStmtTarget */
3230 3446 : passthru.stmt = stmt;
3231 3446 : passthru.target = target;
3232 3446 : passthru.indirection = indirection;
3233 :
3234 : /*
3235 : * To avoid duplicating a lot of code, we use transformSelectStmt to do
3236 : * almost all of the work. However, we need to do additional processing
3237 : * on the SELECT's targetlist after it's been transformed, but before
3238 : * possible addition of targetlist items for ORDER BY or GROUP BY.
3239 : * transformSelectStmt knows it should call transformPLAssignStmtTarget if
3240 : * it's passed a passthru argument.
3241 : *
3242 : * Also, disable resolution of unknown-type tlist items; PL/pgSQL wants to
3243 : * deal with that itself.
3244 : */
3245 3446 : save_resolve_unknowns = pstate->p_resolve_unknowns;
3246 3446 : pstate->p_resolve_unknowns = false;
3247 3446 : qry = transformSelectStmt(pstate, stmt->val, &passthru);
3248 3439 : pstate->p_resolve_unknowns = save_resolve_unknowns;
3249 :
3250 3439 : return qry;
3251 : }
3252 :
3253 : /*
3254 : * Callback function to adjust a SELECT's tlist to make the output suitable
3255 : * for assignment to a PLAssignStmt's target variable.
3256 : *
3257 : * Note: we actually modify the tle->expr in-place, but the function's API
3258 : * is set up to not presume that.
3259 : */
3260 : static List *
3261 3446 : transformPLAssignStmtTarget(ParseState *pstate, List *tlist,
3262 : SelectStmtPassthrough *passthru)
3263 : {
3264 3446 : PLAssignStmt *stmt = passthru->stmt;
3265 3446 : Node *target = passthru->target;
3266 3446 : List *indirection = passthru->indirection;
3267 : Oid targettype;
3268 : int32 targettypmod;
3269 : Oid targetcollation;
3270 : TargetEntry *tle;
3271 : Oid type_id;
3272 :
3273 3446 : targettype = exprType(target);
3274 3446 : targettypmod = exprTypmod(target);
3275 3446 : targetcollation = exprCollation(target);
3276 :
3277 : /* we should have exactly one targetlist item */
3278 3446 : if (list_length(tlist) != 1)
3279 2 : ereport(ERROR,
3280 : (errcode(ERRCODE_SYNTAX_ERROR),
3281 : errmsg_plural("assignment source returned %d column",
3282 : "assignment source returned %d columns",
3283 : list_length(tlist),
3284 : list_length(tlist))));
3285 :
3286 3444 : tle = linitial_node(TargetEntry, tlist);
3287 :
3288 : /*
3289 : * This next bit is similar to transformAssignedExpr; the key difference
3290 : * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
3291 : */
3292 3444 : type_id = exprType((Node *) tle->expr);
3293 :
3294 3444 : pstate->p_expr_kind = EXPR_KIND_UPDATE_TARGET;
3295 :
3296 3444 : if (indirection)
3297 : {
3298 60 : tle->expr = (Expr *)
3299 65 : transformAssignmentIndirection(pstate,
3300 : target,
3301 65 : stmt->name,
3302 : false,
3303 : targettype,
3304 : targettypmod,
3305 : targetcollation,
3306 : indirection,
3307 : list_head(indirection),
3308 65 : (Node *) tle->expr,
3309 : COERCION_PLPGSQL,
3310 : exprLocation(target));
3311 : }
3312 3379 : else if (targettype != type_id &&
3313 919 : (targettype == RECORDOID || ISCOMPLEX(targettype)) &&
3314 226 : (type_id == RECORDOID || ISCOMPLEX(type_id)))
3315 : {
3316 : /*
3317 : * Hack: do not let coerce_to_target_type() deal with inconsistent
3318 : * composite types. Just pass the expression result through as-is,
3319 : * and let the PL/pgSQL executor do the conversion its way. This is
3320 : * rather bogus, but it's needed for backwards compatibility.
3321 : */
3322 : }
3323 : else
3324 : {
3325 : /*
3326 : * For normal non-qualified target column, do type checking and
3327 : * coercion.
3328 : */
3329 3194 : Node *orig_expr = (Node *) tle->expr;
3330 :
3331 3194 : tle->expr = (Expr *)
3332 3194 : coerce_to_target_type(pstate,
3333 : orig_expr, type_id,
3334 : targettype, targettypmod,
3335 : COERCION_PLPGSQL,
3336 : COERCE_IMPLICIT_CAST,
3337 : -1);
3338 : /* With COERCION_PLPGSQL, this error is probably unreachable */
3339 3194 : if (tle->expr == NULL)
3340 0 : ereport(ERROR,
3341 : (errcode(ERRCODE_DATATYPE_MISMATCH),
3342 : errmsg("variable \"%s\" is of type %s"
3343 : " but expression is of type %s",
3344 : stmt->name,
3345 : format_type_be(targettype),
3346 : format_type_be(type_id)),
3347 : errhint("You will need to rewrite or cast the expression."),
3348 : parser_errposition(pstate, exprLocation(orig_expr))));
3349 : }
3350 :
3351 3439 : pstate->p_expr_kind = EXPR_KIND_NONE;
3352 :
3353 3439 : return list_make1(tle);
3354 : }
3355 :
3356 :
3357 : /*
3358 : * transformDeclareCursorStmt -
3359 : * transform a DECLARE CURSOR Statement
3360 : *
3361 : * DECLARE CURSOR is like other utility statements in that we emit it as a
3362 : * CMD_UTILITY Query node; however, we must first transform the contained
3363 : * query. We used to postpone that until execution, but it's really necessary
3364 : * to do it during the normal parse analysis phase to ensure that side effects
3365 : * of parser hooks happen at the expected time.
3366 : */
3367 : static Query *
3368 2752 : transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
3369 : {
3370 : Query *result;
3371 : Query *query;
3372 :
3373 2752 : if ((stmt->options & CURSOR_OPT_SCROLL) &&
3374 160 : (stmt->options & CURSOR_OPT_NO_SCROLL))
3375 0 : ereport(ERROR,
3376 : (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3377 : /* translator: %s is a SQL keyword */
3378 : errmsg("cannot specify both %s and %s",
3379 : "SCROLL", "NO SCROLL")));
3380 :
3381 2752 : if ((stmt->options & CURSOR_OPT_ASENSITIVE) &&
3382 0 : (stmt->options & CURSOR_OPT_INSENSITIVE))
3383 0 : ereport(ERROR,
3384 : (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3385 : /* translator: %s is a SQL keyword */
3386 : errmsg("cannot specify both %s and %s",
3387 : "ASENSITIVE", "INSENSITIVE")));
3388 :
3389 : /* Transform contained query, not allowing SELECT INTO */
3390 2752 : query = transformStmt(pstate, stmt->query);
3391 2739 : stmt->query = (Node *) query;
3392 :
3393 : /* Grammar should not have allowed anything but SELECT */
3394 2739 : if (!IsA(query, Query) ||
3395 2739 : query->commandType != CMD_SELECT)
3396 0 : elog(ERROR, "unexpected non-SELECT command in DECLARE CURSOR");
3397 :
3398 : /*
3399 : * We also disallow data-modifying WITH in a cursor. (This could be
3400 : * allowed, but the semantics of when the updates occur might be
3401 : * surprising.)
3402 : */
3403 2739 : if (query->hasModifyingCTE)
3404 0 : ereport(ERROR,
3405 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3406 : errmsg("DECLARE CURSOR must not contain data-modifying statements in WITH")));
3407 :
3408 : /* FOR UPDATE and WITH HOLD are not compatible */
3409 2739 : if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_HOLD))
3410 0 : ereport(ERROR,
3411 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3412 : /*------
3413 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3414 : errmsg("DECLARE CURSOR WITH HOLD ... %s is not supported",
3415 : LCS_asString(((RowMarkClause *)
3416 : linitial(query->rowMarks))->strength)),
3417 : errdetail("Holdable cursors must be READ ONLY.")));
3418 :
3419 : /* FOR UPDATE and SCROLL are not compatible */
3420 2739 : if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_SCROLL))
3421 0 : ereport(ERROR,
3422 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3423 : /*------
3424 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3425 : errmsg("DECLARE SCROLL CURSOR ... %s is not supported",
3426 : LCS_asString(((RowMarkClause *)
3427 : linitial(query->rowMarks))->strength)),
3428 : errdetail("Scrollable cursors must be READ ONLY.")));
3429 :
3430 : /* FOR UPDATE and INSENSITIVE are not compatible */
3431 2739 : if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_INSENSITIVE))
3432 0 : ereport(ERROR,
3433 : (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
3434 : /*------
3435 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3436 : errmsg("DECLARE INSENSITIVE CURSOR ... %s is not valid",
3437 : LCS_asString(((RowMarkClause *)
3438 : linitial(query->rowMarks))->strength)),
3439 : errdetail("Insensitive cursors must be READ ONLY.")));
3440 :
3441 : /* represent the command as a utility Query */
3442 2739 : result = makeNode(Query);
3443 2739 : result->commandType = CMD_UTILITY;
3444 2739 : result->utilityStmt = (Node *) stmt;
3445 :
3446 2739 : return result;
3447 : }
3448 :
3449 :
3450 : /*
3451 : * transformExplainStmt -
3452 : * transform an EXPLAIN Statement
3453 : *
3454 : * EXPLAIN is like other utility statements in that we emit it as a
3455 : * CMD_UTILITY Query node; however, we must first transform the contained
3456 : * query. We used to postpone that until execution, but it's really necessary
3457 : * to do it during the normal parse analysis phase to ensure that side effects
3458 : * of parser hooks happen at the expected time.
3459 : */
3460 : static Query *
3461 16538 : transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
3462 : {
3463 : Query *result;
3464 16538 : bool generic_plan = false;
3465 16538 : Oid *paramTypes = NULL;
3466 16538 : int numParams = 0;
3467 :
3468 : /*
3469 : * If we have no external source of parameter definitions, and the
3470 : * GENERIC_PLAN option is specified, then accept variable parameter
3471 : * definitions (similarly to PREPARE, for example).
3472 : */
3473 16538 : if (pstate->p_paramref_hook == NULL)
3474 : {
3475 : ListCell *lc;
3476 :
3477 32852 : foreach(lc, stmt->options)
3478 : {
3479 16326 : DefElem *opt = (DefElem *) lfirst(lc);
3480 :
3481 16326 : if (strcmp(opt->defname, "generic_plan") == 0)
3482 12 : generic_plan = defGetBoolean(opt);
3483 : /* don't "break", as we want the last value */
3484 : }
3485 16526 : if (generic_plan)
3486 12 : setup_parse_variable_parameters(pstate, ¶mTypes, &numParams);
3487 : }
3488 :
3489 : /* transform contained query, allowing SELECT INTO */
3490 16538 : stmt->query = (Node *) transformOptionalSelectInto(pstate, stmt->query);
3491 :
3492 : /* make sure all is well with parameter types */
3493 16529 : if (generic_plan)
3494 12 : check_variable_parameters(pstate, (Query *) stmt->query);
3495 :
3496 : /* represent the command as a utility Query */
3497 16529 : result = makeNode(Query);
3498 16529 : result->commandType = CMD_UTILITY;
3499 16529 : result->utilityStmt = (Node *) stmt;
3500 :
3501 16529 : return result;
3502 : }
3503 :
3504 :
3505 : /*
3506 : * transformCreateTableAsStmt -
3507 : * transform a CREATE TABLE AS, SELECT ... INTO, or CREATE MATERIALIZED VIEW
3508 : * Statement
3509 : *
3510 : * As with DECLARE CURSOR and EXPLAIN, transform the contained statement now.
3511 : */
3512 : static Query *
3513 1318 : transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
3514 : {
3515 : Query *result;
3516 : Query *query;
3517 :
3518 : /* transform contained query, not allowing SELECT INTO */
3519 1318 : query = transformStmt(pstate, stmt->query);
3520 1316 : stmt->query = (Node *) query;
3521 :
3522 : /* additional work needed for CREATE MATERIALIZED VIEW */
3523 1316 : if (stmt->objtype == OBJECT_MATVIEW)
3524 : {
3525 : ObjectAddress temp_object;
3526 :
3527 : /*
3528 : * Prohibit a data-modifying CTE in the query used to create a
3529 : * materialized view. It's not sufficiently clear what the user would
3530 : * want to happen if the MV is refreshed or incrementally maintained.
3531 : */
3532 356 : if (query->hasModifyingCTE)
3533 0 : ereport(ERROR,
3534 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3535 : errmsg("materialized views must not use data-modifying statements in WITH")));
3536 :
3537 : /*
3538 : * Check whether any temporary database objects are used in the
3539 : * creation query. It would be hard to refresh data or incrementally
3540 : * maintain it if a source disappeared.
3541 : */
3542 356 : if (query_uses_temp_object(query, &temp_object))
3543 4 : ereport(ERROR,
3544 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3545 : errmsg("materialized views must not use temporary objects"),
3546 : errdetail("This view depends on temporary %s.",
3547 : getObjectDescription(&temp_object, false))));
3548 :
3549 : /*
3550 : * A materialized view would either need to save parameters for use in
3551 : * maintaining/loading the data or prohibit them entirely. The latter
3552 : * seems safer and more sane.
3553 : */
3554 348 : if (query_contains_extern_params(query))
3555 0 : ereport(ERROR,
3556 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3557 : errmsg("materialized views may not be defined using bound parameters")));
3558 :
3559 : /*
3560 : * For now, we disallow unlogged materialized views, because it seems
3561 : * like a bad idea for them to just go to empty after a crash. (If we
3562 : * could mark them as unpopulated, that would be better, but that
3563 : * requires catalog changes which crash recovery can't presently
3564 : * handle.)
3565 : */
3566 348 : if (stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED)
3567 0 : ereport(ERROR,
3568 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3569 : errmsg("materialized views cannot be unlogged")));
3570 :
3571 : /*
3572 : * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
3573 : * for purposes of creating the view's ON SELECT rule. We stash that
3574 : * in the IntoClause because that's where intorel_startup() can
3575 : * conveniently get it from.
3576 : */
3577 348 : stmt->into->viewQuery = copyObject(query);
3578 : }
3579 :
3580 : /* represent the command as a utility Query */
3581 1308 : result = makeNode(Query);
3582 1308 : result->commandType = CMD_UTILITY;
3583 1308 : result->utilityStmt = (Node *) stmt;
3584 :
3585 1308 : return result;
3586 : }
3587 :
3588 : /*
3589 : * transform a CallStmt
3590 : */
3591 : static Query *
3592 312 : transformCallStmt(ParseState *pstate, CallStmt *stmt)
3593 : {
3594 : List *targs;
3595 : ListCell *lc;
3596 : Node *node;
3597 : FuncExpr *fexpr;
3598 : HeapTuple proctup;
3599 : Datum proargmodes;
3600 : bool isNull;
3601 312 : List *outargs = NIL;
3602 : Query *result;
3603 :
3604 : /*
3605 : * First, do standard parse analysis on the procedure call and its
3606 : * arguments, allowing us to identify the called procedure.
3607 : */
3608 312 : targs = NIL;
3609 764 : foreach(lc, stmt->funccall->args)
3610 : {
3611 452 : targs = lappend(targs, transformExpr(pstate,
3612 452 : (Node *) lfirst(lc),
3613 : EXPR_KIND_CALL_ARGUMENT));
3614 : }
3615 :
3616 312 : node = ParseFuncOrColumn(pstate,
3617 312 : stmt->funccall->funcname,
3618 : targs,
3619 : pstate->p_last_srf,
3620 : stmt->funccall,
3621 : true,
3622 312 : stmt->funccall->location);
3623 :
3624 291 : assign_expr_collations(pstate, node);
3625 :
3626 291 : fexpr = castNode(FuncExpr, node);
3627 :
3628 291 : proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
3629 291 : if (!HeapTupleIsValid(proctup))
3630 0 : elog(ERROR, "cache lookup failed for function %u", fexpr->funcid);
3631 :
3632 : /*
3633 : * Expand the argument list to deal with named-argument notation and
3634 : * default arguments. For ordinary FuncExprs this'd be done during
3635 : * planning, but a CallStmt doesn't go through planning, and there seems
3636 : * no good reason not to do it here.
3637 : */
3638 291 : fexpr->args = expand_function_arguments(fexpr->args,
3639 : true,
3640 : fexpr->funcresulttype,
3641 : proctup);
3642 :
3643 : /* Fetch proargmodes; if it's null, there are no output args */
3644 291 : proargmodes = SysCacheGetAttr(PROCOID, proctup,
3645 : Anum_pg_proc_proargmodes,
3646 : &isNull);
3647 291 : if (!isNull)
3648 : {
3649 : /*
3650 : * Split the list into input arguments in fexpr->args and output
3651 : * arguments in stmt->outargs. INOUT arguments appear in both lists.
3652 : */
3653 : ArrayType *arr;
3654 : int numargs;
3655 : char *argmodes;
3656 : List *inargs;
3657 : int i;
3658 :
3659 119 : arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */
3660 119 : numargs = list_length(fexpr->args);
3661 119 : if (ARR_NDIM(arr) != 1 ||
3662 119 : ARR_DIMS(arr)[0] != numargs ||
3663 119 : ARR_HASNULL(arr) ||
3664 119 : ARR_ELEMTYPE(arr) != CHAROID)
3665 0 : elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
3666 : numargs);
3667 119 : argmodes = (char *) ARR_DATA_PTR(arr);
3668 :
3669 119 : inargs = NIL;
3670 119 : i = 0;
3671 395 : foreach(lc, fexpr->args)
3672 : {
3673 276 : Node *n = lfirst(lc);
3674 :
3675 276 : switch (argmodes[i])
3676 : {
3677 91 : case PROARGMODE_IN:
3678 : case PROARGMODE_VARIADIC:
3679 91 : inargs = lappend(inargs, n);
3680 91 : break;
3681 72 : case PROARGMODE_OUT:
3682 72 : outargs = lappend(outargs, n);
3683 72 : break;
3684 113 : case PROARGMODE_INOUT:
3685 113 : inargs = lappend(inargs, n);
3686 113 : outargs = lappend(outargs, copyObject(n));
3687 113 : break;
3688 0 : default:
3689 : /* note we don't support PROARGMODE_TABLE */
3690 0 : elog(ERROR, "invalid argmode %c for procedure",
3691 : argmodes[i]);
3692 : break;
3693 : }
3694 276 : i++;
3695 : }
3696 119 : fexpr->args = inargs;
3697 : }
3698 :
3699 291 : stmt->funcexpr = fexpr;
3700 291 : stmt->outargs = outargs;
3701 :
3702 291 : ReleaseSysCache(proctup);
3703 :
3704 : /* represent the command as a utility Query */
3705 291 : result = makeNode(Query);
3706 291 : result->commandType = CMD_UTILITY;
3707 291 : result->utilityStmt = (Node *) stmt;
3708 :
3709 291 : return result;
3710 : }
3711 :
3712 : /*
3713 : * Produce a string representation of a LockClauseStrength value.
3714 : * This should only be applied to valid values (not LCS_NONE).
3715 : */
3716 : const char *
3717 32 : LCS_asString(LockClauseStrength strength)
3718 : {
3719 32 : switch (strength)
3720 : {
3721 0 : case LCS_NONE:
3722 : Assert(false);
3723 0 : break;
3724 0 : case LCS_FORKEYSHARE:
3725 0 : return "FOR KEY SHARE";
3726 0 : case LCS_FORSHARE:
3727 0 : return "FOR SHARE";
3728 4 : case LCS_FORNOKEYUPDATE:
3729 4 : return "FOR NO KEY UPDATE";
3730 28 : case LCS_FORUPDATE:
3731 28 : return "FOR UPDATE";
3732 : }
3733 0 : return "FOR some"; /* shouldn't happen */
3734 : }
3735 :
3736 : /*
3737 : * Check for features that are not supported with FOR [KEY] UPDATE/SHARE.
3738 : *
3739 : * exported so planner can check again after rewriting, query pullup, etc
3740 : */
3741 : void
3742 11599 : CheckSelectLocking(Query *qry, LockClauseStrength strength)
3743 : {
3744 : Assert(strength != LCS_NONE); /* else caller error */
3745 :
3746 11599 : if (qry->setOperations)
3747 0 : ereport(ERROR,
3748 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3749 : /*------
3750 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3751 : errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
3752 : LCS_asString(strength))));
3753 11599 : if (qry->distinctClause != NIL)
3754 0 : ereport(ERROR,
3755 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3756 : /*------
3757 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3758 : errmsg("%s is not allowed with DISTINCT clause",
3759 : LCS_asString(strength))));
3760 11599 : if (qry->groupClause != NIL || qry->groupingSets != NIL)
3761 8 : ereport(ERROR,
3762 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3763 : /*------
3764 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3765 : errmsg("%s is not allowed with GROUP BY clause",
3766 : LCS_asString(strength))));
3767 11591 : if (qry->havingQual != NULL)
3768 0 : ereport(ERROR,
3769 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3770 : /*------
3771 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3772 : errmsg("%s is not allowed with HAVING clause",
3773 : LCS_asString(strength))));
3774 11591 : if (qry->hasAggs)
3775 4 : ereport(ERROR,
3776 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3777 : /*------
3778 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3779 : errmsg("%s is not allowed with aggregate functions",
3780 : LCS_asString(strength))));
3781 11587 : if (qry->hasWindowFuncs)
3782 0 : ereport(ERROR,
3783 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3784 : /*------
3785 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3786 : errmsg("%s is not allowed with window functions",
3787 : LCS_asString(strength))));
3788 11587 : if (qry->hasTargetSRFs)
3789 0 : ereport(ERROR,
3790 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3791 : /*------
3792 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3793 : errmsg("%s is not allowed with set-returning functions in the target list",
3794 : LCS_asString(strength))));
3795 11587 : }
3796 :
3797 : /*
3798 : * Transform a FOR [KEY] UPDATE/SHARE clause
3799 : *
3800 : * This basically involves replacing names by integer relids.
3801 : *
3802 : * NB: if you need to change this, see also markQueryForLocking()
3803 : * in rewriteHandler.c, and isLockedRefname() in parse_relation.c.
3804 : */
3805 : static void
3806 5020 : transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
3807 : bool pushedDown)
3808 : {
3809 5020 : List *lockedRels = lc->lockedRels;
3810 : ListCell *l;
3811 : ListCell *rt;
3812 : Index i;
3813 : LockingClause *allrels;
3814 :
3815 5020 : CheckSelectLocking(qry, lc->strength);
3816 :
3817 : /* make a clause we can pass down to subqueries to select all rels */
3818 5008 : allrels = makeNode(LockingClause);
3819 5008 : allrels->lockedRels = NIL; /* indicates all rels */
3820 5008 : allrels->strength = lc->strength;
3821 5008 : allrels->waitPolicy = lc->waitPolicy;
3822 :
3823 5008 : if (lockedRels == NIL)
3824 : {
3825 : /*
3826 : * Lock all regular tables used in query and its subqueries. We
3827 : * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
3828 : * in rules. This is a bit of an abuse of a mostly-obsolete flag, but
3829 : * it's convenient. We can't rely on the namespace mechanism that has
3830 : * largely replaced inFromCl, since for example we need to lock
3831 : * base-relation RTEs even if they are masked by upper joins.
3832 : */
3833 3799 : i = 0;
3834 7648 : foreach(rt, qry->rtable)
3835 : {
3836 3849 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
3837 :
3838 3849 : ++i;
3839 3849 : if (!rte->inFromCl)
3840 8 : continue;
3841 3841 : switch (rte->rtekind)
3842 : {
3843 3825 : case RTE_RELATION:
3844 : {
3845 : RTEPermissionInfo *perminfo;
3846 :
3847 3825 : applyLockingClause(qry, i,
3848 : lc->strength,
3849 : lc->waitPolicy,
3850 : pushedDown);
3851 3825 : perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3852 3825 : perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
3853 : }
3854 3825 : break;
3855 0 : case RTE_SUBQUERY:
3856 0 : applyLockingClause(qry, i, lc->strength, lc->waitPolicy,
3857 : pushedDown);
3858 :
3859 : /*
3860 : * FOR UPDATE/SHARE of subquery is propagated to all of
3861 : * subquery's rels, too. We could do this later (based on
3862 : * the marking of the subquery RTE) but it is convenient
3863 : * to have local knowledge in each query level about which
3864 : * rels need to be opened with RowShareLock.
3865 : */
3866 0 : transformLockingClause(pstate, rte->subquery,
3867 : allrels, true);
3868 0 : break;
3869 16 : default:
3870 : /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
3871 16 : break;
3872 : }
3873 : }
3874 : }
3875 : else
3876 : {
3877 : /*
3878 : * Lock just the named tables. As above, we allow locking any base
3879 : * relation regardless of alias-visibility rules, so we need to
3880 : * examine inFromCl to exclude OLD/NEW.
3881 : */
3882 2408 : foreach(l, lockedRels)
3883 : {
3884 1215 : RangeVar *thisrel = (RangeVar *) lfirst(l);
3885 :
3886 : /* For simplicity we insist on unqualified alias names here */
3887 1215 : if (thisrel->catalogname || thisrel->schemaname)
3888 0 : ereport(ERROR,
3889 : (errcode(ERRCODE_SYNTAX_ERROR),
3890 : /*------
3891 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3892 : errmsg("%s must specify unqualified relation names",
3893 : LCS_asString(lc->strength)),
3894 : parser_errposition(pstate, thisrel->location)));
3895 :
3896 1215 : i = 0;
3897 1409 : foreach(rt, qry->rtable)
3898 : {
3899 1401 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
3900 1401 : char *rtename = rte->eref->aliasname;
3901 :
3902 1401 : ++i;
3903 1401 : if (!rte->inFromCl)
3904 16 : continue;
3905 :
3906 : /*
3907 : * A join RTE without an alias is not visible as a relation
3908 : * name and needs to be skipped (otherwise it might hide a
3909 : * base relation with the same name), except if it has a USING
3910 : * alias, which *is* visible.
3911 : *
3912 : * Subquery and values RTEs without aliases are never visible
3913 : * as relation names and must always be skipped.
3914 : */
3915 1385 : if (rte->alias == NULL)
3916 : {
3917 109 : if (rte->rtekind == RTE_JOIN)
3918 : {
3919 40 : if (rte->join_using_alias == NULL)
3920 32 : continue;
3921 8 : rtename = rte->join_using_alias->aliasname;
3922 : }
3923 69 : else if (rte->rtekind == RTE_SUBQUERY ||
3924 65 : rte->rtekind == RTE_VALUES)
3925 4 : continue;
3926 : }
3927 :
3928 1349 : if (strcmp(rtename, thisrel->relname) == 0)
3929 : {
3930 1207 : switch (rte->rtekind)
3931 : {
3932 1193 : case RTE_RELATION:
3933 : {
3934 : RTEPermissionInfo *perminfo;
3935 :
3936 1193 : applyLockingClause(qry, i,
3937 : lc->strength,
3938 : lc->waitPolicy,
3939 : pushedDown);
3940 1193 : perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
3941 1193 : perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
3942 : }
3943 1193 : break;
3944 6 : case RTE_SUBQUERY:
3945 6 : applyLockingClause(qry, i, lc->strength,
3946 : lc->waitPolicy, pushedDown);
3947 : /* see comment above */
3948 6 : transformLockingClause(pstate, rte->subquery,
3949 : allrels, true);
3950 6 : break;
3951 8 : case RTE_JOIN:
3952 8 : ereport(ERROR,
3953 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3954 : /*------
3955 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3956 : errmsg("%s cannot be applied to a join",
3957 : LCS_asString(lc->strength)),
3958 : parser_errposition(pstate, thisrel->location)));
3959 : break;
3960 0 : case RTE_FUNCTION:
3961 0 : ereport(ERROR,
3962 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3963 : /*------
3964 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3965 : errmsg("%s cannot be applied to a function",
3966 : LCS_asString(lc->strength)),
3967 : parser_errposition(pstate, thisrel->location)));
3968 : break;
3969 0 : case RTE_TABLEFUNC:
3970 0 : ereport(ERROR,
3971 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3972 : /*------
3973 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3974 : errmsg("%s cannot be applied to a table function",
3975 : LCS_asString(lc->strength)),
3976 : parser_errposition(pstate, thisrel->location)));
3977 : break;
3978 0 : case RTE_VALUES:
3979 0 : ereport(ERROR,
3980 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3981 : /*------
3982 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3983 : errmsg("%s cannot be applied to VALUES",
3984 : LCS_asString(lc->strength)),
3985 : parser_errposition(pstate, thisrel->location)));
3986 : break;
3987 0 : case RTE_CTE:
3988 0 : ereport(ERROR,
3989 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3990 : /*------
3991 : translator: %s is a SQL row locking clause such as FOR UPDATE */
3992 : errmsg("%s cannot be applied to a WITH query",
3993 : LCS_asString(lc->strength)),
3994 : parser_errposition(pstate, thisrel->location)));
3995 : break;
3996 0 : case RTE_NAMEDTUPLESTORE:
3997 0 : ereport(ERROR,
3998 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3999 : /*------
4000 : translator: %s is a SQL row locking clause such as FOR UPDATE */
4001 : errmsg("%s cannot be applied to a named tuplestore",
4002 : LCS_asString(lc->strength)),
4003 : parser_errposition(pstate, thisrel->location)));
4004 : break;
4005 :
4006 : /* Shouldn't be possible to see RTE_RESULT here */
4007 :
4008 0 : default:
4009 0 : elog(ERROR, "unrecognized RTE type: %d",
4010 : (int) rte->rtekind);
4011 : break;
4012 : }
4013 1199 : break; /* out of foreach loop */
4014 : }
4015 : }
4016 1207 : if (rt == NULL)
4017 8 : ereport(ERROR,
4018 : (errcode(ERRCODE_UNDEFINED_TABLE),
4019 : /*------
4020 : translator: %s is a SQL row locking clause such as FOR UPDATE */
4021 : errmsg("relation \"%s\" in %s clause not found in FROM clause",
4022 : thisrel->relname,
4023 : LCS_asString(lc->strength)),
4024 : parser_errposition(pstate, thisrel->location)));
4025 : }
4026 : }
4027 4992 : }
4028 :
4029 : /*
4030 : * Record locking info for a single rangetable item
4031 : */
4032 : void
4033 5088 : applyLockingClause(Query *qry, Index rtindex,
4034 : LockClauseStrength strength, LockWaitPolicy waitPolicy,
4035 : bool pushedDown)
4036 : {
4037 : RowMarkClause *rc;
4038 :
4039 : Assert(strength != LCS_NONE); /* else caller error */
4040 :
4041 : /* If it's an explicit clause, make sure hasForUpdate gets set */
4042 5088 : if (!pushedDown)
4043 5022 : qry->hasForUpdate = true;
4044 :
4045 : /* Check for pre-existing entry for same rtindex */
4046 5088 : if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
4047 : {
4048 : /*
4049 : * If the same RTE is specified with more than one locking strength,
4050 : * use the strongest. (Reasonable, since you can't take both a shared
4051 : * and exclusive lock at the same time; it'll end up being exclusive
4052 : * anyway.)
4053 : *
4054 : * Similarly, if the same RTE is specified with more than one lock
4055 : * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
4056 : * turn wins over waiting for the lock (the default). This is a bit
4057 : * more debatable but raising an error doesn't seem helpful. (Consider
4058 : * for instance SELECT FOR UPDATE NOWAIT from a view that internally
4059 : * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
4060 : * LOCKED is reasonable since the former throws an error in case of
4061 : * coming across a locked tuple, which may be undesirable in some
4062 : * cases but it seems better than silently returning inconsistent
4063 : * results.
4064 : *
4065 : * And of course pushedDown becomes false if any clause is explicit.
4066 : */
4067 0 : rc->strength = Max(rc->strength, strength);
4068 0 : rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
4069 0 : rc->pushedDown &= pushedDown;
4070 0 : return;
4071 : }
4072 :
4073 : /* Make a new RowMarkClause */
4074 5088 : rc = makeNode(RowMarkClause);
4075 5088 : rc->rti = rtindex;
4076 5088 : rc->strength = strength;
4077 5088 : rc->waitPolicy = waitPolicy;
4078 5088 : rc->pushedDown = pushedDown;
4079 5088 : qry->rowMarks = lappend(qry->rowMarks, rc);
4080 : }
4081 :
4082 : #ifdef DEBUG_NODE_TESTS_ENABLED
4083 : /*
4084 : * Coverage testing for raw_expression_tree_walker().
4085 : *
4086 : * When enabled, we run raw_expression_tree_walker() over every DML statement
4087 : * submitted to parse analysis. Without this provision, that function is only
4088 : * applied in limited cases involving CTEs, and we don't really want to have
4089 : * to test everything inside as well as outside a CTE.
4090 : */
4091 : static bool
4092 16927098 : test_raw_expression_coverage(Node *node, void *context)
4093 : {
4094 16927098 : if (node == NULL)
4095 9124646 : return false;
4096 7802452 : return raw_expression_tree_walker(node,
4097 : test_raw_expression_coverage,
4098 : context);
4099 : }
4100 : #endif /* DEBUG_NODE_TESTS_ENABLED */
|
