mirror of https://github.com/postgres/postgres
This commit moves expand_inherited_tables and underlings from
optimizer/prep/prepunionc.c to optimizer/utils/inherit.c.
Also, all of the AppendRelInfo-based expression manipulation routines
are moved to optimizer/utils/appendinfo.c.
No functional code changes. One exception is the introduction of
make_append_rel_info, but that's still just moving around code.
Also, stop including <limits.h> in prepunion.c, which no longer needs
it since 3fc6e2d7f5. I (Álvaro) noticed this because Amit was copying
that to inherit.c, which likewise doesn't need it.
Author: Amit Langote
Discussion: https://postgr.es/m/3be67028-a00a-502c-199a-da00eec8fb6e@lab.ntt.co.jp
pull/36/head
Alvaro Herrera
7 years ago
parent
dacadcd1f3
commit
b60c397599
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,826 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* appendinfo.c |
||||||
|
* Routines for mapping between append parent(s) and children |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/optimizer/path/appendinfo.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "access/htup_details.h" |
||||||
|
#include "access/sysattr.h" |
||||||
|
#include "nodes/makefuncs.h" |
||||||
|
#include "nodes/nodeFuncs.h" |
||||||
|
#include "optimizer/appendinfo.h" |
||||||
|
#include "parser/parsetree.h" |
||||||
|
#include "utils/rel.h" |
||||||
|
#include "utils/lsyscache.h" |
||||||
|
#include "utils/syscache.h" |
||||||
|
|
||||||
|
|
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
PlannerInfo *root; |
||||||
|
int nappinfos; |
||||||
|
AppendRelInfo **appinfos; |
||||||
|
} adjust_appendrel_attrs_context; |
||||||
|
|
||||||
|
static void make_inh_translation_list(Relation oldrelation, |
||||||
|
Relation newrelation, |
||||||
|
Index newvarno, |
||||||
|
List **translated_vars); |
||||||
|
static Node *adjust_appendrel_attrs_mutator(Node *node, |
||||||
|
adjust_appendrel_attrs_context *context); |
||||||
|
static Relids adjust_child_relids(Relids relids, int nappinfos, |
||||||
|
AppendRelInfo **appinfos); |
||||||
|
static List *adjust_inherited_tlist(List *tlist, |
||||||
|
AppendRelInfo *context); |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* make_append_rel_info |
||||||
|
* Build an AppendRelInfo for the parent-child pair |
||||||
|
*/ |
||||||
|
AppendRelInfo * |
||||||
|
make_append_rel_info(Relation parentrel, Relation childrel, |
||||||
|
Index parentRTindex, Index childRTindex) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = makeNode(AppendRelInfo); |
||||||
|
|
||||||
|
appinfo->parent_relid = parentRTindex; |
||||||
|
appinfo->child_relid = childRTindex; |
||||||
|
appinfo->parent_reltype = parentrel->rd_rel->reltype; |
||||||
|
appinfo->child_reltype = childrel->rd_rel->reltype; |
||||||
|
make_inh_translation_list(parentrel, childrel, childRTindex, |
||||||
|
&appinfo->translated_vars); |
||||||
|
appinfo->parent_reloid = RelationGetRelid(parentrel); |
||||||
|
|
||||||
|
return appinfo; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* make_inh_translation_list |
||||||
|
* Build the list of translations from parent Vars to child Vars for |
||||||
|
* an inheritance child. |
||||||
|
* |
||||||
|
* For paranoia's sake, we match type/collation as well as attribute name. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
make_inh_translation_list(Relation oldrelation, Relation newrelation, |
||||||
|
Index newvarno, |
||||||
|
List **translated_vars) |
||||||
|
{ |
||||||
|
List *vars = NIL; |
||||||
|
TupleDesc old_tupdesc = RelationGetDescr(oldrelation); |
||||||
|
TupleDesc new_tupdesc = RelationGetDescr(newrelation); |
||||||
|
Oid new_relid = RelationGetRelid(newrelation); |
||||||
|
int oldnatts = old_tupdesc->natts; |
||||||
|
int newnatts = new_tupdesc->natts; |
||||||
|
int old_attno; |
||||||
|
int new_attno = 0; |
||||||
|
|
||||||
|
for (old_attno = 0; old_attno < oldnatts; old_attno++) |
||||||
|
{ |
||||||
|
Form_pg_attribute att; |
||||||
|
char *attname; |
||||||
|
Oid atttypid; |
||||||
|
int32 atttypmod; |
||||||
|
Oid attcollation; |
||||||
|
|
||||||
|
att = TupleDescAttr(old_tupdesc, old_attno); |
||||||
|
if (att->attisdropped) |
||||||
|
{ |
||||||
|
/* Just put NULL into this list entry */ |
||||||
|
vars = lappend(vars, NULL); |
||||||
|
continue; |
||||||
|
} |
||||||
|
attname = NameStr(att->attname); |
||||||
|
atttypid = att->atttypid; |
||||||
|
atttypmod = att->atttypmod; |
||||||
|
attcollation = att->attcollation; |
||||||
|
|
||||||
|
/*
|
||||||
|
* When we are generating the "translation list" for the parent table |
||||||
|
* of an inheritance set, no need to search for matches. |
||||||
|
*/ |
||||||
|
if (oldrelation == newrelation) |
||||||
|
{ |
||||||
|
vars = lappend(vars, makeVar(newvarno, |
||||||
|
(AttrNumber) (old_attno + 1), |
||||||
|
atttypid, |
||||||
|
atttypmod, |
||||||
|
attcollation, |
||||||
|
0)); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Otherwise we have to search for the matching column by name. |
||||||
|
* There's no guarantee it'll have the same column position, because |
||||||
|
* of cases like ALTER TABLE ADD COLUMN and multiple inheritance. |
||||||
|
* However, in simple cases, the relative order of columns is mostly |
||||||
|
* the same in both relations, so try the column of newrelation that |
||||||
|
* follows immediately after the one that we just found, and if that |
||||||
|
* fails, let syscache handle it. |
||||||
|
*/ |
||||||
|
if (new_attno >= newnatts || |
||||||
|
(att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped || |
||||||
|
strcmp(attname, NameStr(att->attname)) != 0) |
||||||
|
{ |
||||||
|
HeapTuple newtup; |
||||||
|
|
||||||
|
newtup = SearchSysCacheAttName(new_relid, attname); |
||||||
|
if (!newtup) |
||||||
|
elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"", |
||||||
|
attname, RelationGetRelationName(newrelation)); |
||||||
|
new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1; |
||||||
|
ReleaseSysCache(newtup); |
||||||
|
|
||||||
|
att = TupleDescAttr(new_tupdesc, new_attno); |
||||||
|
} |
||||||
|
|
||||||
|
/* Found it, check type and collation match */ |
||||||
|
if (atttypid != att->atttypid || atttypmod != att->atttypmod) |
||||||
|
elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type", |
||||||
|
attname, RelationGetRelationName(newrelation)); |
||||||
|
if (attcollation != att->attcollation) |
||||||
|
elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation", |
||||||
|
attname, RelationGetRelationName(newrelation)); |
||||||
|
|
||||||
|
vars = lappend(vars, makeVar(newvarno, |
||||||
|
(AttrNumber) (new_attno + 1), |
||||||
|
atttypid, |
||||||
|
atttypmod, |
||||||
|
attcollation, |
||||||
|
0)); |
||||||
|
new_attno++; |
||||||
|
} |
||||||
|
|
||||||
|
*translated_vars = vars; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* translate_col_privs |
||||||
|
* Translate a bitmapset representing per-column privileges from the |
||||||
|
* parent rel's attribute numbering to the child's. |
||||||
|
* |
||||||
|
* The only surprise here is that we don't translate a parent whole-row |
||||||
|
* reference into a child whole-row reference. That would mean requiring |
||||||
|
* permissions on all child columns, which is overly strict, since the |
||||||
|
* query is really only going to reference the inherited columns. Instead |
||||||
|
* we set the per-column bits for all inherited columns. |
||||||
|
*/ |
||||||
|
Bitmapset * |
||||||
|
translate_col_privs(const Bitmapset *parent_privs, |
||||||
|
List *translated_vars) |
||||||
|
{ |
||||||
|
Bitmapset *child_privs = NULL; |
||||||
|
bool whole_row; |
||||||
|
int attno; |
||||||
|
ListCell *lc; |
||||||
|
|
||||||
|
/* System attributes have the same numbers in all tables */ |
||||||
|
for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++) |
||||||
|
{ |
||||||
|
if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber, |
||||||
|
parent_privs)) |
||||||
|
child_privs = bms_add_member(child_privs, |
||||||
|
attno - FirstLowInvalidHeapAttributeNumber); |
||||||
|
} |
||||||
|
|
||||||
|
/* Check if parent has whole-row reference */ |
||||||
|
whole_row = bms_is_member(InvalidAttrNumber - FirstLowInvalidHeapAttributeNumber, |
||||||
|
parent_privs); |
||||||
|
|
||||||
|
/* And now translate the regular user attributes, using the vars list */ |
||||||
|
attno = InvalidAttrNumber; |
||||||
|
foreach(lc, translated_vars) |
||||||
|
{ |
||||||
|
Var *var = lfirst_node(Var, lc); |
||||||
|
|
||||||
|
attno++; |
||||||
|
if (var == NULL) /* ignore dropped columns */ |
||||||
|
continue; |
||||||
|
if (whole_row || |
||||||
|
bms_is_member(attno - FirstLowInvalidHeapAttributeNumber, |
||||||
|
parent_privs)) |
||||||
|
child_privs = bms_add_member(child_privs, |
||||||
|
var->varattno - FirstLowInvalidHeapAttributeNumber); |
||||||
|
} |
||||||
|
|
||||||
|
return child_privs; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* adjust_appendrel_attrs |
||||||
|
* Copy the specified query or expression and translate Vars referring to a |
||||||
|
* parent rel to refer to the corresponding child rel instead. We also |
||||||
|
* update rtindexes appearing outside Vars, such as resultRelation and |
||||||
|
* jointree relids. |
||||||
|
* |
||||||
|
* Note: this is only applied after conversion of sublinks to subplans, |
||||||
|
* so we don't need to cope with recursion into sub-queries. |
||||||
|
* |
||||||
|
* Note: this is not hugely different from what pullup_replace_vars() does; |
||||||
|
* maybe we should try to fold the two routines together. |
||||||
|
*/ |
||||||
|
Node * |
||||||
|
adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, |
||||||
|
AppendRelInfo **appinfos) |
||||||
|
{ |
||||||
|
Node *result; |
||||||
|
adjust_appendrel_attrs_context context; |
||||||
|
|
||||||
|
context.root = root; |
||||||
|
context.nappinfos = nappinfos; |
||||||
|
context.appinfos = appinfos; |
||||||
|
|
||||||
|
/* If there's nothing to adjust, don't call this function. */ |
||||||
|
Assert(nappinfos >= 1 && appinfos != NULL); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Must be prepared to start with a Query or a bare expression tree. |
||||||
|
*/ |
||||||
|
if (node && IsA(node, Query)) |
||||||
|
{ |
||||||
|
Query *newnode; |
||||||
|
int cnt; |
||||||
|
|
||||||
|
newnode = query_tree_mutator((Query *) node, |
||||||
|
adjust_appendrel_attrs_mutator, |
||||||
|
(void *) &context, |
||||||
|
QTW_IGNORE_RC_SUBQUERIES); |
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
if (newnode->resultRelation == appinfo->parent_relid) |
||||||
|
{ |
||||||
|
newnode->resultRelation = appinfo->child_relid; |
||||||
|
/* Fix tlist resnos too, if it's inherited UPDATE */ |
||||||
|
if (newnode->commandType == CMD_UPDATE) |
||||||
|
newnode->targetList = |
||||||
|
adjust_inherited_tlist(newnode->targetList, |
||||||
|
appinfo); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
result = (Node *) newnode; |
||||||
|
} |
||||||
|
else |
||||||
|
result = adjust_appendrel_attrs_mutator(node, &context); |
||||||
|
|
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
static Node * |
||||||
|
adjust_appendrel_attrs_mutator(Node *node, |
||||||
|
adjust_appendrel_attrs_context *context) |
||||||
|
{ |
||||||
|
AppendRelInfo **appinfos = context->appinfos; |
||||||
|
int nappinfos = context->nappinfos; |
||||||
|
int cnt; |
||||||
|
|
||||||
|
if (node == NULL) |
||||||
|
return NULL; |
||||||
|
if (IsA(node, Var)) |
||||||
|
{ |
||||||
|
Var *var = (Var *) copyObject(node); |
||||||
|
AppendRelInfo *appinfo = NULL; |
||||||
|
|
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
if (var->varno == appinfos[cnt]->parent_relid) |
||||||
|
{ |
||||||
|
appinfo = appinfos[cnt]; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (var->varlevelsup == 0 && appinfo) |
||||||
|
{ |
||||||
|
var->varno = appinfo->child_relid; |
||||||
|
var->varnoold = appinfo->child_relid; |
||||||
|
if (var->varattno > 0) |
||||||
|
{ |
||||||
|
Node *newnode; |
||||||
|
|
||||||
|
if (var->varattno > list_length(appinfo->translated_vars)) |
||||||
|
elog(ERROR, "attribute %d of relation \"%s\" does not exist", |
||||||
|
var->varattno, get_rel_name(appinfo->parent_reloid)); |
||||||
|
newnode = copyObject(list_nth(appinfo->translated_vars, |
||||||
|
var->varattno - 1)); |
||||||
|
if (newnode == NULL) |
||||||
|
elog(ERROR, "attribute %d of relation \"%s\" does not exist", |
||||||
|
var->varattno, get_rel_name(appinfo->parent_reloid)); |
||||||
|
return newnode; |
||||||
|
} |
||||||
|
else if (var->varattno == 0) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* Whole-row Var: if we are dealing with named rowtypes, we |
||||||
|
* can use a whole-row Var for the child table plus a coercion |
||||||
|
* step to convert the tuple layout to the parent's rowtype. |
||||||
|
* Otherwise we have to generate a RowExpr. |
||||||
|
*/ |
||||||
|
if (OidIsValid(appinfo->child_reltype)) |
||||||
|
{ |
||||||
|
Assert(var->vartype == appinfo->parent_reltype); |
||||||
|
if (appinfo->parent_reltype != appinfo->child_reltype) |
||||||
|
{ |
||||||
|
ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr); |
||||||
|
|
||||||
|
r->arg = (Expr *) var; |
||||||
|
r->resulttype = appinfo->parent_reltype; |
||||||
|
r->convertformat = COERCE_IMPLICIT_CAST; |
||||||
|
r->location = -1; |
||||||
|
/* Make sure the Var node has the right type ID, too */ |
||||||
|
var->vartype = appinfo->child_reltype; |
||||||
|
return (Node *) r; |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* Build a RowExpr containing the translated variables. |
||||||
|
* |
||||||
|
* In practice var->vartype will always be RECORDOID here, |
||||||
|
* so we need to come up with some suitable column names. |
||||||
|
* We use the parent RTE's column names. |
||||||
|
* |
||||||
|
* Note: we can't get here for inheritance cases, so there |
||||||
|
* is no need to worry that translated_vars might contain |
||||||
|
* some dummy NULLs. |
||||||
|
*/ |
||||||
|
RowExpr *rowexpr; |
||||||
|
List *fields; |
||||||
|
RangeTblEntry *rte; |
||||||
|
|
||||||
|
rte = rt_fetch(appinfo->parent_relid, |
||||||
|
context->root->parse->rtable); |
||||||
|
fields = copyObject(appinfo->translated_vars); |
||||||
|
rowexpr = makeNode(RowExpr); |
||||||
|
rowexpr->args = fields; |
||||||
|
rowexpr->row_typeid = var->vartype; |
||||||
|
rowexpr->row_format = COERCE_IMPLICIT_CAST; |
||||||
|
rowexpr->colnames = copyObject(rte->eref->colnames); |
||||||
|
rowexpr->location = -1; |
||||||
|
|
||||||
|
return (Node *) rowexpr; |
||||||
|
} |
||||||
|
} |
||||||
|
/* system attributes don't need any other translation */ |
||||||
|
} |
||||||
|
return (Node *) var; |
||||||
|
} |
||||||
|
if (IsA(node, CurrentOfExpr)) |
||||||
|
{ |
||||||
|
CurrentOfExpr *cexpr = (CurrentOfExpr *) copyObject(node); |
||||||
|
|
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
if (cexpr->cvarno == appinfo->parent_relid) |
||||||
|
{ |
||||||
|
cexpr->cvarno = appinfo->child_relid; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
return (Node *) cexpr; |
||||||
|
} |
||||||
|
if (IsA(node, RangeTblRef)) |
||||||
|
{ |
||||||
|
RangeTblRef *rtr = (RangeTblRef *) copyObject(node); |
||||||
|
|
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
if (rtr->rtindex == appinfo->parent_relid) |
||||||
|
{ |
||||||
|
rtr->rtindex = appinfo->child_relid; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
return (Node *) rtr; |
||||||
|
} |
||||||
|
if (IsA(node, JoinExpr)) |
||||||
|
{ |
||||||
|
/* Copy the JoinExpr node with correct mutation of subnodes */ |
||||||
|
JoinExpr *j; |
||||||
|
AppendRelInfo *appinfo; |
||||||
|
|
||||||
|
j = (JoinExpr *) expression_tree_mutator(node, |
||||||
|
adjust_appendrel_attrs_mutator, |
||||||
|
(void *) context); |
||||||
|
/* now fix JoinExpr's rtindex (probably never happens) */ |
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
if (j->rtindex == appinfo->parent_relid) |
||||||
|
{ |
||||||
|
j->rtindex = appinfo->child_relid; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
return (Node *) j; |
||||||
|
} |
||||||
|
if (IsA(node, PlaceHolderVar)) |
||||||
|
{ |
||||||
|
/* Copy the PlaceHolderVar node with correct mutation of subnodes */ |
||||||
|
PlaceHolderVar *phv; |
||||||
|
|
||||||
|
phv = (PlaceHolderVar *) expression_tree_mutator(node, |
||||||
|
adjust_appendrel_attrs_mutator, |
||||||
|
(void *) context); |
||||||
|
/* now fix PlaceHolderVar's relid sets */ |
||||||
|
if (phv->phlevelsup == 0) |
||||||
|
phv->phrels = adjust_child_relids(phv->phrels, context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
return (Node *) phv; |
||||||
|
} |
||||||
|
/* Shouldn't need to handle planner auxiliary nodes here */ |
||||||
|
Assert(!IsA(node, SpecialJoinInfo)); |
||||||
|
Assert(!IsA(node, AppendRelInfo)); |
||||||
|
Assert(!IsA(node, PlaceHolderInfo)); |
||||||
|
Assert(!IsA(node, MinMaxAggInfo)); |
||||||
|
|
||||||
|
/*
|
||||||
|
* We have to process RestrictInfo nodes specially. (Note: although |
||||||
|
* set_append_rel_pathlist will hide RestrictInfos in the parent's |
||||||
|
* baserestrictinfo list from us, it doesn't hide those in joininfo.) |
||||||
|
*/ |
||||||
|
if (IsA(node, RestrictInfo)) |
||||||
|
{ |
||||||
|
RestrictInfo *oldinfo = (RestrictInfo *) node; |
||||||
|
RestrictInfo *newinfo = makeNode(RestrictInfo); |
||||||
|
|
||||||
|
/* Copy all flat-copiable fields */ |
||||||
|
memcpy(newinfo, oldinfo, sizeof(RestrictInfo)); |
||||||
|
|
||||||
|
/* Recursively fix the clause itself */ |
||||||
|
newinfo->clause = (Expr *) |
||||||
|
adjust_appendrel_attrs_mutator((Node *) oldinfo->clause, context); |
||||||
|
|
||||||
|
/* and the modified version, if an OR clause */ |
||||||
|
newinfo->orclause = (Expr *) |
||||||
|
adjust_appendrel_attrs_mutator((Node *) oldinfo->orclause, context); |
||||||
|
|
||||||
|
/* adjust relid sets too */ |
||||||
|
newinfo->clause_relids = adjust_child_relids(oldinfo->clause_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
newinfo->required_relids = adjust_child_relids(oldinfo->required_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
newinfo->outer_relids = adjust_child_relids(oldinfo->outer_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
newinfo->nullable_relids = adjust_child_relids(oldinfo->nullable_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
newinfo->left_relids = adjust_child_relids(oldinfo->left_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
newinfo->right_relids = adjust_child_relids(oldinfo->right_relids, |
||||||
|
context->nappinfos, |
||||||
|
context->appinfos); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Reset cached derivative fields, since these might need to have |
||||||
|
* different values when considering the child relation. Note we |
||||||
|
* don't reset left_ec/right_ec: each child variable is implicitly |
||||||
|
* equivalent to its parent, so still a member of the same EC if any. |
||||||
|
*/ |
||||||
|
newinfo->eval_cost.startup = -1; |
||||||
|
newinfo->norm_selec = -1; |
||||||
|
newinfo->outer_selec = -1; |
||||||
|
newinfo->left_em = NULL; |
||||||
|
newinfo->right_em = NULL; |
||||||
|
newinfo->scansel_cache = NIL; |
||||||
|
newinfo->left_bucketsize = -1; |
||||||
|
newinfo->right_bucketsize = -1; |
||||||
|
newinfo->left_mcvfreq = -1; |
||||||
|
newinfo->right_mcvfreq = -1; |
||||||
|
|
||||||
|
return (Node *) newinfo; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* NOTE: we do not need to recurse into sublinks, because they should |
||||||
|
* already have been converted to subplans before we see them. |
||||||
|
*/ |
||||||
|
Assert(!IsA(node, SubLink)); |
||||||
|
Assert(!IsA(node, Query)); |
||||||
|
|
||||||
|
return expression_tree_mutator(node, adjust_appendrel_attrs_mutator, |
||||||
|
(void *) context); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Substitute child relids for parent relids in a Relid set. The array of |
||||||
|
* appinfos specifies the substitutions to be performed. |
||||||
|
*/ |
||||||
|
static Relids |
||||||
|
adjust_child_relids(Relids relids, int nappinfos, AppendRelInfo **appinfos) |
||||||
|
{ |
||||||
|
Bitmapset *result = NULL; |
||||||
|
int cnt; |
||||||
|
|
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
/* Remove parent, add child */ |
||||||
|
if (bms_is_member(appinfo->parent_relid, relids)) |
||||||
|
{ |
||||||
|
/* Make a copy if we are changing the set. */ |
||||||
|
if (!result) |
||||||
|
result = bms_copy(relids); |
||||||
|
|
||||||
|
result = bms_del_member(result, appinfo->parent_relid); |
||||||
|
result = bms_add_member(result, appinfo->child_relid); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* If we made any changes, return the modified copy. */ |
||||||
|
if (result) |
||||||
|
return result; |
||||||
|
|
||||||
|
/* Otherwise, return the original set without modification. */ |
||||||
|
return relids; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Replace any relid present in top_parent_relids with its child in |
||||||
|
* child_relids. Members of child_relids can be multiple levels below top |
||||||
|
* parent in the partition hierarchy. |
||||||
|
*/ |
||||||
|
Relids |
||||||
|
adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, |
||||||
|
Relids child_relids, Relids top_parent_relids) |
||||||
|
{ |
||||||
|
AppendRelInfo **appinfos; |
||||||
|
int nappinfos; |
||||||
|
Relids parent_relids = NULL; |
||||||
|
Relids result; |
||||||
|
Relids tmp_result = NULL; |
||||||
|
int cnt; |
||||||
|
|
||||||
|
/*
|
||||||
|
* If the given relids set doesn't contain any of the top parent relids, |
||||||
|
* it will remain unchanged. |
||||||
|
*/ |
||||||
|
if (!bms_overlap(relids, top_parent_relids)) |
||||||
|
return relids; |
||||||
|
|
||||||
|
appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); |
||||||
|
|
||||||
|
/* Construct relids set for the immediate parent of the given child. */ |
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); |
||||||
|
} |
||||||
|
|
||||||
|
/* Recurse if immediate parent is not the top parent. */ |
||||||
|
if (!bms_equal(parent_relids, top_parent_relids)) |
||||||
|
{ |
||||||
|
tmp_result = adjust_child_relids_multilevel(root, relids, |
||||||
|
parent_relids, |
||||||
|
top_parent_relids); |
||||||
|
relids = tmp_result; |
||||||
|
} |
||||||
|
|
||||||
|
result = adjust_child_relids(relids, nappinfos, appinfos); |
||||||
|
|
||||||
|
/* Free memory consumed by any intermediate result. */ |
||||||
|
if (tmp_result) |
||||||
|
bms_free(tmp_result); |
||||||
|
bms_free(parent_relids); |
||||||
|
pfree(appinfos); |
||||||
|
|
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Adjust the targetlist entries of an inherited UPDATE operation |
||||||
|
* |
||||||
|
* The expressions have already been fixed, but we have to make sure that |
||||||
|
* the target resnos match the child table (they may not, in the case of |
||||||
|
* a column that was added after-the-fact by ALTER TABLE). In some cases |
||||||
|
* this can force us to re-order the tlist to preserve resno ordering. |
||||||
|
* (We do all this work in special cases so that preptlist.c is fast for |
||||||
|
* the typical case.) |
||||||
|
* |
||||||
|
* The given tlist has already been through expression_tree_mutator; |
||||||
|
* therefore the TargetEntry nodes are fresh copies that it's okay to |
||||||
|
* scribble on. |
||||||
|
* |
||||||
|
* Note that this is not needed for INSERT because INSERT isn't inheritable. |
||||||
|
*/ |
||||||
|
static List * |
||||||
|
adjust_inherited_tlist(List *tlist, AppendRelInfo *context) |
||||||
|
{ |
||||||
|
bool changed_it = false; |
||||||
|
ListCell *tl; |
||||||
|
List *new_tlist; |
||||||
|
bool more; |
||||||
|
int attrno; |
||||||
|
|
||||||
|
/* This should only happen for an inheritance case, not UNION ALL */ |
||||||
|
Assert(OidIsValid(context->parent_reloid)); |
||||||
|
|
||||||
|
/* Scan tlist and update resnos to match attnums of child rel */ |
||||||
|
foreach(tl, tlist) |
||||||
|
{ |
||||||
|
TargetEntry *tle = (TargetEntry *) lfirst(tl); |
||||||
|
Var *childvar; |
||||||
|
|
||||||
|
if (tle->resjunk) |
||||||
|
continue; /* ignore junk items */ |
||||||
|
|
||||||
|
/* Look up the translation of this column: it must be a Var */ |
||||||
|
if (tle->resno <= 0 || |
||||||
|
tle->resno > list_length(context->translated_vars)) |
||||||
|
elog(ERROR, "attribute %d of relation \"%s\" does not exist", |
||||||
|
tle->resno, get_rel_name(context->parent_reloid)); |
||||||
|
childvar = (Var *) list_nth(context->translated_vars, tle->resno - 1); |
||||||
|
if (childvar == NULL || !IsA(childvar, Var)) |
||||||
|
elog(ERROR, "attribute %d of relation \"%s\" does not exist", |
||||||
|
tle->resno, get_rel_name(context->parent_reloid)); |
||||||
|
|
||||||
|
if (tle->resno != childvar->varattno) |
||||||
|
{ |
||||||
|
tle->resno = childvar->varattno; |
||||||
|
changed_it = true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we changed anything, re-sort the tlist by resno, and make sure |
||||||
|
* resjunk entries have resnos above the last real resno. The sort |
||||||
|
* algorithm is a bit stupid, but for such a seldom-taken path, small is |
||||||
|
* probably better than fast. |
||||||
|
*/ |
||||||
|
if (!changed_it) |
||||||
|
return tlist; |
||||||
|
|
||||||
|
new_tlist = NIL; |
||||||
|
more = true; |
||||||
|
for (attrno = 1; more; attrno++) |
||||||
|
{ |
||||||
|
more = false; |
||||||
|
foreach(tl, tlist) |
||||||
|
{ |
||||||
|
TargetEntry *tle = (TargetEntry *) lfirst(tl); |
||||||
|
|
||||||
|
if (tle->resjunk) |
||||||
|
continue; /* ignore junk items */ |
||||||
|
|
||||||
|
if (tle->resno == attrno) |
||||||
|
new_tlist = lappend(new_tlist, tle); |
||||||
|
else if (tle->resno > attrno) |
||||||
|
more = true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
foreach(tl, tlist) |
||||||
|
{ |
||||||
|
TargetEntry *tle = (TargetEntry *) lfirst(tl); |
||||||
|
|
||||||
|
if (!tle->resjunk) |
||||||
|
continue; /* here, ignore non-junk items */ |
||||||
|
|
||||||
|
tle->resno = attrno; |
||||||
|
new_tlist = lappend(new_tlist, tle); |
||||||
|
attrno++; |
||||||
|
} |
||||||
|
|
||||||
|
return new_tlist; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* adjust_appendrel_attrs_multilevel |
||||||
|
* Apply Var translations from a toplevel appendrel parent down to a child. |
||||||
|
* |
||||||
|
* In some cases we need to translate expressions referencing a parent relation |
||||||
|
* to reference an appendrel child that's multiple levels removed from it. |
||||||
|
*/ |
||||||
|
Node * |
||||||
|
adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, |
||||||
|
Relids child_relids, |
||||||
|
Relids top_parent_relids) |
||||||
|
{ |
||||||
|
AppendRelInfo **appinfos; |
||||||
|
Bitmapset *parent_relids = NULL; |
||||||
|
int nappinfos; |
||||||
|
int cnt; |
||||||
|
|
||||||
|
Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids)); |
||||||
|
|
||||||
|
appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); |
||||||
|
|
||||||
|
/* Construct relids set for the immediate parent of given child. */ |
||||||
|
for (cnt = 0; cnt < nappinfos; cnt++) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = appinfos[cnt]; |
||||||
|
|
||||||
|
parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); |
||||||
|
} |
||||||
|
|
||||||
|
/* Recurse if immediate parent is not the top parent. */ |
||||||
|
if (!bms_equal(parent_relids, top_parent_relids)) |
||||||
|
node = adjust_appendrel_attrs_multilevel(root, node, parent_relids, |
||||||
|
top_parent_relids); |
||||||
|
|
||||||
|
/* Now translate for this child */ |
||||||
|
node = adjust_appendrel_attrs(root, node, nappinfos, appinfos); |
||||||
|
|
||||||
|
pfree(appinfos); |
||||||
|
|
||||||
|
return node; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Construct the SpecialJoinInfo for a child-join by translating |
||||||
|
* SpecialJoinInfo for the join between parents. left_relids and right_relids |
||||||
|
* are the relids of left and right side of the join respectively. |
||||||
|
*/ |
||||||
|
SpecialJoinInfo * |
||||||
|
build_child_join_sjinfo(PlannerInfo *root, SpecialJoinInfo *parent_sjinfo, |
||||||
|
Relids left_relids, Relids right_relids) |
||||||
|
{ |
||||||
|
SpecialJoinInfo *sjinfo = makeNode(SpecialJoinInfo); |
||||||
|
AppendRelInfo **left_appinfos; |
||||||
|
int left_nappinfos; |
||||||
|
AppendRelInfo **right_appinfos; |
||||||
|
int right_nappinfos; |
||||||
|
|
||||||
|
memcpy(sjinfo, parent_sjinfo, sizeof(SpecialJoinInfo)); |
||||||
|
left_appinfos = find_appinfos_by_relids(root, left_relids, |
||||||
|
&left_nappinfos); |
||||||
|
right_appinfos = find_appinfos_by_relids(root, right_relids, |
||||||
|
&right_nappinfos); |
||||||
|
|
||||||
|
sjinfo->min_lefthand = adjust_child_relids(sjinfo->min_lefthand, |
||||||
|
left_nappinfos, left_appinfos); |
||||||
|
sjinfo->min_righthand = adjust_child_relids(sjinfo->min_righthand, |
||||||
|
right_nappinfos, |
||||||
|
right_appinfos); |
||||||
|
sjinfo->syn_lefthand = adjust_child_relids(sjinfo->syn_lefthand, |
||||||
|
left_nappinfos, left_appinfos); |
||||||
|
sjinfo->syn_righthand = adjust_child_relids(sjinfo->syn_righthand, |
||||||
|
right_nappinfos, |
||||||
|
right_appinfos); |
||||||
|
sjinfo->semi_rhs_exprs = (List *) adjust_appendrel_attrs(root, |
||||||
|
(Node *) sjinfo->semi_rhs_exprs, |
||||||
|
right_nappinfos, |
||||||
|
right_appinfos); |
||||||
|
|
||||||
|
pfree(left_appinfos); |
||||||
|
pfree(right_appinfos); |
||||||
|
|
||||||
|
return sjinfo; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* find_appinfos_by_relids |
||||||
|
* Find AppendRelInfo structures for all relations specified by relids. |
||||||
|
* |
||||||
|
* The AppendRelInfos are returned in an array, which can be pfree'd by the |
||||||
|
* caller. *nappinfos is set to the number of entries in the array. |
||||||
|
*/ |
||||||
|
AppendRelInfo ** |
||||||
|
find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) |
||||||
|
{ |
||||||
|
AppendRelInfo **appinfos; |
||||||
|
int cnt = 0; |
||||||
|
int i; |
||||||
|
|
||||||
|
*nappinfos = bms_num_members(relids); |
||||||
|
appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos); |
||||||
|
|
||||||
|
i = -1; |
||||||
|
while ((i = bms_next_member(relids, i)) >= 0) |
||||||
|
{ |
||||||
|
AppendRelInfo *appinfo = root->append_rel_array[i]; |
||||||
|
|
||||||
|
if (!appinfo) |
||||||
|
elog(ERROR, "child rel %d not found in append_rel_array", i); |
||||||
|
|
||||||
|
appinfos[cnt++] = appinfo; |
||||||
|
} |
||||||
|
return appinfos; |
||||||
|
} |
||||||
@ -0,0 +1,439 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* inherit.c |
||||||
|
* Routines to process child relations in inheritance trees |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/optimizer/path/inherit.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include "access/heapam.h" |
||||||
|
#include "catalog/partition.h" |
||||||
|
#include "catalog/pg_inherits.h" |
||||||
|
#include "miscadmin.h" |
||||||
|
#include "optimizer/appendinfo.h" |
||||||
|
#include "optimizer/inherit.h" |
||||||
|
#include "optimizer/planner.h" |
||||||
|
#include "optimizer/prep.h" |
||||||
|
#include "utils/rel.h" |
||||||
|
|
||||||
|
|
||||||
|
static void expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, |
||||||
|
Index rti); |
||||||
|
static void expand_partitioned_rtentry(PlannerInfo *root, |
||||||
|
RangeTblEntry *parentrte, |
||||||
|
Index parentRTindex, Relation parentrel, |
||||||
|
PlanRowMark *top_parentrc, LOCKMODE lockmode, |
||||||
|
List **appinfos); |
||||||
|
static void expand_single_inheritance_child(PlannerInfo *root, |
||||||
|
RangeTblEntry *parentrte, |
||||||
|
Index parentRTindex, Relation parentrel, |
||||||
|
PlanRowMark *top_parentrc, Relation childrel, |
||||||
|
List **appinfos, RangeTblEntry **childrte_p, |
||||||
|
Index *childRTindex_p); |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* expand_inherited_tables |
||||||
|
* Expand each rangetable entry that represents an inheritance set |
||||||
|
* into an "append relation". At the conclusion of this process, |
||||||
|
* the "inh" flag is set in all and only those RTEs that are append |
||||||
|
* relation parents. |
||||||
|
*/ |
||||||
|
void |
||||||
|
expand_inherited_tables(PlannerInfo *root) |
||||||
|
{ |
||||||
|
Index nrtes; |
||||||
|
Index rti; |
||||||
|
ListCell *rl; |
||||||
|
|
||||||
|
/*
|
||||||
|
* expand_inherited_rtentry may add RTEs to parse->rtable. The function is |
||||||
|
* expected to recursively handle any RTEs that it creates with inh=true. |
||||||
|
* So just scan as far as the original end of the rtable list. |
||||||
|
*/ |
||||||
|
nrtes = list_length(root->parse->rtable); |
||||||
|
rl = list_head(root->parse->rtable); |
||||||
|
for (rti = 1; rti <= nrtes; rti++) |
||||||
|
{ |
||||||
|
RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl); |
||||||
|
|
||||||
|
expand_inherited_rtentry(root, rte, rti); |
||||||
|
rl = lnext(rl); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* expand_inherited_rtentry |
||||||
|
* Check whether a rangetable entry represents an inheritance set. |
||||||
|
* If so, add entries for all the child tables to the query's |
||||||
|
* rangetable, and build AppendRelInfo nodes for all the child tables |
||||||
|
* and add them to root->append_rel_list. If not, clear the entry's |
||||||
|
* "inh" flag to prevent later code from looking for AppendRelInfos. |
||||||
|
* |
||||||
|
* Note that the original RTE is considered to represent the whole |
||||||
|
* inheritance set. The first of the generated RTEs is an RTE for the same |
||||||
|
* table, but with inh = false, to represent the parent table in its role |
||||||
|
* as a simple member of the inheritance set. |
||||||
|
* |
||||||
|
* A childless table is never considered to be an inheritance set. For |
||||||
|
* regular inheritance, a parent RTE must always have at least two associated |
||||||
|
* AppendRelInfos: one corresponding to the parent table as a simple member of |
||||||
|
* inheritance set and one or more corresponding to the actual children. |
||||||
|
* Since a partitioned table is not scanned, it might have only one associated |
||||||
|
* AppendRelInfo. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti) |
||||||
|
{ |
||||||
|
Oid parentOID; |
||||||
|
PlanRowMark *oldrc; |
||||||
|
Relation oldrelation; |
||||||
|
LOCKMODE lockmode; |
||||||
|
List *inhOIDs; |
||||||
|
ListCell *l; |
||||||
|
|
||||||
|
/* Does RT entry allow inheritance? */ |
||||||
|
if (!rte->inh) |
||||||
|
return; |
||||||
|
/* Ignore any already-expanded UNION ALL nodes */ |
||||||
|
if (rte->rtekind != RTE_RELATION) |
||||||
|
{ |
||||||
|
Assert(rte->rtekind == RTE_SUBQUERY); |
||||||
|
return; |
||||||
|
} |
||||||
|
/* Fast path for common case of childless table */ |
||||||
|
parentOID = rte->relid; |
||||||
|
if (!has_subclass(parentOID)) |
||||||
|
{ |
||||||
|
/* Clear flag before returning */ |
||||||
|
rte->inh = false; |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* The rewriter should already have obtained an appropriate lock on each |
||||||
|
* relation named in the query. However, for each child relation we add |
||||||
|
* to the query, we must obtain an appropriate lock, because this will be |
||||||
|
* the first use of those relations in the parse/rewrite/plan pipeline. |
||||||
|
* Child rels should use the same lockmode as their parent. |
||||||
|
*/ |
||||||
|
lockmode = rte->rellockmode; |
||||||
|
|
||||||
|
/* Scan for all members of inheritance set, acquire needed locks */ |
||||||
|
inhOIDs = find_all_inheritors(parentOID, lockmode, NULL); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Check that there's at least one descendant, else treat as no-child |
||||||
|
* case. This could happen despite above has_subclass() check, if table |
||||||
|
* once had a child but no longer does. |
||||||
|
*/ |
||||||
|
if (list_length(inhOIDs) < 2) |
||||||
|
{ |
||||||
|
/* Clear flag before returning */ |
||||||
|
rte->inh = false; |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If parent relation is selected FOR UPDATE/SHARE, we need to mark its |
||||||
|
* PlanRowMark as isParent = true, and generate a new PlanRowMark for each |
||||||
|
* child. |
||||||
|
*/ |
||||||
|
oldrc = get_plan_rowmark(root->rowMarks, rti); |
||||||
|
if (oldrc) |
||||||
|
oldrc->isParent = true; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Must open the parent relation to examine its tupdesc. We need not lock |
||||||
|
* it; we assume the rewriter already did. |
||||||
|
*/ |
||||||
|
oldrelation = heap_open(parentOID, NoLock); |
||||||
|
|
||||||
|
/* Scan the inheritance set and expand it */ |
||||||
|
if (RelationGetPartitionDesc(oldrelation) != NULL) |
||||||
|
{ |
||||||
|
Assert(rte->relkind == RELKIND_PARTITIONED_TABLE); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If this table has partitions, recursively expand them in the order |
||||||
|
* in which they appear in the PartitionDesc. While at it, also |
||||||
|
* extract the partition key columns of all the partitioned tables. |
||||||
|
*/ |
||||||
|
expand_partitioned_rtentry(root, rte, rti, oldrelation, oldrc, |
||||||
|
lockmode, &root->append_rel_list); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
List *appinfos = NIL; |
||||||
|
RangeTblEntry *childrte; |
||||||
|
Index childRTindex; |
||||||
|
|
||||||
|
/*
|
||||||
|
* This table has no partitions. Expand any plain inheritance |
||||||
|
* children in the order the OIDs were returned by |
||||||
|
* find_all_inheritors. |
||||||
|
*/ |
||||||
|
foreach(l, inhOIDs) |
||||||
|
{ |
||||||
|
Oid childOID = lfirst_oid(l); |
||||||
|
Relation newrelation; |
||||||
|
|
||||||
|
/* Open rel if needed; we already have required locks */ |
||||||
|
if (childOID != parentOID) |
||||||
|
newrelation = heap_open(childOID, NoLock); |
||||||
|
else |
||||||
|
newrelation = oldrelation; |
||||||
|
|
||||||
|
/*
|
||||||
|
* It is possible that the parent table has children that are temp |
||||||
|
* tables of other backends. We cannot safely access such tables |
||||||
|
* (because of buffering issues), and the best thing to do seems |
||||||
|
* to be to silently ignore them. |
||||||
|
*/ |
||||||
|
if (childOID != parentOID && RELATION_IS_OTHER_TEMP(newrelation)) |
||||||
|
{ |
||||||
|
heap_close(newrelation, lockmode); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
expand_single_inheritance_child(root, rte, rti, oldrelation, oldrc, |
||||||
|
newrelation, |
||||||
|
&appinfos, &childrte, |
||||||
|
&childRTindex); |
||||||
|
|
||||||
|
/* Close child relations, but keep locks */ |
||||||
|
if (childOID != parentOID) |
||||||
|
heap_close(newrelation, NoLock); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If all the children were temp tables, pretend it's a |
||||||
|
* non-inheritance situation; we don't need Append node in that case. |
||||||
|
* The duplicate RTE we added for the parent table is harmless, so we |
||||||
|
* don't bother to get rid of it; ditto for the useless PlanRowMark |
||||||
|
* node. |
||||||
|
*/ |
||||||
|
if (list_length(appinfos) < 2) |
||||||
|
rte->inh = false; |
||||||
|
else |
||||||
|
root->append_rel_list = list_concat(root->append_rel_list, |
||||||
|
appinfos); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
heap_close(oldrelation, NoLock); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* expand_partitioned_rtentry |
||||||
|
* Recursively expand an RTE for a partitioned table. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
expand_partitioned_rtentry(PlannerInfo *root, RangeTblEntry *parentrte, |
||||||
|
Index parentRTindex, Relation parentrel, |
||||||
|
PlanRowMark *top_parentrc, LOCKMODE lockmode, |
||||||
|
List **appinfos) |
||||||
|
{ |
||||||
|
int i; |
||||||
|
RangeTblEntry *childrte; |
||||||
|
Index childRTindex; |
||||||
|
PartitionDesc partdesc = RelationGetPartitionDesc(parentrel); |
||||||
|
|
||||||
|
check_stack_depth(); |
||||||
|
|
||||||
|
/* A partitioned table should always have a partition descriptor. */ |
||||||
|
Assert(partdesc); |
||||||
|
|
||||||
|
Assert(parentrte->inh); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Note down whether any partition key cols are being updated. Though it's |
||||||
|
* the root partitioned table's updatedCols we are interested in, we |
||||||
|
* instead use parentrte to get the updatedCols. This is convenient |
||||||
|
* because parentrte already has the root partrel's updatedCols translated |
||||||
|
* to match the attribute ordering of parentrel. |
||||||
|
*/ |
||||||
|
if (!root->partColsUpdated) |
||||||
|
root->partColsUpdated = |
||||||
|
has_partition_attrs(parentrel, parentrte->updatedCols, NULL); |
||||||
|
|
||||||
|
/* First expand the partitioned table itself. */ |
||||||
|
expand_single_inheritance_child(root, parentrte, parentRTindex, parentrel, |
||||||
|
top_parentrc, parentrel, |
||||||
|
appinfos, &childrte, &childRTindex); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If the partitioned table has no partitions, treat this as the |
||||||
|
* non-inheritance case. |
||||||
|
*/ |
||||||
|
if (partdesc->nparts == 0) |
||||||
|
{ |
||||||
|
parentrte->inh = false; |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
for (i = 0; i < partdesc->nparts; i++) |
||||||
|
{ |
||||||
|
Oid childOID = partdesc->oids[i]; |
||||||
|
Relation childrel; |
||||||
|
|
||||||
|
/* Open rel; we already have required locks */ |
||||||
|
childrel = heap_open(childOID, NoLock); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Temporary partitions belonging to other sessions should have been |
||||||
|
* disallowed at definition, but for paranoia's sake, let's double |
||||||
|
* check. |
||||||
|
*/ |
||||||
|
if (RELATION_IS_OTHER_TEMP(childrel)) |
||||||
|
elog(ERROR, "temporary relation from another session found as partition"); |
||||||
|
|
||||||
|
expand_single_inheritance_child(root, parentrte, parentRTindex, |
||||||
|
parentrel, top_parentrc, childrel, |
||||||
|
appinfos, &childrte, &childRTindex); |
||||||
|
|
||||||
|
/* If this child is itself partitioned, recurse */ |
||||||
|
if (childrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE) |
||||||
|
expand_partitioned_rtentry(root, childrte, childRTindex, |
||||||
|
childrel, top_parentrc, lockmode, |
||||||
|
appinfos); |
||||||
|
|
||||||
|
/* Close child relation, but keep locks */ |
||||||
|
heap_close(childrel, NoLock); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* expand_single_inheritance_child |
||||||
|
* Build a RangeTblEntry and an AppendRelInfo, if appropriate, plus |
||||||
|
* maybe a PlanRowMark. |
||||||
|
* |
||||||
|
* We now expand the partition hierarchy level by level, creating a |
||||||
|
* corresponding hierarchy of AppendRelInfos and RelOptInfos, where each |
||||||
|
* partitioned descendant acts as a parent of its immediate partitions. |
||||||
|
* (This is a difference from what older versions of PostgreSQL did and what |
||||||
|
* is still done in the case of table inheritance for unpartitioned tables, |
||||||
|
* where the hierarchy is flattened during RTE expansion.) |
||||||
|
* |
||||||
|
* PlanRowMarks still carry the top-parent's RTI, and the top-parent's |
||||||
|
* allMarkTypes field still accumulates values from all descendents. |
||||||
|
* |
||||||
|
* "parentrte" and "parentRTindex" are immediate parent's RTE and |
||||||
|
* RTI. "top_parentrc" is top parent's PlanRowMark. |
||||||
|
* |
||||||
|
* The child RangeTblEntry and its RTI are returned in "childrte_p" and |
||||||
|
* "childRTindex_p" resp. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
expand_single_inheritance_child(PlannerInfo *root, RangeTblEntry *parentrte, |
||||||
|
Index parentRTindex, Relation parentrel, |
||||||
|
PlanRowMark *top_parentrc, Relation childrel, |
||||||
|
List **appinfos, RangeTblEntry **childrte_p, |
||||||
|
Index *childRTindex_p) |
||||||
|
{ |
||||||
|
Query *parse = root->parse; |
||||||
|
Oid parentOID = RelationGetRelid(parentrel); |
||||||
|
Oid childOID = RelationGetRelid(childrel); |
||||||
|
RangeTblEntry *childrte; |
||||||
|
Index childRTindex; |
||||||
|
AppendRelInfo *appinfo; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Build an RTE for the child, and attach to query's rangetable list. We |
||||||
|
* copy most fields of the parent's RTE, but replace relation OID and |
||||||
|
* relkind, and set inh = false. Also, set requiredPerms to zero since |
||||||
|
* all required permissions checks are done on the original RTE. Likewise, |
||||||
|
* set the child's securityQuals to empty, because we only want to apply |
||||||
|
* the parent's RLS conditions regardless of what RLS properties |
||||||
|
* individual children may have. (This is an intentional choice to make |
||||||
|
* inherited RLS work like regular permissions checks.) The parent |
||||||
|
* securityQuals will be propagated to children along with other base |
||||||
|
* restriction clauses, so we don't need to do it here. |
||||||
|
*/ |
||||||
|
childrte = copyObject(parentrte); |
||||||
|
*childrte_p = childrte; |
||||||
|
childrte->relid = childOID; |
||||||
|
childrte->relkind = childrel->rd_rel->relkind; |
||||||
|
/* A partitioned child will need to be expanded further. */ |
||||||
|
if (childOID != parentOID && |
||||||
|
childrte->relkind == RELKIND_PARTITIONED_TABLE) |
||||||
|
childrte->inh = true; |
||||||
|
else |
||||||
|
childrte->inh = false; |
||||||
|
childrte->requiredPerms = 0; |
||||||
|
childrte->securityQuals = NIL; |
||||||
|
parse->rtable = lappend(parse->rtable, childrte); |
||||||
|
childRTindex = list_length(parse->rtable); |
||||||
|
*childRTindex_p = childRTindex; |
||||||
|
|
||||||
|
/*
|
||||||
|
* We need an AppendRelInfo if paths will be built for the child RTE. If |
||||||
|
* childrte->inh is true, then we'll always need to generate append paths |
||||||
|
* for it. If childrte->inh is false, we must scan it if it's not a |
||||||
|
* partitioned table; but if it is a partitioned table, then it never has |
||||||
|
* any data of its own and need not be scanned. |
||||||
|
*/ |
||||||
|
if (childrte->relkind != RELKIND_PARTITIONED_TABLE || childrte->inh) |
||||||
|
{ |
||||||
|
appinfo = make_append_rel_info(parentrel, childrel, |
||||||
|
parentRTindex, childRTindex); |
||||||
|
*appinfos = lappend(*appinfos, appinfo); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Translate the column permissions bitmaps to the child's attnums (we |
||||||
|
* have to build the translated_vars list before we can do this). But |
||||||
|
* if this is the parent table, leave copyObject's result alone. |
||||||
|
* |
||||||
|
* Note: we need to do this even though the executor won't run any |
||||||
|
* permissions checks on the child RTE. The insertedCols/updatedCols |
||||||
|
* bitmaps may be examined for trigger-firing purposes. |
||||||
|
*/ |
||||||
|
if (childOID != parentOID) |
||||||
|
{ |
||||||
|
childrte->selectedCols = translate_col_privs(parentrte->selectedCols, |
||||||
|
appinfo->translated_vars); |
||||||
|
childrte->insertedCols = translate_col_privs(parentrte->insertedCols, |
||||||
|
appinfo->translated_vars); |
||||||
|
childrte->updatedCols = translate_col_privs(parentrte->updatedCols, |
||||||
|
appinfo->translated_vars); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Build a PlanRowMark if parent is marked FOR UPDATE/SHARE. |
||||||
|
*/ |
||||||
|
if (top_parentrc) |
||||||
|
{ |
||||||
|
PlanRowMark *childrc = makeNode(PlanRowMark); |
||||||
|
|
||||||
|
childrc->rti = childRTindex; |
||||||
|
childrc->prti = top_parentrc->rti; |
||||||
|
childrc->rowmarkId = top_parentrc->rowmarkId; |
||||||
|
/* Reselect rowmark type, because relkind might not match parent */ |
||||||
|
childrc->markType = select_rowmark_type(childrte, |
||||||
|
top_parentrc->strength); |
||||||
|
childrc->allMarkTypes = (1 << childrc->markType); |
||||||
|
childrc->strength = top_parentrc->strength; |
||||||
|
childrc->waitPolicy = top_parentrc->waitPolicy; |
||||||
|
|
||||||
|
/*
|
||||||
|
* We mark RowMarks for partitioned child tables as parent RowMarks so |
||||||
|
* that the executor ignores them (except their existence means that |
||||||
|
* the child tables be locked using appropriate mode). |
||||||
|
*/ |
||||||
|
childrc->isParent = (childrte->relkind == RELKIND_PARTITIONED_TABLE); |
||||||
|
|
||||||
|
/* Include child's rowmark type in top parent's allMarkTypes */ |
||||||
|
top_parentrc->allMarkTypes |= childrc->allMarkTypes; |
||||||
|
|
||||||
|
root->rowMarks = lappend(root->rowMarks, childrc); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,42 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* appendinfo.h |
||||||
|
* Routines for mapping expressions between append rel parent(s) and |
||||||
|
* children |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* src/include/optimizer/appendinfo.h |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#ifndef APPENDINFO_H |
||||||
|
#define APPENDINFO_H |
||||||
|
|
||||||
|
#include "nodes/plannodes.h" |
||||||
|
#include "nodes/relation.h" |
||||||
|
#include "utils/relcache.h" |
||||||
|
|
||||||
|
extern AppendRelInfo *make_append_rel_info(Relation parentrel, |
||||||
|
Relation childrel, |
||||||
|
Index parentRTindex, Index childRTindex); |
||||||
|
extern Bitmapset *translate_col_privs(const Bitmapset *parent_privs, |
||||||
|
List *translated_vars); |
||||||
|
extern Node *adjust_appendrel_attrs(PlannerInfo *root, Node *node, |
||||||
|
int nappinfos, AppendRelInfo **appinfos); |
||||||
|
|
||||||
|
extern Node *adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, |
||||||
|
Relids child_relids, |
||||||
|
Relids top_parent_relids); |
||||||
|
|
||||||
|
extern AppendRelInfo **find_appinfos_by_relids(PlannerInfo *root, |
||||||
|
Relids relids, int *nappinfos); |
||||||
|
|
||||||
|
extern SpecialJoinInfo *build_child_join_sjinfo(PlannerInfo *root, |
||||||
|
SpecialJoinInfo *parent_sjinfo, |
||||||
|
Relids left_relids, Relids right_relids); |
||||||
|
extern Relids adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, |
||||||
|
Relids child_relids, Relids top_parent_relids); |
||||||
|
|
||||||
|
#endif /* APPENDINFO_H */ |
||||||
@ -0,0 +1,22 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* inherit.h |
||||||
|
* prototypes for inherit.c. |
||||||
|
* |
||||||
|
* |
||||||
|
* Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* src/include/optimizer/inherit.h |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#ifndef INHERIT_H |
||||||
|
#define INHERIT_H |
||||||
|
|
||||||
|
#include "nodes/relation.h" |
||||||
|
|
||||||
|
|
||||||
|
extern void expand_inherited_tables(PlannerInfo *root); |
||||||
|
|
||||||
|
#endif /* INHERIT_H */ |
||||||
Loading…
Reference in new issue