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