Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * preptlist.c
4 : * Routines to preprocess the parse tree target list
5 : *
6 : * For an INSERT, the targetlist must contain an entry for each attribute of
7 : * the target relation in the correct order.
8 : *
9 : * For an UPDATE, the targetlist just contains the expressions for the new
10 : * column values.
11 : *
12 : * For UPDATE and DELETE queries, the targetlist must also contain "junk"
13 : * tlist entries needed to allow the executor to identify the rows to be
14 : * updated or deleted; for example, the ctid of a heap row. (The planner
15 : * adds these; they're not in what we receive from the parser/rewriter.)
16 : *
17 : * For all query types, there can be additional junk tlist entries, such as
18 : * sort keys, Vars needed for a RETURNING list, and row ID information needed
19 : * for SELECT FOR UPDATE locking and/or EvalPlanQual checking.
20 : *
21 : * The query rewrite phase also does preprocessing of the targetlist (see
22 : * rewriteTargetListIU). The division of labor between here and there is
23 : * partially historical, but it's not entirely arbitrary. The stuff done
24 : * here is closely connected to physical access to tables, whereas the
25 : * rewriter's work is more concerned with SQL semantics.
26 : *
27 : *
28 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
29 : * Portions Copyright (c) 1994, Regents of the University of California
30 : *
31 : * IDENTIFICATION
32 : * src/backend/optimizer/prep/preptlist.c
33 : *
34 : *-------------------------------------------------------------------------
35 : */
36 :
37 : #include "postgres.h"
38 :
39 : #include "access/table.h"
40 : #include "nodes/makefuncs.h"
41 : #include "optimizer/appendinfo.h"
42 : #include "optimizer/optimizer.h"
43 : #include "optimizer/prep.h"
44 : #include "optimizer/tlist.h"
45 : #include "parser/parse_coerce.h"
46 : #include "parser/parsetree.h"
47 : #include "utils/rel.h"
48 :
49 : static List *expand_insert_targetlist(PlannerInfo *root, List *tlist,
50 : Relation rel);
51 :
52 :
53 : /*
54 : * preprocess_targetlist
55 : * Driver for preprocessing the parse tree targetlist.
56 : *
57 : * The preprocessed targetlist is returned in root->processed_tlist.
58 : * Also, if this is an UPDATE, we return a list of target column numbers
59 : * in root->update_colnos. (Resnos in processed_tlist will be consecutive,
60 : * so do not look at that to find out which columns are targets!)
61 : */
62 : void
63 532386 : preprocess_targetlist(PlannerInfo *root)
64 : {
65 532386 : Query *parse = root->parse;
66 532386 : int result_relation = parse->resultRelation;
67 532386 : List *range_table = parse->rtable;
68 532386 : CmdType command_type = parse->commandType;
69 532386 : RangeTblEntry *target_rte = NULL;
70 532386 : Relation target_relation = NULL;
71 : List *tlist;
72 : ListCell *lc;
73 :
74 : /*
75 : * If there is a result relation, open it so we can look for missing
76 : * columns and so on. We assume that previous code already acquired at
77 : * least AccessShareLock on the relation, so we need no lock here.
78 : */
79 532386 : if (result_relation)
80 : {
81 92286 : target_rte = rt_fetch(result_relation, range_table);
82 :
83 : /*
84 : * Sanity check: it'd better be a real relation not, say, a subquery.
85 : * Else parser or rewriter messed up.
86 : */
87 92286 : if (target_rte->rtekind != RTE_RELATION)
88 0 : elog(ERROR, "result relation must be a regular relation");
89 :
90 92286 : target_relation = table_open(target_rte->relid, NoLock);
91 : }
92 : else
93 : Assert(command_type == CMD_SELECT);
94 :
95 : /*
96 : * In an INSERT, the executor expects the targetlist to match the exact
97 : * order of the target table's attributes, including entries for
98 : * attributes not mentioned in the source query.
99 : *
100 : * In an UPDATE, we don't rearrange the tlist order, but we need to make a
101 : * separate list of the target attribute numbers, in tlist order, and then
102 : * renumber the processed_tlist entries to be consecutive.
103 : */
104 532386 : tlist = parse->targetList;
105 532386 : if (command_type == CMD_INSERT)
106 72296 : tlist = expand_insert_targetlist(root, tlist, target_relation);
107 460090 : else if (command_type == CMD_UPDATE)
108 13818 : root->update_colnos = extract_update_targetlist_colnos(tlist);
109 :
110 : /*
111 : * For non-inherited UPDATE/DELETE/MERGE, register any junk column(s)
112 : * needed to allow the executor to identify the rows to be updated or
113 : * deleted. In the inheritance case, we do nothing now, leaving this to
114 : * be dealt with when expand_inherited_rtentry() makes the leaf target
115 : * relations. (But there might not be any leaf target relations, in which
116 : * case we must do this in distribute_row_identity_vars().)
117 : */
118 532386 : if ((command_type == CMD_UPDATE || command_type == CMD_DELETE ||
119 19990 : command_type == CMD_MERGE) &&
120 19990 : !target_rte->inh)
121 : {
122 : /* row-identity logic expects to add stuff to processed_tlist */
123 17198 : root->processed_tlist = tlist;
124 17198 : add_row_identity_columns(root, result_relation,
125 : target_rte, target_relation);
126 17198 : tlist = root->processed_tlist;
127 : }
128 :
129 : /*
130 : * For MERGE we also need to handle the target list for each INSERT and
131 : * UPDATE action separately. In addition, we examine the qual of each
132 : * action and add any Vars there (other than those of the target rel) to
133 : * the subplan targetlist.
134 : */
135 532386 : if (command_type == CMD_MERGE)
136 : {
137 : ListCell *l;
138 : List *vars;
139 :
140 : /*
141 : * For MERGE, handle targetlist of each MergeAction separately. Give
142 : * the same treatment to MergeAction->targetList as we would have
143 : * given to a regular INSERT. For UPDATE, collect the column numbers
144 : * being modified.
145 : */
146 4608 : foreach(l, parse->mergeActionList)
147 : {
148 2778 : MergeAction *action = (MergeAction *) lfirst(l);
149 : ListCell *l2;
150 :
151 2778 : if (action->commandType == CMD_INSERT)
152 878 : action->targetList = expand_insert_targetlist(root,
153 : action->targetList,
154 : target_relation);
155 1900 : else if (action->commandType == CMD_UPDATE)
156 1382 : action->updateColnos =
157 1382 : extract_update_targetlist_colnos(action->targetList);
158 :
159 : /*
160 : * Add resjunk entries for any Vars and PlaceHolderVars used in
161 : * each action's targetlist and WHEN condition that belong to
162 : * relations other than the target. We don't expect to see any
163 : * aggregates or window functions here.
164 : */
165 2778 : vars = pull_var_clause((Node *)
166 2778 : list_concat_copy((List *) action->qual,
167 2778 : action->targetList),
168 : PVC_INCLUDE_PLACEHOLDERS);
169 6240 : foreach(l2, vars)
170 : {
171 3462 : Var *var = (Var *) lfirst(l2);
172 : TargetEntry *tle;
173 :
174 3462 : if (IsA(var, Var) && var->varno == result_relation)
175 1682 : continue; /* don't need it */
176 :
177 1780 : if (tlist_member((Expr *) var, tlist))
178 482 : continue; /* already got it */
179 :
180 1298 : tle = makeTargetEntry((Expr *) var,
181 1298 : list_length(tlist) + 1,
182 : NULL, true);
183 1298 : tlist = lappend(tlist, tle);
184 : }
185 2778 : list_free(vars);
186 : }
187 :
188 : /*
189 : * Add resjunk entries for any Vars and PlaceHolderVars used in the
190 : * join condition that belong to relations other than the target. We
191 : * don't expect to see any aggregates or window functions here.
192 : */
193 1830 : vars = pull_var_clause(parse->mergeJoinCondition,
194 : PVC_INCLUDE_PLACEHOLDERS);
195 2220 : foreach(l, vars)
196 : {
197 390 : Var *var = (Var *) lfirst(l);
198 : TargetEntry *tle;
199 :
200 390 : if (IsA(var, Var) && var->varno == result_relation)
201 132 : continue; /* don't need it */
202 :
203 258 : if (tlist_member((Expr *) var, tlist))
204 102 : continue; /* already got it */
205 :
206 156 : tle = makeTargetEntry((Expr *) var,
207 156 : list_length(tlist) + 1,
208 : NULL, true);
209 156 : tlist = lappend(tlist, tle);
210 : }
211 : }
212 :
213 : /*
214 : * Add necessary junk columns for rowmarked rels. These values are needed
215 : * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
216 : * rechecking. See comments for PlanRowMark in plannodes.h. If you
217 : * change this stanza, see also expand_inherited_rtentry(), which has to
218 : * be able to add on junk columns equivalent to these.
219 : *
220 : * (Someday it might be useful to fold these resjunk columns into the
221 : * row-identity-column management used for UPDATE/DELETE. Today is not
222 : * that day, however. One notable issue is that it seems important that
223 : * the whole-row Vars made here use the real table rowtype, not RECORD, so
224 : * that conversion to/from child relations' rowtypes will happen. Also,
225 : * since these entries don't potentially bloat with more and more child
226 : * relations, there's not really much need for column sharing.)
227 : */
228 543012 : foreach(lc, root->rowMarks)
229 : {
230 10626 : PlanRowMark *rc = (PlanRowMark *) lfirst(lc);
231 : Var *var;
232 : char resname[32];
233 : TargetEntry *tle;
234 :
235 : /* child rels use the same junk attrs as their parents */
236 10626 : if (rc->rti != rc->prti)
237 0 : continue;
238 :
239 10626 : if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
240 : {
241 : /* Need to fetch TID */
242 9908 : var = makeVar(rc->rti,
243 : SelfItemPointerAttributeNumber,
244 : TIDOID,
245 : -1,
246 : InvalidOid,
247 : 0);
248 9908 : snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
249 9908 : tle = makeTargetEntry((Expr *) var,
250 9908 : list_length(tlist) + 1,
251 : pstrdup(resname),
252 : true);
253 9908 : tlist = lappend(tlist, tle);
254 : }
255 10626 : if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
256 : {
257 : /* Need the whole row as a junk var */
258 718 : var = makeWholeRowVar(rt_fetch(rc->rti, range_table),
259 718 : rc->rti,
260 : 0,
261 : false);
262 718 : snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
263 718 : tle = makeTargetEntry((Expr *) var,
264 718 : list_length(tlist) + 1,
265 : pstrdup(resname),
266 : true);
267 718 : tlist = lappend(tlist, tle);
268 : }
269 :
270 : /* If parent of inheritance tree, always fetch the tableoid too. */
271 10626 : if (rc->isParent)
272 : {
273 0 : var = makeVar(rc->rti,
274 : TableOidAttributeNumber,
275 : OIDOID,
276 : -1,
277 : InvalidOid,
278 : 0);
279 0 : snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
280 0 : tle = makeTargetEntry((Expr *) var,
281 0 : list_length(tlist) + 1,
282 : pstrdup(resname),
283 : true);
284 0 : tlist = lappend(tlist, tle);
285 : }
286 : }
287 :
288 : /*
289 : * If the query has a RETURNING list, add resjunk entries for any Vars
290 : * used in RETURNING that belong to other relations. We need to do this
291 : * to make these Vars available for the RETURNING calculation. Vars that
292 : * belong to the result rel don't need to be added, because they will be
293 : * made to refer to the actual heap tuple.
294 : */
295 532386 : if (parse->returningList && list_length(parse->rtable) > 1)
296 : {
297 : List *vars;
298 : ListCell *l;
299 :
300 1750 : vars = pull_var_clause((Node *) parse->returningList,
301 : PVC_RECURSE_AGGREGATES |
302 : PVC_RECURSE_WINDOWFUNCS |
303 : PVC_INCLUDE_PLACEHOLDERS);
304 8044 : foreach(l, vars)
305 : {
306 6294 : Var *var = (Var *) lfirst(l);
307 : TargetEntry *tle;
308 :
309 6294 : if (IsA(var, Var) &&
310 6294 : var->varno == result_relation)
311 5670 : continue; /* don't need it */
312 :
313 624 : if (tlist_member((Expr *) var, tlist))
314 236 : continue; /* already got it */
315 :
316 388 : tle = makeTargetEntry((Expr *) var,
317 388 : list_length(tlist) + 1,
318 : NULL,
319 : true);
320 :
321 388 : tlist = lappend(tlist, tle);
322 : }
323 1750 : list_free(vars);
324 : }
325 :
326 532386 : root->processed_tlist = tlist;
327 :
328 532386 : if (target_relation)
329 92286 : table_close(target_relation, NoLock);
330 532386 : }
331 :
332 : /*
333 : * extract_update_targetlist_colnos
334 : * Extract a list of the target-table column numbers that
335 : * an UPDATE's targetlist wants to assign to, then renumber.
336 : *
337 : * The convention in the parser and rewriter is that the resnos in an
338 : * UPDATE's non-resjunk TLE entries are the target column numbers
339 : * to assign to. Here, we extract that info into a separate list, and
340 : * then convert the tlist to the sequential-numbering convention that's
341 : * used by all other query types.
342 : *
343 : * This is also applied to the tlist associated with INSERT ... ON CONFLICT
344 : * ... UPDATE, although not till much later in planning.
345 : */
346 : List *
347 17014 : extract_update_targetlist_colnos(List *tlist)
348 : {
349 17014 : List *update_colnos = NIL;
350 17014 : AttrNumber nextresno = 1;
351 : ListCell *lc;
352 :
353 38110 : foreach(lc, tlist)
354 : {
355 21096 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
356 :
357 21096 : if (!tle->resjunk)
358 20808 : update_colnos = lappend_int(update_colnos, tle->resno);
359 21096 : tle->resno = nextresno++;
360 : }
361 17014 : return update_colnos;
362 : }
363 :
364 :
365 : /*****************************************************************************
366 : *
367 : * TARGETLIST EXPANSION
368 : *
369 : *****************************************************************************/
370 :
371 : /*
372 : * expand_insert_targetlist
373 : * Given a target list as generated by the parser and a result relation,
374 : * add targetlist entries for any missing attributes, and ensure the
375 : * non-junk attributes appear in proper field order.
376 : *
377 : * Once upon a time we also did more or less this with UPDATE targetlists,
378 : * but now this code is only applied to INSERT targetlists.
379 : */
380 : static List *
381 73174 : expand_insert_targetlist(PlannerInfo *root, List *tlist, Relation rel)
382 : {
383 73174 : List *new_tlist = NIL;
384 : ListCell *tlist_item;
385 : int attrno,
386 : numattrs;
387 :
388 73174 : tlist_item = list_head(tlist);
389 :
390 : /*
391 : * The rewriter should have already ensured that the TLEs are in correct
392 : * order; but we have to insert TLEs for any missing attributes.
393 : *
394 : * Scan the tuple description in the relation's relcache entry to make
395 : * sure we have all the user attributes in the right order.
396 : */
397 73174 : numattrs = RelationGetNumberOfAttributes(rel);
398 :
399 237218 : for (attrno = 1; attrno <= numattrs; attrno++)
400 : {
401 164044 : Form_pg_attribute att_tup = TupleDescAttr(rel->rd_att, attrno - 1);
402 164044 : TargetEntry *new_tle = NULL;
403 :
404 164044 : if (tlist_item != NULL)
405 : {
406 153680 : TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
407 :
408 153680 : if (!old_tle->resjunk && old_tle->resno == attrno)
409 : {
410 144702 : new_tle = old_tle;
411 144702 : tlist_item = lnext(tlist, tlist_item);
412 : }
413 : }
414 :
415 164044 : if (new_tle == NULL)
416 : {
417 : /*
418 : * Didn't find a matching tlist entry, so make one.
419 : *
420 : * INSERTs should insert NULL in this case. (We assume the
421 : * rewriter would have inserted any available non-NULL default
422 : * value.) Also, if the column isn't dropped, apply any domain
423 : * constraints that might exist --- this is to catch domain NOT
424 : * NULL.
425 : *
426 : * When generating a NULL constant for a dropped column, we label
427 : * it INT4 (any other guaranteed-to-exist datatype would do as
428 : * well). We can't label it with the dropped column's datatype
429 : * since that might not exist anymore. It does not really matter
430 : * what we claim the type is, since NULL is NULL --- its
431 : * representation is datatype-independent. This could perhaps
432 : * confuse code comparing the finished plan to the target
433 : * relation, however.
434 : */
435 : Node *new_expr;
436 :
437 19342 : if (!att_tup->attisdropped)
438 : {
439 18714 : new_expr = coerce_null_to_domain(att_tup->atttypid,
440 : att_tup->atttypmod,
441 : att_tup->attcollation,
442 18714 : att_tup->attlen,
443 18714 : att_tup->attbyval);
444 : /* Must run expression preprocessing on any non-const nodes */
445 18714 : if (!IsA(new_expr, Const))
446 78 : new_expr = eval_const_expressions(root, new_expr);
447 : }
448 : else
449 : {
450 : /* Insert NULL for dropped column */
451 628 : new_expr = (Node *) makeConst(INT4OID,
452 : -1,
453 : InvalidOid,
454 : sizeof(int32),
455 : (Datum) 0,
456 : true, /* isnull */
457 : true /* byval */ );
458 : }
459 :
460 19342 : new_tle = makeTargetEntry((Expr *) new_expr,
461 : attrno,
462 19342 : pstrdup(NameStr(att_tup->attname)),
463 : false);
464 : }
465 :
466 164044 : new_tlist = lappend(new_tlist, new_tle);
467 : }
468 :
469 : /*
470 : * The remaining tlist entries should be resjunk; append them all to the
471 : * end of the new tlist, making sure they have resnos higher than the last
472 : * real attribute. (Note: although the rewriter already did such
473 : * renumbering, we have to do it again here in case we added NULL entries
474 : * above.)
475 : */
476 73174 : while (tlist_item)
477 : {
478 0 : TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
479 :
480 0 : if (!old_tle->resjunk)
481 0 : elog(ERROR, "targetlist is not sorted correctly");
482 : /* Get the resno right, but don't copy unnecessarily */
483 0 : if (old_tle->resno != attrno)
484 : {
485 0 : old_tle = flatCopyTargetEntry(old_tle);
486 0 : old_tle->resno = attrno;
487 : }
488 0 : new_tlist = lappend(new_tlist, old_tle);
489 0 : attrno++;
490 0 : tlist_item = lnext(tlist, tlist_item);
491 : }
492 :
493 73174 : return new_tlist;
494 : }
495 :
496 :
497 : /*
498 : * Locate PlanRowMark for given RT index, or return NULL if none
499 : *
500 : * This probably ought to be elsewhere, but there's no very good place
501 : */
502 : PlanRowMark *
503 22902 : get_plan_rowmark(List *rowmarks, Index rtindex)
504 : {
505 : ListCell *l;
506 :
507 24394 : foreach(l, rowmarks)
508 : {
509 3756 : PlanRowMark *rc = (PlanRowMark *) lfirst(l);
510 :
511 3756 : if (rc->rti == rtindex)
512 2264 : return rc;
513 : }
514 20638 : return NULL;
515 : }
|
