2019-01-10 18:54:31 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* 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 "nodes/makefuncs.h"
|
|
|
|
#include "nodes/nodeFuncs.h"
|
|
|
|
#include "optimizer/appendinfo.h"
|
|
|
|
#include "parser/parsetree.h"
|
|
|
|
#include "utils/lsyscache.h"
|
2019-01-16 20:27:44 +01:00
|
|
|
#include "utils/rel.h"
|
2019-01-10 18:54:31 +01:00
|
|
|
#include "utils/syscache.h"
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
PlannerInfo *root;
|
|
|
|
int nappinfos;
|
|
|
|
AppendRelInfo **appinfos;
|
|
|
|
} adjust_appendrel_attrs_context;
|
|
|
|
|
|
|
|
static void make_inh_translation_list(Relation oldrelation,
|
2019-05-22 19:04:48 +02:00
|
|
|
Relation newrelation,
|
|
|
|
Index newvarno,
|
|
|
|
List **translated_vars);
|
2019-01-10 18:54:31 +01:00
|
|
|
static Node *adjust_appendrel_attrs_mutator(Node *node,
|
2019-05-22 19:04:48 +02:00
|
|
|
adjust_appendrel_attrs_context *context);
|
2019-01-10 18:54:31 +01:00
|
|
|
static List *adjust_inherited_tlist(List *tlist,
|
2019-05-22 19:04:48 +02:00
|
|
|
AppendRelInfo *context);
|
2019-01-10 18:54:31 +01:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
2019-05-05 19:10:07 +02:00
|
|
|
if (!HeapTupleIsValid(newtup))
|
2019-01-10 18:54:31 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2019-01-16 20:27:44 +01:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2019-01-10 18:54:31 +01:00
|
|
|
/*
|
|
|
|
* Substitute child relids for parent relids in a Relid set. The array of
|
|
|
|
* appinfos specifies the substitutions to be performed.
|
|
|
|
*/
|
2019-01-16 20:27:44 +01:00
|
|
|
Relids
|
2019-01-10 18:54:31 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|