Debian Codegraph @

src/backend/optimizer/util/inherit.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * inherit.c
4 * Routines to process child relations in inheritance trees
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/optimizer/util/inherit.c
12 *
13 *-------------------------------------------------------------------------
14 */
15 #include "postgres.h"
16
17 #include "access/sysattr.h"
18 #include "access/table.h"
19 #include "catalog/partition.h"
20 #include "catalog/pg_inherits.h"
21 #include "catalog/pg_type.h"
22 #include "miscadmin.h"
23 #include "nodes/makefuncs.h"
24 #include "optimizer/appendinfo.h"
25 #include "optimizer/inherit.h"
26 #include "optimizer/optimizer.h"
27 #include "optimizer/pathnode.h"
28 #include "optimizer/plancat.h"
29 #include "optimizer/planmain.h"
30 #include "optimizer/planner.h"
31 #include "optimizer/prep.h"
32 #include "optimizer/restrictinfo.h"
33 #include "parser/parsetree.h"
34 #include "parser/parse_relation.h"
35 #include "partitioning/partdesc.h"
36 #include "partitioning/partprune.h"
37 #include "utils/rel.h"
38
39
40 static void expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo,
41 RangeTblEntry *parentrte,
42 Index parentRTindex, Relation parentrel,
43 Bitmapset *parent_updatedCols,
44 PlanRowMark *top_parentrc, LOCKMODE lockmode);
45 static void expand_single_inheritance_child(PlannerInfo *root,
46 RangeTblEntry *parentrte,
47 Index parentRTindex, Relation parentrel,
48 PlanRowMark *top_parentrc, Relation childrel,
49 RangeTblEntry **childrte_p,
50 Index *childRTindex_p);
51 static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
52 List *translated_vars);
53 static Bitmapset *translate_col_privs_multilevel(PlannerInfo *root,
54 RelOptInfo *rel,
55 RelOptInfo *parent_rel,
56 Bitmapset *parent_cols);
57 static void expand_appendrel_subquery(PlannerInfo *root, RelOptInfo *rel,
58 RangeTblEntry *rte, Index rti);
59
60
61 /*
62 * expand_inherited_rtentry
63 * Expand a rangetable entry that has the "inh" bit set.
64 *
65 * "inh" is only allowed in two cases: RELATION and SUBQUERY RTEs.
66 *
67 * "inh" on a plain RELATION RTE means that it is a partitioned table or the
68 * parent of a traditional-inheritance set. In this case we must add entries
69 * for all the interesting child tables to the query's rangetable, and build
70 * additional planner data structures for them, including RelOptInfos,
71 * AppendRelInfos, and possibly PlanRowMarks.
72 *
73 * Note that the original RTE is considered to represent the whole inheritance
74 * set. In the case of traditional inheritance, the first of the generated
75 * RTEs is an RTE for the same table, but with inh = false, to represent the
76 * parent table in its role as a simple member of the inheritance set. For
77 * partitioning, we don't need a second RTE because the partitioned table
78 * itself has no data and need not be scanned.
79 *
80 * "inh" on a SUBQUERY RTE means that it's the parent of a UNION ALL group,
81 * which is treated as an appendrel similarly to inheritance cases; however,
82 * we already made RTEs and AppendRelInfos for the subqueries. We only need
83 * to build RelOptInfos for them, which is done by expand_appendrel_subquery.
84 */
85 void
86 expand_inherited_rtentry(PlannerInfo *root, RelOptInfo *rel,
87 RangeTblEntry *rte, Index rti)
88 {
89 Oid parentOID;
90 Relation oldrelation;
91 LOCKMODE lockmode;
92 PlanRowMark *oldrc;
93 bool old_isParent = false;
94 int old_allMarkTypes = 0;
95
96 Assert(rte->inh); /* else caller error */
97
98 if (rte->rtekind == RTE_SUBQUERY)
99 {
100 expand_appendrel_subquery(root, rel, rte, rti);
101 return;
102 }
103
104 Assert(rte->rtekind == RTE_RELATION);
105
106 parentOID = rte->relid;
107
108 /*
109 * We used to check has_subclass() here, but there's no longer any need
110 * to, because subquery_planner already did.
111 */
112
113 /*
114 * The rewriter should already have obtained an appropriate lock on each
115 * relation named in the query, so we can open the parent relation without
116 * locking it. However, for each child relation we add to the query, we
117 * must obtain an appropriate lock, because this will be the first use of
118 * those relations in the parse/rewrite/plan pipeline. Child rels should
119 * use the same lockmode as their parent.
120 */
121 oldrelation = table_open(parentOID, NoLock);
122 lockmode = rte->rellockmode;
123
124 /*
125 * If parent relation is selected FOR UPDATE/SHARE, we need to mark its
126 * PlanRowMark as isParent = true, and generate a new PlanRowMark for each
127 * child.
128 */
129 oldrc = get_plan_rowmark(root->rowMarks, rti);
130 if (oldrc)
131 {
132 old_isParent = oldrc->isParent;
133 oldrc->isParent = true;
134 /* Save initial value of allMarkTypes before children add to it */
135 old_allMarkTypes = oldrc->allMarkTypes;
136 }
137
138 /* Scan the inheritance set and expand it */
139 if (oldrelation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
140 {
141 RTEPermissionInfo *perminfo;
142
143 perminfo = getRTEPermissionInfo(root->parse->rteperminfos, rte);
144
145 /*
146 * Partitioned table, so set up for partitioning.
147 */
148 Assert(rte->relkind == RELKIND_PARTITIONED_TABLE);
149
150 /*
151 * Recursively expand and lock the partitions. While at it, also
152 * extract the partition key columns of all the partitioned tables.
153 */
154 expand_partitioned_rtentry(root, rel, rte, rti,
155 oldrelation,
156 perminfo->updatedCols,
157 oldrc, lockmode);
158 }
159 else
160 {
161 /*
162 * Ordinary table, so process traditional-inheritance children. (Note
163 * that partitioned tables are not allowed to have inheritance
164 * children, so it's not possible for both cases to apply.)
165 */
166 List *inhOIDs;
167 ListCell *l;
168
169 /* Scan for all members of inheritance set, acquire needed locks */
170 inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
171
172 /*
173 * We used to special-case the situation where the table no longer has
174 * any children, by clearing rte->inh and exiting. That no longer
175 * works, because this function doesn't get run until after decisions
176 * have been made that depend on rte->inh. We have to treat such
177 * situations as normal inheritance. The table itself should always
178 * have been found, though.
179 */
180 Assert(inhOIDs != NIL);
181 Assert(linitial_oid(inhOIDs) == parentOID);
182
183 /* Expand simple_rel_array and friends to hold child objects. */
184 expand_planner_arrays(root, list_length(inhOIDs));
185
186 /*
187 * Expand inheritance children in the order the OIDs were returned by
188 * find_all_inheritors.
189 */
190 foreach(l, inhOIDs)
191 {
192 Oid childOID = lfirst_oid(l);
193 Relation newrelation;
194 RangeTblEntry *childrte;
195 Index childRTindex;
196
197 /* Open rel if needed; we already have required locks */
198 if (childOID != parentOID)
199 newrelation = table_open(childOID, NoLock);
200 else
201 newrelation = oldrelation;
202
203 /*
204 * It is possible that the parent table has children that are temp
205 * tables of other backends. We cannot safely access such tables
206 * (because of buffering issues), and the best thing to do seems
207 * to be to silently ignore them.
208 */
209 if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation))
210 {
211 table_close(newrelation, lockmode);
212 continue;
213 }
214
215 /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
216 expand_single_inheritance_child(root, rte, rti, oldrelation,
217 oldrc, newrelation,
218 &childrte, &childRTindex);
219
220 /* Create the otherrel RelOptInfo too. */
221 (void) build_simple_rel(root, childRTindex, rel);
222
223 /* Close child relations, but keep locks */
224 if (childOID != parentOID)
225 table_close(newrelation, NoLock);
226 }
227 }
228
229 /*
230 * Some children might require different mark types, which would've been
231 * reported into oldrc. If so, add relevant entries to the top-level
232 * targetlist and update parent rel's reltarget. This should match what
233 * preprocess_targetlist() would have added if the mark types had been
234 * requested originally.
235 *
236 * (Someday it might be useful to fold these resjunk columns into the
237 * row-identity-column management used for UPDATE/DELETE. Today is not
238 * that day, however.)
239 */
240 if (oldrc)
241 {
242 int new_allMarkTypes = oldrc->allMarkTypes;
243 Var *var;
244 TargetEntry *tle;
245 char resname[32];
246 List *newvars = NIL;
247
248 /* Add TID junk Var if needed, unless we had it already */
249 if (new_allMarkTypes & ~(1 << ROW_MARK_COPY) &&
250 !(old_allMarkTypes & ~(1 << ROW_MARK_COPY)))
251 {
252 /* Need to fetch TID */
253 var = makeVar(oldrc->rti,
254 SelfItemPointerAttributeNumber,
255 TIDOID,
256 -1,
257 InvalidOid,
258 0);
259 snprintf(resname, sizeof(resname), "ctid%u", oldrc->rowmarkId);
260 tle = makeTargetEntry((Expr *) var,
261 list_length(root->processed_tlist) + 1,
262 pstrdup(resname),
263 true);
264 root->processed_tlist = lappend(root->processed_tlist, tle);
265 newvars = lappend(newvars, var);
266 }
267
268 /* Add whole-row junk Var if needed, unless we had it already */
269 if ((new_allMarkTypes & (1 << ROW_MARK_COPY)) &&
270 !(old_allMarkTypes & (1 << ROW_MARK_COPY)))
271 {
272 var = makeWholeRowVar(planner_rt_fetch(oldrc->rti, root),
273 oldrc->rti,
274 0,
275 false);
276 snprintf(resname, sizeof(resname), "wholerow%u", oldrc->rowmarkId);
277 tle = makeTargetEntry((Expr *) var,
278 list_length(root->processed_tlist) + 1,
279 pstrdup(resname),
280 true);
281 root->processed_tlist = lappend(root->processed_tlist, tle);
282 newvars = lappend(newvars, var);
283 }
284
285 /* Add tableoid junk Var, unless we had it already */
286 if (!old_isParent)
287 {
288 var = makeVar(oldrc->rti,
289 TableOidAttributeNumber,
290 OIDOID,
291 -1,
292 InvalidOid,
293 0);
294 snprintf(resname, sizeof(resname), "tableoid%u", oldrc->rowmarkId);
295 tle = makeTargetEntry((Expr *) var,
296 list_length(root->processed_tlist) + 1,
297 pstrdup(resname),
298 true);
299 root->processed_tlist = lappend(root->processed_tlist, tle);
300 newvars = lappend(newvars, var);
301 }
302
303 /*
304 * Add the newly added Vars to parent's reltarget. We needn't worry
305 * about the children's reltargets, they'll be made later.
306 */
307 add_vars_to_targetlist(root, newvars, bms_make_singleton(0));
308 }
309
310 table_close(oldrelation, NoLock);
311 }
312
313 /*
314 * expand_partitioned_rtentry
315 * Recursively expand an RTE for a partitioned table.
316 */
317 static void
318 expand_partitioned_rtentry(PlannerInfo *root, RelOptInfo *relinfo,
319 RangeTblEntry *parentrte,
320 Index parentRTindex, Relation parentrel,
321 Bitmapset *parent_updatedCols,
322 PlanRowMark *top_parentrc, LOCKMODE lockmode)
323 {
324 PartitionDesc partdesc;
325 int num_live_parts;
326 int i;
327
328 check_stack_depth();
329
330 Assert(parentrte->inh);
331
332 partdesc = PartitionDirectoryLookup(root->glob->partition_directory,
333 parentrel);
334
335 /* A partitioned table should always have a partition descriptor. */
336 Assert(partdesc);
337
338 /*
339 * Note down whether any partition key cols are being updated. Though it's
340 * the root partitioned table's updatedCols we are interested in,
341 * parent_updatedCols provided by the caller contains the root partrel's
342 * updatedCols translated to match the attribute ordering of parentrel.
343 */
344 if (!root->partColsUpdated)
345 root->partColsUpdated =
346 has_partition_attrs(parentrel, parent_updatedCols, NULL);
347
348 /* Nothing further to do here if there are no partitions. */
349 if (partdesc->nparts == 0)
350 return;
351
352 /*
353 * Perform partition pruning using restriction clauses assigned to parent
354 * relation. live_parts will contain PartitionDesc indexes of partitions
355 * that survive pruning. Below, we will initialize child objects for the
356 * surviving partitions.
357 */
358 relinfo->live_parts = prune_append_rel_partitions(relinfo);
359
360 /* Expand simple_rel_array and friends to hold child objects. */
361 num_live_parts = bms_num_members(relinfo->live_parts);
362 if (num_live_parts > 0)
363 expand_planner_arrays(root, num_live_parts);
364
365 /*
366 * We also store partition RelOptInfo pointers in the parent relation.
367 * Since we're palloc0'ing, slots corresponding to pruned partitions will
368 * contain NULL.
369 */
370 Assert(relinfo->part_rels == NULL);
371 relinfo->part_rels = (RelOptInfo **)
372 palloc0(relinfo->nparts * sizeof(RelOptInfo *));
373
374 /*
375 * Create a child RTE for each live partition. Note that unlike
376 * traditional inheritance, we don't need a child RTE for the partitioned
377 * table itself, because it's not going to be scanned.
378 */
379 i = -1;
380 while ((i = bms_next_member(relinfo->live_parts, i)) >= 0)
381 {
382 Oid childOID = partdesc->oids[i];
383 Relation childrel;
384 RangeTblEntry *childrte;
385 Index childRTindex;
386 RelOptInfo *childrelinfo;
387
388 /*
389 * Open rel, acquiring required locks. If a partition was recently
390 * detached and subsequently dropped, then opening it will fail. In
391 * this case, behave as though the partition had been pruned.
392 */
393 childrel = try_table_open(childOID, lockmode);
394 if (childrel == NULL)
395 {
396 relinfo->live_parts = bms_del_member(relinfo->live_parts, i);
397 continue;
398 }
399
400 /*
401 * Temporary partitions belonging to other sessions should have been
402 * disallowed at definition, but for paranoia's sake, let's double
403 * check.
404 */
405 if (RELATION_IS_OTHER_TEMP(childrel))
406 elog(ERROR, "temporary relation from another session found as partition");
407
408 /* Create RTE and AppendRelInfo, plus PlanRowMark if needed. */
409 expand_single_inheritance_child(root, parentrte, parentRTindex,
410 parentrel, top_parentrc, childrel,
411 &childrte, &childRTindex);
412
413 /* Create the otherrel RelOptInfo too. */
414 childrelinfo = build_simple_rel(root, childRTindex, relinfo);
415 relinfo->part_rels[i] = childrelinfo;
416 relinfo->all_partrels = bms_add_members(relinfo->all_partrels,
417 childrelinfo->relids);
418
419 /* If this child is itself partitioned, recurse */
420 if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
421 {
422 AppendRelInfo *appinfo = root->append_rel_array[childRTindex];
423 Bitmapset *child_updatedCols;
424
425 child_updatedCols = translate_col_privs(parent_updatedCols,
426 appinfo->translated_vars);
427
428 expand_partitioned_rtentry(root, childrelinfo,
429 childrte, childRTindex,
430 childrel,
431 child_updatedCols,
432 top_parentrc, lockmode);
433 }
434
435 /* Close child relation, but keep locks */
436 table_close(childrel, NoLock);
437 }
438 }
439
440 /*
441 * expand_single_inheritance_child
442 * Build a RangeTblEntry and an AppendRelInfo, plus maybe a PlanRowMark.
443 *
444 * We now expand the partition hierarchy level by level, creating a
445 * corresponding hierarchy of AppendRelInfos and RelOptInfos, where each
446 * partitioned descendant acts as a parent of its immediate partitions.
447 * (This is a difference from what older versions of PostgreSQL did and what
448 * is still done in the case of table inheritance for unpartitioned tables,
449 * where the hierarchy is flattened during RTE expansion.)
450 *
451 * PlanRowMarks still carry the top-parent's RTI, and the top-parent's
452 * allMarkTypes field still accumulates values from all descendents.
453 *
454 * "parentrte" and "parentRTindex" are immediate parent's RTE and
455 * RTI. "top_parentrc" is top parent's PlanRowMark.
456 *
457 * The child RangeTblEntry and its RTI are returned in "childrte_p" and
458 * "childRTindex_p" resp.
459 */
460 static void
461 expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte,
462 Index parentRTindex, Relation parentrel,
463 PlanRowMark *top_parentrc, Relation childrel,
464 RangeTblEntry **childrte_p,
465 Index *childRTindex_p)
466 {
467 Query *parse = root->parse;
468 Oid parentOID PG_USED_FOR_ASSERTS_ONLY =
469 RelationGetRelid(parentrel);
470 Oid childOID = RelationGetRelid(childrel);
471 RangeTblEntry *childrte;
472 Index childRTindex;
473 AppendRelInfo *appinfo;
474 TupleDesc child_tupdesc;
475 List *parent_colnames;
476 List *child_colnames;
477
478 /*
479 * Build an RTE for the child, and attach to query's rangetable list. We
480 * copy most scalar fields of the parent's RTE, but replace relation OID,
481 * relkind, and inh for the child. Set the child's securityQuals to
482 * empty, because we only want to apply the parent's RLS conditions
483 * regardless of what RLS properties individual children may have. (This
484 * is an intentional choice to make inherited RLS work like regular
485 * permissions checks.) The parent securityQuals will be propagated to
486 * children along with other base restriction clauses, so we don't need to
487 * do it here. Other infrastructure of the parent RTE has to be
488 * translated to match the child table's column ordering, which we do
489 * below, so a "flat" copy is sufficient to start with.
490 */
491 childrte = makeNode(RangeTblEntry);
492 memcpy(childrte, parentrte, sizeof(RangeTblEntry));
493 Assert(parentrte->rtekind == RTE_RELATION); /* else this is dubious */
494 childrte->relid = childOID;
495 childrte->relkind = childrel->rd_rel->relkind;
496 /* A partitioned child will need to be expanded further. */
497 if (childrte->relkind == RELKIND_PARTITIONED_TABLE)
498 {
499 Assert(childOID != parentOID);
500 childrte->inh = true;
501 }
502 else
503 childrte->inh = false;
504 childrte->securityQuals = NIL;
505
506 /* No permission checking for child RTEs. */
507 childrte->perminfoindex = 0;
508
509 /* Link not-yet-fully-filled child RTE into data structures */
510 parse->rtable = lappend(parse->rtable, childrte);
511 childRTindex = list_length(parse->rtable);
512 *childrte_p = childrte;
513 *childRTindex_p = childRTindex;
514
515 /*
516 * Build an AppendRelInfo struct for each parent/child pair.
517 */
518 appinfo = make_append_rel_info(parentrel, childrel,
519 parentRTindex, childRTindex);
520 root->append_rel_list = lappend(root->append_rel_list, appinfo);
521
522 /* tablesample is probably null, but copy it */
523 childrte->tablesample = copyObject(parentrte->tablesample);
524
525 /*
526 * Construct an alias clause for the child, which we can also use as eref.
527 * This is important so that EXPLAIN will print the right column aliases
528 * for child-table columns. (Since ruleutils.c doesn't have any easy way
529 * to reassociate parent and child columns, we must get the child column
530 * aliases right to start with. Note that setting childrte->alias forces
531 * ruleutils.c to use these column names, which it otherwise would not.)
532 */
533 child_tupdesc = RelationGetDescr(childrel);
534 parent_colnames = parentrte->eref->colnames;
535 child_colnames = NIL;
536 for (int cattno = 0; cattno < child_tupdesc->natts; cattno++)
537 {
538 Form_pg_attribute att = TupleDescAttr(child_tupdesc, cattno);
539 const char *attname;
540
541 if (att->attisdropped)
542 {
543 /* Always insert an empty string for a dropped column */
544 attname = "";
545 }
546 else if (appinfo->parent_colnos[cattno] > 0 &&
547 appinfo->parent_colnos[cattno] <= list_length(parent_colnames))
548 {
549 /* Duplicate the query-assigned name for the parent column */
550 attname = strVal(list_nth(parent_colnames,
551 appinfo->parent_colnos[cattno] - 1));
552 }
553 else
554 {
555 /* New column, just use its real name */
556 attname = NameStr(att->attname);
557 }
558 child_colnames = lappend(child_colnames, makeString(pstrdup(attname)));
559 }
560
561 /*
562 * We just duplicate the parent's table alias name for each child. If the
563 * plan gets printed, ruleutils.c has to sort out unique table aliases to
564 * use, which it can handle.
565 */
566 childrte->alias = childrte->eref = makeAlias(parentrte->eref->aliasname,
567 child_colnames);
568
569 /*
570 * Store the RTE and appinfo in the respective PlannerInfo arrays, which
571 * the caller must already have allocated space for.
572 */
573 Assert(childRTindex < root->simple_rel_array_size);
574 Assert(root->simple_rte_array[childRTindex] == NULL);
575 root->simple_rte_array[childRTindex] = childrte;
576 Assert(root->append_rel_array[childRTindex] == NULL);
577 root->append_rel_array[childRTindex] = appinfo;
578
579 /*
580 * Build a PlanRowMark if parent is marked FOR UPDATE/SHARE.
581 */
582 if (top_parentrc)
583 {
584 PlanRowMark *childrc = makeNode(PlanRowMark);
585
586 childrc->rti = childRTindex;
587 childrc->prti = top_parentrc->rti;
588 childrc->rowmarkId = top_parentrc->rowmarkId;
589 /* Reselect rowmark type, because relkind might not match parent */
590 childrc->markType = select_rowmark_type(childrte,
591 top_parentrc->strength);
592 childrc->allMarkTypes = (1 << childrc->markType);
593 childrc->strength = top_parentrc->strength;
594 childrc->waitPolicy = top_parentrc->waitPolicy;
595
596 /*
597 * We mark RowMarks for partitioned child tables as parent RowMarks so
598 * that the executor ignores them (except their existence means that
599 * the child tables will be locked using the appropriate mode).
600 */
601 childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE);
602
603 /* Include child's rowmark type in top parent's allMarkTypes */
604 top_parentrc->allMarkTypes |= childrc->allMarkTypes;
605
606 root->rowMarks = lappend(root->rowMarks, childrc);
607 }
608
609 /*
610 * If we are creating a child of the query target relation (only possible
611 * in UPDATE/DELETE/MERGE), add it to all_result_relids, as well as
612 * leaf_result_relids if appropriate, and make sure that we generate
613 * required row-identity data.
614 */
615 if (bms_is_member(parentRTindex, root->all_result_relids))
616 {
617 /* OK, record the child as a result rel too. */
618 root->all_result_relids = bms_add_member(root->all_result_relids,
619 childRTindex);
620
621 /* Non-leaf partitions don't need any row identity info. */
622 if (childrte->relkind != RELKIND_PARTITIONED_TABLE)
623 {
624 Var *rrvar;
625
626 root->leaf_result_relids = bms_add_member(root->leaf_result_relids,
627 childRTindex);
628
629 /*
630 * If we have any child target relations, assume they all need to
631 * generate a junk "tableoid" column. (If only one child survives
632 * pruning, we wouldn't really need this, but it's not worth
633 * thrashing about to avoid it.)
634 */
635 rrvar = makeVar(childRTindex,
636 TableOidAttributeNumber,
637 OIDOID,
638 -1,
639 InvalidOid,
640 0);
641 add_row_identity_var(root, rrvar, childRTindex, "tableoid");
642
643 /* Register any row-identity columns needed by this child. */
644 add_row_identity_columns(root, childRTindex,
645 childrte, childrel);
646 }
647 }
648 }
649
650 /*
651 * get_rel_all_updated_cols
652 * Returns the set of columns of a given "simple" relation that are
653 * updated by this query.
654 */
655 Bitmapset *
656 get_rel_all_updated_cols(PlannerInfo *root, RelOptInfo *rel)
657 {
658 Index relid;
659 RangeTblEntry *rte;
660 RTEPermissionInfo *perminfo;
661 Bitmapset *updatedCols,
662 *extraUpdatedCols;
663
664 Assert(root->parse->commandType == CMD_UPDATE);
665 Assert(IS_SIMPLE_REL(rel));
666
667 /*
668 * We obtain updatedCols for the query's result relation. Then, if
669 * necessary, we map it to the column numbers of the relation for which
670 * they were requested.
671 */
672 relid = root->parse->resultRelation;
673 rte = planner_rt_fetch(relid, root);
674 perminfo = getRTEPermissionInfo(root->parse->rteperminfos, rte);
675
676 updatedCols = perminfo->updatedCols;
677
678 if (rel->relid != relid)
679 {
680 RelOptInfo *top_parent_rel = find_base_rel(root, relid);
681
682 Assert(IS_OTHER_REL(rel));
683
684 updatedCols = translate_col_privs_multilevel(root, rel, top_parent_rel,
685 updatedCols);
686 }
687
688 /*
689 * Now we must check to see if there are any generated columns that depend
690 * on the updatedCols, and add them to the result.
691 */
692 extraUpdatedCols = get_dependent_generated_columns(root, rel->relid,
693 updatedCols);
694
695 return bms_union(updatedCols, extraUpdatedCols);
696 }
697
698 /*
699 * translate_col_privs
700 * Translate a bitmapset representing per-column privileges from the
701 * parent rel's attribute numbering to the child's.
702 *
703 * The only surprise here is that we don't translate a parent whole-row
704 * reference into a child whole-row reference. That would mean requiring
705 * permissions on all child columns, which is overly strict, since the
706 * query is really only going to reference the inherited columns. Instead
707 * we set the per-column bits for all inherited columns.
708 */
709 static Bitmapset *
710 translate_col_privs(const Bitmapset *parent_privs,
711 List *translated_vars)
712 {
713 Bitmapset *child_privs = NULL;
714 bool whole_row;
715 int attno;
716 ListCell *lc;
717
718 /* System attributes have the same numbers in all tables */
719 for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
720 {
721 if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
722 parent_privs))
723 child_privs = bms_add_member(child_privs,
724 attno - FirstLowInvalidHeapAttributeNumber);
725 }
726
727 /* Check if parent has whole-row reference */
728 whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber,
729 parent_privs);
730
731 /* And now translate the regular user attributes, using the vars list */
732 attno = InvalidAttrNumber;
733 foreach(lc, translated_vars)
734 {
735 Var *var = lfirst_node(Var, lc);
736
737 attno++;
738 if (var == NULL) /* ignore dropped columns */
739 continue;
740 if (whole_row ||
741 bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
742 parent_privs))
743 child_privs = bms_add_member(child_privs,
744 var->varattno - FirstLowInvalidHeapAttributeNumber);
745 }
746
747 return child_privs;
748 }
749
750 /*
751 * translate_col_privs_multilevel
752 * Recursively translates the column numbers contained in 'parent_cols'
753 * to the column numbers of a descendant relation given by 'rel'
754 *
755 * Note that because this is based on translate_col_privs, it will expand
756 * a whole-row reference into all inherited columns. This is not an issue
757 * for current usages, but beware.
758 */
759 static Bitmapset *
760 translate_col_privs_multilevel(PlannerInfo *root, RelOptInfo *rel,
761 RelOptInfo *parent_rel,
762 Bitmapset *parent_cols)
763 {
764 AppendRelInfo *appinfo;
765
766 /* Fast path for easy case. */
767 if (parent_cols == NULL)
768 return NULL;
769
770 /* Recurse if immediate parent is not the top parent. */
771 if (rel->parent != parent_rel)
772 {
773 if (rel->parent)
774 parent_cols = translate_col_privs_multilevel(root, rel->parent,
775 parent_rel,
776 parent_cols);
777 else
778 elog(ERROR, "rel with relid %u is not a child rel", rel->relid);
779 }
780
781 /* Now translate for this child. */
782 Assert(root->append_rel_array != NULL);
783 appinfo = root->append_rel_array[rel->relid];
784 Assert(appinfo != NULL);
785
786 return translate_col_privs(parent_cols, appinfo->translated_vars);
787 }
788
789 /*
790 * expand_appendrel_subquery
791 * Add "other rel" RelOptInfos for the children of an appendrel baserel
792 *
793 * "rel" is a subquery relation that has the rte->inh flag set, meaning it
794 * is a UNION ALL subquery that's been flattened into an appendrel, with
795 * child subqueries listed in root->append_rel_list. We need to build
796 * a RelOptInfo for each child relation so that we can plan scans on them.
797 */
798 static void
799 expand_appendrel_subquery(PlannerInfo *root, RelOptInfo *rel,
800 RangeTblEntry *rte, Index rti)
801 {
802 ListCell *l;
803
804 foreach(l, root->append_rel_list)
805 {
806 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
807 Index childRTindex = appinfo->child_relid;
808 RangeTblEntry *childrte;
809 RelOptInfo *childrel;
810
811 /* append_rel_list contains all append rels; ignore others */
812 if (appinfo->parent_relid != rti)
813 continue;
814
815 /* find the child RTE, which should already exist */
816 Assert(childRTindex < root->simple_rel_array_size);
817 childrte = root->simple_rte_array[childRTindex];
818 Assert(childrte != NULL);
819
820 /* Build the child RelOptInfo. */
821 childrel = build_simple_rel(root, childRTindex, rel);
822
823 /* Child may itself be an inherited rel, either table or subquery. */
824 if (childrte->inh)
825 expand_inherited_rtentry(root, childrel, childrte, childRTindex);
826 }
827 }
828
829
830 /*
831 * apply_child_basequals
832 * Populate childrel's base restriction quals from parent rel's quals,
833 * translating Vars using appinfo and re-checking for quals which are
834 * constant-TRUE or constant-FALSE when applied to this child relation.
835 *
836 * If any of the resulting clauses evaluate to constant false or NULL, we
837 * return false and don't apply any quals. Caller should mark the relation as
838 * a dummy rel in this case, since it doesn't need to be scanned. Constant
839 * true quals are ignored.
840 */
841 bool
842 apply_child_basequals(PlannerInfo *root, RelOptInfo *parentrel,
843 RelOptInfo *childrel, RangeTblEntry *childRTE,
844 AppendRelInfo *appinfo)
845 {
846 List *childquals;
847 Index cq_min_security;
848 ListCell *lc;
849
850 /*
851 * The child rel's targetlist might contain non-Var expressions, which
852 * means that substitution into the quals could produce opportunities for
853 * const-simplification, and perhaps even pseudoconstant quals. Therefore,
854 * transform each RestrictInfo separately to see if it reduces to a
855 * constant or pseudoconstant. (We must process them separately to keep
856 * track of the security level of each qual.)
857 */
858 childquals = NIL;
859 cq_min_security = UINT_MAX;
860 foreach(lc, parentrel->baserestrictinfo)
861 {
862 RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
863 Node *childqual;
864 ListCell *lc2;
865
866 Assert(IsA(rinfo, RestrictInfo));
867 childqual = adjust_appendrel_attrs(root,
868 (Node *) rinfo->clause,
869 1, &appinfo);
870 childqual = eval_const_expressions(root, childqual);
871 /* check for flat-out constant */
872 if (childqual && IsA(childqual, Const))
873 {
874 if (((Const *) childqual)->constisnull ||
875 !DatumGetBool(((Const *) childqual)->constvalue))
876 {
877 /* Restriction reduces to constant FALSE or NULL */
878 return false;
879 }
880 /* Restriction reduces to constant TRUE, so drop it */
881 continue;
882 }
883 /* might have gotten an AND clause, if so flatten it */
884 foreach(lc2, make_ands_implicit((Expr *) childqual))
885 {
886 Node *onecq = (Node *) lfirst(lc2);
887 bool pseudoconstant;
888 RestrictInfo *childrinfo;
889
890 /* check for pseudoconstant (no Vars or volatile functions) */
891 pseudoconstant =
892 !contain_vars_of_level(onecq, 0) &&
893 !contain_volatile_functions(onecq);
894 if (pseudoconstant)
895 {
896 /* tell createplan.c to check for gating quals */
897 root->hasPseudoConstantQuals = true;
898 }
899 /* reconstitute RestrictInfo with appropriate properties */
900 childrinfo = make_restrictinfo(root,
901 (Expr *) onecq,
902 rinfo->is_pushed_down,
903 rinfo->has_clone,
904 rinfo->is_clone,
905 pseudoconstant,
906 rinfo->security_level,
907 NULL, NULL, NULL);
908
909 /* Restriction is proven always false */
910 if (restriction_is_always_false(root, childrinfo))
911 return false;
912 /* Restriction is proven always true, so drop it */
913 if (restriction_is_always_true(root, childrinfo))
914 continue;
915
916 childquals = lappend(childquals, childrinfo);
917 /* track minimum security level among child quals */
918 cq_min_security = Min(cq_min_security, rinfo->security_level);
919 }
920 }
921
922 /*
923 * In addition to the quals inherited from the parent, we might have
924 * securityQuals associated with this particular child node. (Currently
925 * this can only happen in appendrels originating from UNION ALL;
926 * inheritance child tables don't have their own securityQuals, see
927 * expand_single_inheritance_child().) Pull any such securityQuals up
928 * into the baserestrictinfo for the child. This is similar to
929 * process_security_barrier_quals() for the parent rel, except that we
930 * can't make any general deductions from such quals, since they don't
931 * hold for the whole appendrel.
932 */
933 if (childRTE->securityQuals)
934 {
935 Index security_level = 0;
936
937 foreach(lc, childRTE->securityQuals)
938 {
939 List *qualset = (List *) lfirst(lc);
940 ListCell *lc2;
941
942 foreach(lc2, qualset)
943 {
944 Expr *qual = (Expr *) lfirst(lc2);
945
946 /* not likely that we'd see constants here, so no check */
947 childquals = lappend(childquals,
948 make_restrictinfo(root, qual,
949 true,
950 false, false,
951 false,
952 security_level,
953 NULL, NULL, NULL));
954 cq_min_security = Min(cq_min_security, security_level);
955 }
956 security_level++;
957 }
958 Assert(security_level <= root->qual_security_level);
959 }
960
961 /*
962 * OK, we've got all the baserestrictinfo quals for this child.
963 */
964 childrel->baserestrictinfo = childquals;
965 childrel->baserestrict_min_security = cq_min_security;
966
967 return true;
968 }