| 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 |
} |