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