Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * appendinfo.c
4 : * Routines for mapping between append parent(s) and children
5 : *
6 : * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/optimizer/util/appendinfo.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include "access/htup_details.h"
18 : #include "access/table.h"
19 : #include "foreign/fdwapi.h"
20 : #include "nodes/makefuncs.h"
21 : #include "nodes/nodeFuncs.h"
22 : #include "optimizer/appendinfo.h"
23 : #include "optimizer/pathnode.h"
24 : #include "optimizer/planmain.h"
25 : #include "parser/parsetree.h"
26 : #include "utils/lsyscache.h"
27 : #include "utils/rel.h"
28 : #include "utils/syscache.h"
29 :
30 :
31 : typedef struct
32 : {
33 : PlannerInfo *root;
34 : int nappinfos;
35 : AppendRelInfo **appinfos;
36 : } adjust_appendrel_attrs_context;
37 :
38 : static void make_inh_translation_list(Relation oldrelation,
39 : Relation newrelation,
40 : Index newvarno,
41 : AppendRelInfo *appinfo);
42 : static Node *adjust_appendrel_attrs_mutator(Node *node,
43 : adjust_appendrel_attrs_context *context);
44 :
45 :
46 : /*
47 : * make_append_rel_info
48 : * Build an AppendRelInfo for the parent-child pair
49 : */
50 : AppendRelInfo *
51 36092 : make_append_rel_info(Relation parentrel, Relation childrel,
52 : Index parentRTindex, Index childRTindex)
53 : {
54 36092 : AppendRelInfo *appinfo = makeNode(AppendRelInfo);
55 :
56 36092 : appinfo->parent_relid = parentRTindex;
57 36092 : appinfo->child_relid = childRTindex;
58 36092 : appinfo->parent_reltype = parentrel->rd_rel->reltype;
59 36092 : appinfo->child_reltype = childrel->rd_rel->reltype;
60 36092 : make_inh_translation_list(parentrel, childrel, childRTindex, appinfo);
61 36090 : appinfo->parent_reloid = RelationGetRelid(parentrel);
62 :
63 36090 : return appinfo;
64 : }
65 :
66 : /*
67 : * make_inh_translation_list
68 : * Build the list of translations from parent Vars to child Vars for
69 : * an inheritance child, as well as a reverse-translation array.
70 : *
71 : * The reverse-translation array has an entry for each child relation
72 : * column, which is either the 1-based index of the corresponding parent
73 : * column, or 0 if there's no match (that happens for dropped child columns,
74 : * as well as child columns beyond those of the parent, which are allowed in
75 : * traditional inheritance though not partitioning).
76 : *
77 : * For paranoia's sake, we match type/collation as well as attribute name.
78 : */
79 : static void
80 36092 : make_inh_translation_list(Relation oldrelation, Relation newrelation,
81 : Index newvarno,
82 : AppendRelInfo *appinfo)
83 : {
84 36092 : List *vars = NIL;
85 : AttrNumber *pcolnos;
86 36092 : TupleDesc old_tupdesc = RelationGetDescr(oldrelation);
87 36092 : TupleDesc new_tupdesc = RelationGetDescr(newrelation);
88 36092 : Oid new_relid = RelationGetRelid(newrelation);
89 36092 : int oldnatts = old_tupdesc->natts;
90 36092 : int newnatts = new_tupdesc->natts;
91 : int old_attno;
92 36092 : int new_attno = 0;
93 :
94 : /* Initialize reverse-translation array with all entries zero */
95 36092 : appinfo->num_child_cols = newnatts;
96 36092 : appinfo->parent_colnos = pcolnos =
97 36092 : (AttrNumber *) palloc0(newnatts * sizeof(AttrNumber));
98 :
99 134638 : for (old_attno = 0; old_attno < oldnatts; old_attno++)
100 : {
101 : Form_pg_attribute att;
102 : char *attname;
103 : Oid atttypid;
104 : int32 atttypmod;
105 : Oid attcollation;
106 :
107 98548 : att = TupleDescAttr(old_tupdesc, old_attno);
108 98548 : if (att->attisdropped)
109 : {
110 : /* Just put NULL into this list entry */
111 3100 : vars = lappend(vars, NULL);
112 3100 : continue;
113 : }
114 95448 : attname = NameStr(att->attname);
115 95448 : atttypid = att->atttypid;
116 95448 : atttypmod = att->atttypmod;
117 95448 : attcollation = att->attcollation;
118 :
119 : /*
120 : * When we are generating the "translation list" for the parent table
121 : * of an inheritance set, no need to search for matches.
122 : */
123 95448 : if (oldrelation == newrelation)
124 : {
125 5704 : vars = lappend(vars, makeVar(newvarno,
126 5704 : (AttrNumber) (old_attno + 1),
127 : atttypid,
128 : atttypmod,
129 : attcollation,
130 : 0));
131 5704 : pcolnos[old_attno] = old_attno + 1;
132 5704 : continue;
133 : }
134 :
135 : /*
136 : * Otherwise we have to search for the matching column by name.
137 : * There's no guarantee it'll have the same column position, because
138 : * of cases like ALTER TABLE ADD COLUMN and multiple inheritance.
139 : * However, in simple cases, the relative order of columns is mostly
140 : * the same in both relations, so try the column of newrelation that
141 : * follows immediately after the one that we just found, and if that
142 : * fails, let syscache handle it.
143 : */
144 89744 : if (new_attno >= newnatts ||
145 87676 : (att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped ||
146 86864 : strcmp(attname, NameStr(att->attname)) != 0)
147 : {
148 : HeapTuple newtup;
149 :
150 7410 : newtup = SearchSysCacheAttName(new_relid, attname);
151 7410 : if (!HeapTupleIsValid(newtup))
152 0 : elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"",
153 : attname, RelationGetRelationName(newrelation));
154 7410 : new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1;
155 : Assert(new_attno >= 0 && new_attno < newnatts);
156 7410 : ReleaseSysCache(newtup);
157 :
158 7410 : att = TupleDescAttr(new_tupdesc, new_attno);
159 : }
160 :
161 : /* Found it, check type and collation match */
162 89744 : if (atttypid != att->atttypid || atttypmod != att->atttypmod)
163 2 : elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type",
164 : attname, RelationGetRelationName(newrelation));
165 89742 : if (attcollation != att->attcollation)
166 0 : elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation",
167 : attname, RelationGetRelationName(newrelation));
168 :
169 89742 : vars = lappend(vars, makeVar(newvarno,
170 89742 : (AttrNumber) (new_attno + 1),
171 : atttypid,
172 : atttypmod,
173 : attcollation,
174 : 0));
175 89742 : pcolnos[new_attno] = old_attno + 1;
176 89742 : new_attno++;
177 : }
178 :
179 36090 : appinfo->translated_vars = vars;
180 36090 : }
181 :
182 : /*
183 : * adjust_appendrel_attrs
184 : * Copy the specified query or expression and translate Vars referring to a
185 : * parent rel to refer to the corresponding child rel instead. We also
186 : * update rtindexes appearing outside Vars, such as resultRelation and
187 : * jointree relids.
188 : *
189 : * Note: this is only applied after conversion of sublinks to subplans,
190 : * so we don't need to cope with recursion into sub-queries.
191 : *
192 : * Note: this is not hugely different from what pullup_replace_vars() does;
193 : * maybe we should try to fold the two routines together.
194 : */
195 : Node *
196 180948 : adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos,
197 : AppendRelInfo **appinfos)
198 : {
199 : adjust_appendrel_attrs_context context;
200 :
201 180948 : context.root = root;
202 180948 : context.nappinfos = nappinfos;
203 180948 : context.appinfos = appinfos;
204 :
205 : /* If there's nothing to adjust, don't call this function. */
206 : Assert(nappinfos >= 1 && appinfos != NULL);
207 :
208 : /* Should never be translating a Query tree. */
209 : Assert(node == NULL || !IsA(node, Query));
210 :
211 180948 : return adjust_appendrel_attrs_mutator(node, &context);
212 : }
213 :
214 : static Node *
215 830860 : adjust_appendrel_attrs_mutator(Node *node,
216 : adjust_appendrel_attrs_context *context)
217 : {
218 830860 : AppendRelInfo **appinfos = context->appinfos;
219 830860 : int nappinfos = context->nappinfos;
220 : int cnt;
221 :
222 830860 : if (node == NULL)
223 84142 : return NULL;
224 746718 : if (IsA(node, Var))
225 : {
226 327914 : Var *var = (Var *) copyObject(node);
227 327914 : AppendRelInfo *appinfo = NULL;
228 :
229 327914 : if (var->varlevelsup != 0)
230 0 : return (Node *) var; /* no changes needed */
231 :
232 : /*
233 : * You might think we need to adjust var->varnullingrels, but that
234 : * shouldn't need any changes. It will contain outer-join relids,
235 : * while the transformation we are making affects only baserels.
236 : * Below, we just propagate var->varnullingrels into the translated
237 : * Var.
238 : *
239 : * If var->varnullingrels isn't empty, and the translation wouldn't be
240 : * a Var, we have to fail. One could imagine wrapping the translated
241 : * expression in a PlaceHolderVar, but that won't work because this is
242 : * typically used after freezing placeholders. Fortunately, the case
243 : * appears unreachable at the moment. We can see nonempty
244 : * var->varnullingrels here, but only in cases involving partitionwise
245 : * joining, and in such cases the translations will always be Vars.
246 : * (Non-Var translations occur only for appendrels made by flattening
247 : * UNION ALL subqueries.) Should we need to make this work in future,
248 : * a possible fix is to mandate that prepjointree.c create PHVs for
249 : * all non-Var outputs of such subqueries, and then we could look up
250 : * the pre-existing PHV here. Or perhaps just wrap the translations
251 : * that way to begin with?
252 : */
253 :
254 417368 : for (cnt = 0; cnt < nappinfos; cnt++)
255 : {
256 365694 : if (var->varno == appinfos[cnt]->parent_relid)
257 : {
258 276240 : appinfo = appinfos[cnt];
259 276240 : break;
260 : }
261 : }
262 :
263 327914 : if (appinfo)
264 : {
265 276240 : var->varno = appinfo->child_relid;
266 : /* it's now a generated Var, so drop any syntactic labeling */
267 276240 : var->varnosyn = 0;
268 276240 : var->varattnosyn = 0;
269 276240 : if (var->varattno > 0)
270 : {
271 : Node *newnode;
272 :
273 261610 : if (var->varattno > list_length(appinfo->translated_vars))
274 0 : elog(ERROR, "attribute %d of relation \"%s\" does not exist",
275 : var->varattno, get_rel_name(appinfo->parent_reloid));
276 261610 : newnode = copyObject(list_nth(appinfo->translated_vars,
277 : var->varattno - 1));
278 261610 : if (newnode == NULL)
279 0 : elog(ERROR, "attribute %d of relation \"%s\" does not exist",
280 : var->varattno, get_rel_name(appinfo->parent_reloid));
281 261610 : if (IsA(newnode, Var))
282 258246 : ((Var *) newnode)->varnullingrels = var->varnullingrels;
283 3364 : else if (var->varnullingrels != NULL)
284 0 : elog(ERROR, "failed to apply nullingrels to a non-Var");
285 261610 : return newnode;
286 : }
287 14630 : else if (var->varattno == 0)
288 : {
289 : /*
290 : * Whole-row Var: if we are dealing with named rowtypes, we
291 : * can use a whole-row Var for the child table plus a coercion
292 : * step to convert the tuple layout to the parent's rowtype.
293 : * Otherwise we have to generate a RowExpr.
294 : */
295 886 : if (OidIsValid(appinfo->child_reltype))
296 : {
297 : Assert(var->vartype == appinfo->parent_reltype);
298 830 : if (appinfo->parent_reltype != appinfo->child_reltype)
299 : {
300 686 : ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);
301 :
302 686 : r->arg = (Expr *) var;
303 686 : r->resulttype = appinfo->parent_reltype;
304 686 : r->convertformat = COERCE_IMPLICIT_CAST;
305 686 : r->location = -1;
306 : /* Make sure the Var node has the right type ID, too */
307 686 : var->vartype = appinfo->child_reltype;
308 686 : return (Node *) r;
309 : }
310 : }
311 : else
312 : {
313 : /*
314 : * Build a RowExpr containing the translated variables.
315 : *
316 : * In practice var->vartype will always be RECORDOID here,
317 : * so we need to come up with some suitable column names.
318 : * We use the parent RTE's column names.
319 : *
320 : * Note: we can't get here for inheritance cases, so there
321 : * is no need to worry that translated_vars might contain
322 : * some dummy NULLs.
323 : */
324 : RowExpr *rowexpr;
325 : List *fields;
326 : RangeTblEntry *rte;
327 :
328 56 : rte = rt_fetch(appinfo->parent_relid,
329 : context->root->parse->rtable);
330 56 : fields = copyObject(appinfo->translated_vars);
331 56 : rowexpr = makeNode(RowExpr);
332 56 : rowexpr->args = fields;
333 56 : rowexpr->row_typeid = var->vartype;
334 56 : rowexpr->row_format = COERCE_IMPLICIT_CAST;
335 56 : rowexpr->colnames = copyObject(rte->eref->colnames);
336 56 : rowexpr->location = -1;
337 :
338 56 : if (var->varnullingrels != NULL)
339 0 : elog(ERROR, "failed to apply nullingrels to a non-Var");
340 :
341 56 : return (Node *) rowexpr;
342 : }
343 : }
344 : /* system attributes don't need any other translation */
345 : }
346 51674 : else if (var->varno == ROWID_VAR)
347 : {
348 : /*
349 : * If it's a ROWID_VAR placeholder, see if we've reached a leaf
350 : * target rel, for which we can translate the Var to a specific
351 : * instantiation. We should never be asked to translate to a set
352 : * of relids containing more than one leaf target rel, so the
353 : * answer will be unique. If we're still considering non-leaf
354 : * inheritance levels, return the ROWID_VAR Var as-is.
355 : */
356 16702 : Relids leaf_result_relids = context->root->leaf_result_relids;
357 16702 : Index leaf_relid = 0;
358 :
359 33404 : for (cnt = 0; cnt < nappinfos; cnt++)
360 : {
361 16702 : if (bms_is_member(appinfos[cnt]->child_relid,
362 : leaf_result_relids))
363 : {
364 14654 : if (leaf_relid)
365 0 : elog(ERROR, "cannot translate to multiple leaf relids");
366 14654 : leaf_relid = appinfos[cnt]->child_relid;
367 : }
368 : }
369 :
370 16702 : if (leaf_relid)
371 : {
372 : RowIdentityVarInfo *ridinfo = (RowIdentityVarInfo *)
373 14654 : list_nth(context->root->row_identity_vars, var->varattno - 1);
374 :
375 14654 : if (bms_is_member(leaf_relid, ridinfo->rowidrels))
376 : {
377 : /* Substitute the Var given in the RowIdentityVarInfo */
378 14566 : var = copyObject(ridinfo->rowidvar);
379 : /* ... but use the correct relid */
380 14566 : var->varno = leaf_relid;
381 : /* identity vars shouldn't have nulling rels */
382 : Assert(var->varnullingrels == NULL);
383 : /* varnosyn in the RowIdentityVarInfo is probably wrong */
384 14566 : var->varnosyn = 0;
385 14566 : var->varattnosyn = 0;
386 : }
387 : else
388 : {
389 : /*
390 : * This leaf rel can't return the desired value, so
391 : * substitute a NULL of the correct type.
392 : */
393 88 : return (Node *) makeNullConst(var->vartype,
394 : var->vartypmod,
395 : var->varcollid);
396 : }
397 : }
398 : }
399 65474 : return (Node *) var;
400 : }
401 418804 : if (IsA(node, CurrentOfExpr))
402 : {
403 184 : CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node);
404 :
405 184 : for (cnt = 0; cnt < nappinfos; cnt++)
406 : {
407 184 : AppendRelInfo *appinfo = appinfos[cnt];
408 :
409 184 : if (cexpr->cvarno == appinfo->parent_relid)
410 : {
411 184 : cexpr->cvarno = appinfo->child_relid;
412 184 : break;
413 : }
414 : }
415 184 : return (Node *) cexpr;
416 : }
417 418620 : if (IsA(node, PlaceHolderVar))
418 : {
419 : /* Copy the PlaceHolderVar node with correct mutation of subnodes */
420 : PlaceHolderVar *phv;
421 :
422 2172 : phv = (PlaceHolderVar *) expression_tree_mutator(node,
423 : adjust_appendrel_attrs_mutator,
424 : (void *) context);
425 : /* now fix PlaceHolderVar's relid sets */
426 2172 : if (phv->phlevelsup == 0)
427 : {
428 2172 : phv->phrels = adjust_child_relids(phv->phrels,
429 : nappinfos, appinfos);
430 : /* as above, we needn't touch phnullingrels */
431 : }
432 2172 : return (Node *) phv;
433 : }
434 : /* Shouldn't need to handle planner auxiliary nodes here */
435 : Assert(!IsA(node, SpecialJoinInfo));
436 : Assert(!IsA(node, AppendRelInfo));
437 : Assert(!IsA(node, PlaceHolderInfo));
438 : Assert(!IsA(node, MinMaxAggInfo));
439 :
440 : /*
441 : * We have to process RestrictInfo nodes specially. (Note: although
442 : * set_append_rel_pathlist will hide RestrictInfos in the parent's
443 : * baserestrictinfo list from us, it doesn't hide those in joininfo.)
444 : */
445 416448 : if (IsA(node, RestrictInfo))
446 : {
447 33568 : RestrictInfo *oldinfo = (RestrictInfo *) node;
448 33568 : RestrictInfo *newinfo = makeNode(RestrictInfo);
449 :
450 : /* Copy all flat-copiable fields, notably including rinfo_serial */
451 33568 : memcpy(newinfo, oldinfo, sizeof(RestrictInfo));
452 :
453 : /* Recursively fix the clause itself */
454 33568 : newinfo->clause = (Expr *)
455 33568 : adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context);
456 :
457 : /* and the modified version, if an OR clause */
458 33568 : newinfo->orclause = (Expr *)
459 33568 : adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context);
460 :
461 : /* adjust relid sets too */
462 33568 : newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids,
463 : context->nappinfos,
464 : context->appinfos);
465 33568 : newinfo->required_relids = adjust_child_relids(oldinfo->required_relids,
466 : context->nappinfos,
467 : context->appinfos);
468 33568 : newinfo->outer_relids = adjust_child_relids(oldinfo->outer_relids,
469 : context->nappinfos,
470 : context->appinfos);
471 33568 : newinfo->left_relids = adjust_child_relids(oldinfo->left_relids,
472 : context->nappinfos,
473 : context->appinfos);
474 33568 : newinfo->right_relids = adjust_child_relids(oldinfo->right_relids,
475 : context->nappinfos,
476 : context->appinfos);
477 :
478 : /*
479 : * Reset cached derivative fields, since these might need to have
480 : * different values when considering the child relation. Note we
481 : * don't reset left_ec/right_ec: each child variable is implicitly
482 : * equivalent to its parent, so still a member of the same EC if any.
483 : */
484 33568 : newinfo->eval_cost.startup = -1;
485 33568 : newinfo->norm_selec = -1;
486 33568 : newinfo->outer_selec = -1;
487 33568 : newinfo->left_em = NULL;
488 33568 : newinfo->right_em = NULL;
489 33568 : newinfo->scansel_cache = NIL;
490 33568 : newinfo->left_bucketsize = -1;
491 33568 : newinfo->right_bucketsize = -1;
492 33568 : newinfo->left_mcvfreq = -1;
493 33568 : newinfo->right_mcvfreq = -1;
494 :
495 33568 : return (Node *) newinfo;
496 : }
497 :
498 : /*
499 : * NOTE: we do not need to recurse into sublinks, because they should
500 : * already have been converted to subplans before we see them.
501 : */
502 : Assert(!IsA(node, SubLink));
503 : Assert(!IsA(node, Query));
504 : /* We should never see these Query substructures, either. */
505 : Assert(!IsA(node, RangeTblRef));
506 : Assert(!IsA(node, JoinExpr));
507 :
508 382880 : return expression_tree_mutator(node, adjust_appendrel_attrs_mutator,
509 : (void *) context);
510 : }
511 :
512 : /*
513 : * adjust_appendrel_attrs_multilevel
514 : * Apply Var translations from an appendrel parent down to a child.
515 : *
516 : * Replace Vars in the "node" expression that reference "parentrel" with
517 : * the appropriate Vars for "childrel". childrel can be more than one
518 : * inheritance level removed from parentrel.
519 : */
520 : Node *
521 30536 : adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node,
522 : RelOptInfo *childrel,
523 : RelOptInfo *parentrel)
524 : {
525 : AppendRelInfo **appinfos;
526 : int nappinfos;
527 :
528 : /* Recurse if immediate parent is not the top parent. */
529 30536 : if (childrel->parent != parentrel)
530 : {
531 9088 : if (childrel->parent)
532 9088 : node = adjust_appendrel_attrs_multilevel(root, node,
533 9088 : childrel->parent,
534 : parentrel);
535 : else
536 0 : elog(ERROR, "childrel is not a child of parentrel");
537 : }
538 :
539 : /* Now translate for this child. */
540 30536 : appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
541 :
542 30536 : node = adjust_appendrel_attrs(root, node, nappinfos, appinfos);
543 :
544 30536 : pfree(appinfos);
545 :
546 30536 : return node;
547 : }
548 :
549 : /*
550 : * Substitute child relids for parent relids in a Relid set. The array of
551 : * appinfos specifies the substitutions to be performed.
552 : */
553 : Relids
554 197264 : adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos)
555 : {
556 197264 : Bitmapset *result = NULL;
557 : int cnt;
558 :
559 474580 : for (cnt = 0; cnt < nappinfos; cnt++)
560 : {
561 277316 : AppendRelInfo *appinfo = appinfos[cnt];
562 :
563 : /* Remove parent, add child */
564 277316 : if (bms_is_member(appinfo->parent_relid, relids))
565 : {
566 : /* Make a copy if we are changing the set. */
567 171378 : if (!result)
568 147372 : result = bms_copy(relids);
569 :
570 171378 : result = bms_del_member(result, appinfo->parent_relid);
571 171378 : result = bms_add_member(result, appinfo->child_relid);
572 : }
573 : }
574 :
575 : /* If we made any changes, return the modified copy. */
576 197264 : if (result)
577 147372 : return result;
578 :
579 : /* Otherwise, return the original set without modification. */
580 49892 : return relids;
581 : }
582 :
583 : /*
584 : * Substitute child's relids for parent's relids in a Relid set.
585 : * The childrel can be multiple inheritance levels below the parent.
586 : */
587 : Relids
588 8308 : adjust_child_relids_multilevel(PlannerInfo *root, Relids relids,
589 : RelOptInfo *childrel,
590 : RelOptInfo *parentrel)
591 : {
592 : AppendRelInfo **appinfos;
593 : int nappinfos;
594 :
595 : /*
596 : * If the given relids set doesn't contain any of the parent relids, it
597 : * will remain unchanged.
598 : */
599 8308 : if (!bms_overlap(relids, parentrel->relids))
600 0 : return relids;
601 :
602 : /* Recurse if immediate parent is not the top parent. */
603 8308 : if (childrel->parent != parentrel)
604 : {
605 144 : if (childrel->parent)
606 144 : relids = adjust_child_relids_multilevel(root, relids,
607 144 : childrel->parent,
608 : parentrel);
609 : else
610 0 : elog(ERROR, "childrel is not a child of parentrel");
611 : }
612 :
613 : /* Now translate for this child. */
614 8308 : appinfos = find_appinfos_by_relids(root, childrel->relids, &nappinfos);
615 :
616 8308 : relids = adjust_child_relids(relids, nappinfos, appinfos);
617 :
618 8308 : pfree(appinfos);
619 :
620 8308 : return relids;
621 : }
622 :
623 : /*
624 : * adjust_inherited_attnums
625 : * Translate an integer list of attribute numbers from parent to child.
626 : */
627 : List *
628 4378 : adjust_inherited_attnums(List *attnums, AppendRelInfo *context)
629 : {
630 4378 : List *result = NIL;
631 : ListCell *lc;
632 :
633 : /* This should only happen for an inheritance case, not UNION ALL */
634 : Assert(OidIsValid(context->parent_reloid));
635 :
636 : /* Look up each attribute in the AppendRelInfo's translated_vars list */
637 9572 : foreach(lc, attnums)
638 : {
639 5194 : AttrNumber parentattno = lfirst_int(lc);
640 : Var *childvar;
641 :
642 : /* Look up the translation of this column: it must be a Var */
643 10388 : if (parentattno <= 0 ||
644 5194 : parentattno > list_length(context->translated_vars))
645 0 : elog(ERROR, "attribute %d of relation \"%s\" does not exist",
646 : parentattno, get_rel_name(context->parent_reloid));
647 5194 : childvar = (Var *) list_nth(context->translated_vars, parentattno - 1);
648 5194 : if (childvar == NULL || !IsA(childvar, Var))
649 0 : elog(ERROR, "attribute %d of relation \"%s\" does not exist",
650 : parentattno, get_rel_name(context->parent_reloid));
651 :
652 5194 : result = lappend_int(result, childvar->varattno);
653 : }
654 4378 : return result;
655 : }
656 :
657 : /*
658 : * adjust_inherited_attnums_multilevel
659 : * As above, but traverse multiple inheritance levels as needed.
660 : */
661 : List *
662 4378 : adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums,
663 : Index child_relid, Index top_parent_relid)
664 : {
665 4378 : AppendRelInfo *appinfo = root->append_rel_array[child_relid];
666 :
667 4378 : if (!appinfo)
668 0 : elog(ERROR, "child rel %d not found in append_rel_array", child_relid);
669 :
670 : /* Recurse if immediate parent is not the top parent. */
671 4378 : if (appinfo->parent_relid != top_parent_relid)
672 790 : attnums = adjust_inherited_attnums_multilevel(root, attnums,
673 : appinfo->parent_relid,
674 : top_parent_relid);
675 :
676 : /* Now translate for this child */
677 4378 : return adjust_inherited_attnums(attnums, appinfo);
678 : }
679 :
680 : /*
681 : * get_translated_update_targetlist
682 : * Get the processed_tlist of an UPDATE query, translated as needed to
683 : * match a child target relation.
684 : *
685 : * Optionally also return the list of target column numbers translated
686 : * to this target relation. (The resnos in processed_tlist MUST NOT be
687 : * relied on for this purpose.)
688 : */
689 : void
690 100 : get_translated_update_targetlist(PlannerInfo *root, Index relid,
691 : List **processed_tlist, List **update_colnos)
692 : {
693 : /* This is pretty meaningless for commands other than UPDATE. */
694 : Assert(root->parse->commandType == CMD_UPDATE);
695 100 : if (relid == root->parse->resultRelation)
696 : {
697 : /*
698 : * Non-inheritance case, so it's easy. The caller might be expecting
699 : * a tree it can scribble on, though, so copy.
700 : */
701 66 : *processed_tlist = copyObject(root->processed_tlist);
702 66 : if (update_colnos)
703 66 : *update_colnos = copyObject(root->update_colnos);
704 : }
705 : else
706 : {
707 : Assert(bms_is_member(relid, root->all_result_relids));
708 34 : *processed_tlist = (List *)
709 34 : adjust_appendrel_attrs_multilevel(root,
710 34 : (Node *) root->processed_tlist,
711 : find_base_rel(root, relid),
712 34 : find_base_rel(root, root->parse->resultRelation));
713 34 : if (update_colnos)
714 34 : *update_colnos =
715 34 : adjust_inherited_attnums_multilevel(root, root->update_colnos,
716 : relid,
717 34 : root->parse->resultRelation);
718 : }
719 100 : }
720 :
721 : /*
722 : * find_appinfos_by_relids
723 : * Find AppendRelInfo structures for base relations listed in relids.
724 : *
725 : * The relids argument is typically a join relation's relids, which can
726 : * include outer-join RT indexes in addition to baserels. We silently
727 : * ignore the outer joins.
728 : *
729 : * The AppendRelInfos are returned in an array, which can be pfree'd by the
730 : * caller. *nappinfos is set to the number of entries in the array.
731 : */
732 : AppendRelInfo **
733 79382 : find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
734 : {
735 : AppendRelInfo **appinfos;
736 79382 : int cnt = 0;
737 : int i;
738 :
739 : /* Allocate an array that's certainly big enough */
740 : appinfos = (AppendRelInfo **)
741 79382 : palloc(sizeof(AppendRelInfo *) * bms_num_members(relids));
742 :
743 79382 : i = -1;
744 188912 : while ((i = bms_next_member(relids, i)) >= 0)
745 : {
746 109530 : AppendRelInfo *appinfo = root->append_rel_array[i];
747 :
748 109530 : if (!appinfo)
749 : {
750 : /* Probably i is an OJ index, but let's check */
751 9816 : if (find_base_rel_ignore_join(root, i) == NULL)
752 9816 : continue;
753 : /* It's a base rel, but we lack an append_rel_array entry */
754 0 : elog(ERROR, "child rel %d not found in append_rel_array", i);
755 : }
756 :
757 99714 : appinfos[cnt++] = appinfo;
758 : }
759 79382 : *nappinfos = cnt;
760 79382 : return appinfos;
761 : }
762 :
763 :
764 : /*****************************************************************************
765 : *
766 : * ROW-IDENTITY VARIABLE MANAGEMENT
767 : *
768 : * This code lacks a good home, perhaps. We choose to keep it here because
769 : * adjust_appendrel_attrs_mutator() is its principal co-conspirator. That
770 : * function does most of what is needed to expand ROWID_VAR Vars into the
771 : * right things.
772 : *
773 : *****************************************************************************/
774 :
775 : /*
776 : * add_row_identity_var
777 : * Register a row-identity column to be used in UPDATE/DELETE/MERGE.
778 : *
779 : * The Var must be equal(), aside from varno, to any other row-identity
780 : * column with the same rowid_name. Thus, for example, "wholerow"
781 : * row identities had better use vartype == RECORDOID.
782 : *
783 : * rtindex is currently redundant with rowid_var->varno, but we specify
784 : * it as a separate parameter in case this is ever generalized to support
785 : * non-Var expressions. (We could reasonably handle expressions over
786 : * Vars of the specified rtindex, but for now that seems unnecessary.)
787 : */
788 : void
789 27466 : add_row_identity_var(PlannerInfo *root, Var *orig_var,
790 : Index rtindex, const char *rowid_name)
791 : {
792 : TargetEntry *tle;
793 : Var *rowid_var;
794 : RowIdentityVarInfo *ridinfo;
795 : ListCell *lc;
796 :
797 : /* For now, the argument must be just a Var of the given rtindex */
798 : Assert(IsA(orig_var, Var));
799 : Assert(orig_var->varno == rtindex);
800 : Assert(orig_var->varlevelsup == 0);
801 : Assert(orig_var->varnullingrels == NULL);
802 :
803 : /*
804 : * If we're doing non-inherited UPDATE/DELETE/MERGE, there's little need
805 : * for ROWID_VAR shenanigans. Just shove the presented Var into the
806 : * processed_tlist, and we're done.
807 : */
808 27466 : if (rtindex == root->parse->resultRelation)
809 : {
810 18268 : tle = makeTargetEntry((Expr *) orig_var,
811 18268 : list_length(root->processed_tlist) + 1,
812 : pstrdup(rowid_name),
813 : true);
814 18268 : root->processed_tlist = lappend(root->processed_tlist, tle);
815 18268 : return;
816 : }
817 :
818 : /*
819 : * Otherwise, rtindex should reference a leaf target relation that's being
820 : * added to the query during expand_inherited_rtentry().
821 : */
822 : Assert(bms_is_member(rtindex, root->leaf_result_relids));
823 : Assert(root->append_rel_array[rtindex] != NULL);
824 :
825 : /*
826 : * We have to find a matching RowIdentityVarInfo, or make one if there is
827 : * none. To allow using equal() to match the vars, change the varno to
828 : * ROWID_VAR, leaving all else alone.
829 : */
830 9198 : rowid_var = copyObject(orig_var);
831 : /* This could eventually become ChangeVarNodes() */
832 9198 : rowid_var->varno = ROWID_VAR;
833 :
834 : /* Look for an existing row-id column of the same name */
835 13912 : foreach(lc, root->row_identity_vars)
836 : {
837 9198 : ridinfo = (RowIdentityVarInfo *) lfirst(lc);
838 9198 : if (strcmp(rowid_name, ridinfo->rowidname) != 0)
839 4714 : continue;
840 4484 : if (equal(rowid_var, ridinfo->rowidvar))
841 : {
842 : /* Found a match; we need only record that rtindex needs it too */
843 4484 : ridinfo->rowidrels = bms_add_member(ridinfo->rowidrels, rtindex);
844 4484 : return;
845 : }
846 : else
847 : {
848 : /* Ooops, can't handle this */
849 0 : elog(ERROR, "conflicting uses of row-identity name \"%s\"",
850 : rowid_name);
851 : }
852 : }
853 :
854 : /* No request yet, so add a new RowIdentityVarInfo */
855 4714 : ridinfo = makeNode(RowIdentityVarInfo);
856 4714 : ridinfo->rowidvar = copyObject(rowid_var);
857 : /* for the moment, estimate width using just the datatype info */
858 4714 : ridinfo->rowidwidth = get_typavgwidth(exprType((Node *) rowid_var),
859 : exprTypmod((Node *) rowid_var));
860 4714 : ridinfo->rowidname = pstrdup(rowid_name);
861 4714 : ridinfo->rowidrels = bms_make_singleton(rtindex);
862 :
863 4714 : root->row_identity_vars = lappend(root->row_identity_vars, ridinfo);
864 :
865 : /* Change rowid_var into a reference to this row_identity_vars entry */
866 4714 : rowid_var->varattno = list_length(root->row_identity_vars);
867 :
868 : /* Push the ROWID_VAR reference variable into processed_tlist */
869 4714 : tle = makeTargetEntry((Expr *) rowid_var,
870 4714 : list_length(root->processed_tlist) + 1,
871 : pstrdup(rowid_name),
872 : true);
873 4714 : root->processed_tlist = lappend(root->processed_tlist, tle);
874 : }
875 :
876 : /*
877 : * add_row_identity_columns
878 : *
879 : * This function adds the row identity columns needed by the core code.
880 : * FDWs might call add_row_identity_var() for themselves to add nonstandard
881 : * columns. (Duplicate requests are fine.)
882 : */
883 : void
884 22900 : add_row_identity_columns(PlannerInfo *root, Index rtindex,
885 : RangeTblEntry *target_rte,
886 : Relation target_relation)
887 : {
888 22900 : CmdType commandType = root->parse->commandType;
889 22900 : char relkind = target_relation->rd_rel->relkind;
890 : Var *var;
891 :
892 : Assert(commandType == CMD_UPDATE || commandType == CMD_DELETE || commandType == CMD_MERGE);
893 :
894 22900 : if (commandType == CMD_MERGE ||
895 630 : relkind == RELKIND_RELATION ||
896 570 : relkind == RELKIND_MATVIEW ||
897 : relkind == RELKIND_PARTITIONED_TABLE)
898 : {
899 : /*
900 : * Emit CTID so that executor can find the row to merge, update or
901 : * delete.
902 : */
903 22354 : var = makeVar(rtindex,
904 : SelfItemPointerAttributeNumber,
905 : TIDOID,
906 : -1,
907 : InvalidOid,
908 : 0);
909 22354 : add_row_identity_var(root, var, rtindex, "ctid");
910 : }
911 546 : else if (relkind == RELKIND_FOREIGN_TABLE)
912 : {
913 : /*
914 : * Let the foreign table's FDW add whatever junk TLEs it wants.
915 : */
916 : FdwRoutine *fdwroutine;
917 :
918 348 : fdwroutine = GetFdwRoutineForRelation(target_relation, false);
919 :
920 348 : if (fdwroutine->AddForeignUpdateTargets != NULL)
921 340 : fdwroutine->AddForeignUpdateTargets(root, rtindex,
922 : target_rte, target_relation);
923 :
924 : /*
925 : * For UPDATE, we need to make the FDW fetch unchanged columns by
926 : * asking it to fetch a whole-row Var. That's because the top-level
927 : * targetlist only contains entries for changed columns, but
928 : * ExecUpdate will need to build the complete new tuple. (Actually,
929 : * we only really need this in UPDATEs that are not pushed to the
930 : * remote side, but it's hard to tell if that will be the case at the
931 : * point when this function is called.)
932 : *
933 : * We will also need the whole row if there are any row triggers, so
934 : * that the executor will have the "old" row to pass to the trigger.
935 : * Alas, this misses system columns.
936 : */
937 348 : if (commandType == CMD_UPDATE ||
938 154 : (target_relation->trigdesc &&
939 30 : (target_relation->trigdesc->trig_delete_after_row ||
940 18 : target_relation->trigdesc->trig_delete_before_row)))
941 : {
942 210 : var = makeVar(rtindex,
943 : InvalidAttrNumber,
944 : RECORDOID,
945 : -1,
946 : InvalidOid,
947 : 0);
948 210 : add_row_identity_var(root, var, rtindex, "wholerow");
949 : }
950 : }
951 22900 : }
952 :
953 : /*
954 : * distribute_row_identity_vars
955 : *
956 : * After we have finished identifying all the row identity columns
957 : * needed by an inherited UPDATE/DELETE/MERGE query, make sure that
958 : * these columns will be generated by all the target relations.
959 : *
960 : * This is more or less like what build_base_rel_tlists() does,
961 : * except that it would not understand what to do with ROWID_VAR Vars.
962 : * Since that function runs before inheritance relations are expanded,
963 : * it will never see any such Vars anyway.
964 : */
965 : void
966 254854 : distribute_row_identity_vars(PlannerInfo *root)
967 : {
968 254854 : Query *parse = root->parse;
969 254854 : int result_relation = parse->resultRelation;
970 : RangeTblEntry *target_rte;
971 : RelOptInfo *target_rel;
972 : ListCell *lc;
973 :
974 : /*
975 : * There's nothing to do if this isn't an inherited UPDATE/DELETE/MERGE.
976 : */
977 254854 : if (parse->commandType != CMD_UPDATE && parse->commandType != CMD_DELETE &&
978 235126 : parse->commandType != CMD_MERGE)
979 : {
980 : Assert(root->row_identity_vars == NIL);
981 234196 : return;
982 : }
983 20658 : target_rte = rt_fetch(result_relation, parse->rtable);
984 20658 : if (!target_rte->inh)
985 : {
986 : Assert(root->row_identity_vars == NIL);
987 18308 : return;
988 : }
989 :
990 : /*
991 : * Ordinarily, we expect that leaf result relation(s) will have added some
992 : * ROWID_VAR Vars to the query. However, it's possible that constraint
993 : * exclusion suppressed every leaf relation. The executor will get upset
994 : * if the plan has no row identity columns at all, even though it will
995 : * certainly process no rows. Handle this edge case by re-opening the top
996 : * result relation and adding the row identity columns it would have used,
997 : * as preprocess_targetlist() would have done if it weren't marked "inh".
998 : * Then re-run build_base_rel_tlists() to ensure that the added columns
999 : * get propagated to the relation's reltarget. (This is a bit ugly, but
1000 : * it seems better to confine the ugliness and extra cycles to this
1001 : * unusual corner case.)
1002 : */
1003 2350 : if (root->row_identity_vars == NIL)
1004 : {
1005 : Relation target_relation;
1006 :
1007 30 : target_relation = table_open(target_rte->relid, NoLock);
1008 30 : add_row_identity_columns(root, result_relation,
1009 : target_rte, target_relation);
1010 30 : table_close(target_relation, NoLock);
1011 30 : build_base_rel_tlists(root, root->processed_tlist);
1012 : /* There are no ROWID_VAR Vars in this case, so we're done. */
1013 30 : return;
1014 : }
1015 :
1016 : /*
1017 : * Dig through the processed_tlist to find the ROWID_VAR reference Vars,
1018 : * and forcibly copy them into the reltarget list of the topmost target
1019 : * relation. That's sufficient because they'll be copied to the
1020 : * individual leaf target rels (with appropriate translation) later,
1021 : * during appendrel expansion --- see set_append_rel_size().
1022 : */
1023 2320 : target_rel = find_base_rel(root, result_relation);
1024 :
1025 9590 : foreach(lc, root->processed_tlist)
1026 : {
1027 7270 : TargetEntry *tle = lfirst(lc);
1028 7270 : Var *var = (Var *) tle->expr;
1029 :
1030 7270 : if (var && IsA(var, Var) && var->varno == ROWID_VAR)
1031 : {
1032 4714 : target_rel->reltarget->exprs =
1033 4714 : lappend(target_rel->reltarget->exprs, copyObject(var));
1034 : /* reltarget cost and width will be computed later */
1035 : }
1036 : }
1037 : }
|
