summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 39808e8)
raw | patch | inline | side by side (parent: 39808e8)
| author | Tom Lane <tgl@sss.pgh.pa.us> | |
| Sun, 7 Oct 2018 18:33:17 +0000 (14:33 -0400) | ||
| committer | Tom Lane <tgl@sss.pgh.pa.us> | |
| Sun, 7 Oct 2018 18:33:17 +0000 (14:33 -0400) |
In the wake of commit f2343653f, we no longer need some fields that
were used before to control executor lock acquisitions:
* PlannedStmt.nonleafResultRelations can go away entirely.
* partitioned_rels can go away from Append, MergeAppend, and ModifyTable.
However, ModifyTable still needs to know the RT index of the partition
root table if any, which was formerly kept in the first entry of that
list. Add a new field "rootRelation" to remember that. rootRelation is
partly redundant with nominalRelation, in that if it's set it will have
the same value as nominalRelation. However, the latter field has a
different purpose so it seems best to keep them distinct.
Amit Langote, reviewed by David Rowley and Jesper Pedersen,
and whacked around a bit more by me
Discussion: https://postgr.es/m/468c85d9-540e-66a2-1dde-fec2b741e688@lab.ntt.co.jp
were used before to control executor lock acquisitions:
* PlannedStmt.nonleafResultRelations can go away entirely.
* partitioned_rels can go away from Append, MergeAppend, and ModifyTable.
However, ModifyTable still needs to know the RT index of the partition
root table if any, which was formerly kept in the first entry of that
list. Add a new field "rootRelation" to remember that. rootRelation is
partly redundant with nominalRelation, in that if it's set it will have
the same value as nominalRelation. However, the latter field has a
different purpose so it seems best to keep them distinct.
Amit Langote, reviewed by David Rowley and Jesper Pedersen,
and whacked around a bit more by me
Discussion: https://postgr.es/m/468c85d9-540e-66a2-1dde-fec2b741e688@lab.ntt.co.jp
13 files changed:
index b91b7d27de90a5b8c2956ecabc395538f540d562..fd20aa96aa9b8a18e3cef7ac9f807ae811148d85 100644 (file)
* Vars contained in those expressions.
*/
if (plan && plan->operation == CMD_UPDATE &&
- resultRelation == plan->nominalRelation)
+ resultRelation == plan->rootRelation)
resultRelation = mtstate->resultRelInfo[0].ri_RangeTableIndex;
}
index 0fdbd119d9bca92a3df4f81dba2376a04c236420..13ef232d39b4fe68d34fb46197079e45232d6f8c 100644 (file)
pstmt->planTree = plan;
pstmt->rtable = estate->es_range_table;
pstmt->resultRelations = NIL;
- pstmt->nonleafResultRelations = NIL;
/*
* Transfer only parallel-safe subplans, leaving a NULL "hole" in the list
index c7dc9bf1362334b4e60859ada09f6d6c44418d33..0bcb2377c342719f9eb68b9399f69832b7e3b4ca 100644 (file)
leaf_part_rri = makeNode(ResultRelInfo);
InitResultRelInfo(leaf_part_rri,
partrel,
- node ? node->nominalRelation : 1,
+ node ? node->rootRelation : 1,
rootrel,
estate->es_instrument);
index 3b690b55b38e73b25b0249693b2b13e8075b6afa..e47641d572159f612b9ce3656ff5a5c77d28897e 100644 (file)
COPY_NODE_FIELD(planTree);
COPY_NODE_FIELD(rtable);
COPY_NODE_FIELD(resultRelations);
- COPY_NODE_FIELD(nonleafResultRelations);
COPY_NODE_FIELD(rootResultRelations);
COPY_NODE_FIELD(subplans);
COPY_BITMAPSET_FIELD(rewindPlanIDs);
COPY_SCALAR_FIELD(operation);
COPY_SCALAR_FIELD(canSetTag);
COPY_SCALAR_FIELD(nominalRelation);
- COPY_NODE_FIELD(partitioned_rels);
+ COPY_SCALAR_FIELD(rootRelation);
COPY_SCALAR_FIELD(partColsUpdated);
COPY_NODE_FIELD(resultRelations);
COPY_SCALAR_FIELD(resultRelIndex);
*/
COPY_NODE_FIELD(appendplans);
COPY_SCALAR_FIELD(first_partial_plan);
- COPY_NODE_FIELD(partitioned_rels);
COPY_NODE_FIELD(part_prune_info);
return newnode;
/*
* copy remainder of node
*/
- COPY_NODE_FIELD(partitioned_rels);
COPY_NODE_FIELD(mergeplans);
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
index 863d29cc57db76083a90165d092e380238dbfcb1..9f4ffac91e6b215f6fb049f1d84dd82105e7a020 100644 (file)
WRITE_NODE_FIELD(planTree);
WRITE_NODE_FIELD(rtable);
WRITE_NODE_FIELD(resultRelations);
- WRITE_NODE_FIELD(nonleafResultRelations);
WRITE_NODE_FIELD(rootResultRelations);
WRITE_NODE_FIELD(subplans);
WRITE_BITMAPSET_FIELD(rewindPlanIDs);
WRITE_ENUM_FIELD(operation, CmdType);
WRITE_BOOL_FIELD(canSetTag);
WRITE_UINT_FIELD(nominalRelation);
- WRITE_NODE_FIELD(partitioned_rels);
+ WRITE_UINT_FIELD(rootRelation);
WRITE_BOOL_FIELD(partColsUpdated);
WRITE_NODE_FIELD(resultRelations);
WRITE_INT_FIELD(resultRelIndex);
WRITE_NODE_FIELD(appendplans);
WRITE_INT_FIELD(first_partial_plan);
- WRITE_NODE_FIELD(partitioned_rels);
WRITE_NODE_FIELD(part_prune_info);
}
_outPlanInfo(str, (const Plan *) node);
- WRITE_NODE_FIELD(partitioned_rels);
WRITE_NODE_FIELD(mergeplans);
WRITE_INT_FIELD(numCols);
WRITE_ENUM_FIELD(operation, CmdType);
WRITE_BOOL_FIELD(canSetTag);
WRITE_UINT_FIELD(nominalRelation);
- WRITE_NODE_FIELD(partitioned_rels);
+ WRITE_UINT_FIELD(rootRelation);
WRITE_BOOL_FIELD(partColsUpdated);
WRITE_NODE_FIELD(resultRelations);
WRITE_NODE_FIELD(subpaths);
WRITE_NODE_FIELD(finalrtable);
WRITE_NODE_FIELD(finalrowmarks);
WRITE_NODE_FIELD(resultRelations);
- WRITE_NODE_FIELD(nonleafResultRelations);
WRITE_NODE_FIELD(rootResultRelations);
WRITE_NODE_FIELD(relationOids);
WRITE_NODE_FIELD(invalItems);
index 73ffa9714c60f72fc273af28712327f5b741ee5f..e117867de56c9b2521c031eaf25bc538d36de7b5 100644 (file)
READ_NODE_FIELD(planTree);
READ_NODE_FIELD(rtable);
READ_NODE_FIELD(resultRelations);
- READ_NODE_FIELD(nonleafResultRelations);
READ_NODE_FIELD(rootResultRelations);
READ_NODE_FIELD(subplans);
READ_BITMAPSET_FIELD(rewindPlanIDs);
READ_ENUM_FIELD(operation, CmdType);
READ_BOOL_FIELD(canSetTag);
READ_UINT_FIELD(nominalRelation);
- READ_NODE_FIELD(partitioned_rels);
+ READ_UINT_FIELD(rootRelation);
READ_BOOL_FIELD(partColsUpdated);
READ_NODE_FIELD(resultRelations);
READ_INT_FIELD(resultRelIndex);
READ_NODE_FIELD(appendplans);
READ_INT_FIELD(first_partial_plan);
- READ_NODE_FIELD(partitioned_rels);
READ_NODE_FIELD(part_prune_info);
READ_DONE();
ReadCommonPlan(&local_node->plan);
- READ_NODE_FIELD(partitioned_rels);
READ_NODE_FIELD(mergeplans);
READ_INT_FIELD(numCols);
READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
index ae41c9efa07fe55208dcd02d87b30645b8b93289..ae46b0140e506d86b2055a458f661d8da427a760 100644 (file)
static Plan *create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual,
List **qual, List **indexqual, List **indexECs);
static void bitmap_subplan_mark_shared(Plan *plan);
-static List *flatten_partitioned_rels(List *partitioned_rels);
static TidScan *create_tidscan_plan(PlannerInfo *root, TidPath *best_path,
List *tlist, List *scan_clauses);
static SubqueryScan *create_subqueryscan_plan(PlannerInfo *root,
@@ -203,8 +202,7 @@ static NamedTuplestoreScan *make_namedtuplestorescan(List *qptlist, List *qpqual
static WorkTableScan *make_worktablescan(List *qptlist, List *qpqual,
Index scanrelid, int wtParam);
static Append *make_append(List *appendplans, int first_partial_plan,
- List *tlist, List *partitioned_rels,
- PartitionPruneInfo *partpruneinfo);
+ List *tlist, PartitionPruneInfo *partpruneinfo);
static RecursiveUnion *make_recursive_union(List *tlist,
Plan *lefttree,
Plan *righttree,
static ProjectSet *make_project_set(List *tlist, Plan *subplan);
static ModifyTable *make_modifytable(PlannerInfo *root,
CmdType operation, bool canSetTag,
- Index nominalRelation, List *partitioned_rels,
+ Index nominalRelation, Index rootRelation,
bool partColsUpdated,
List *resultRelations, List *subplans, List *subroots,
List *withCheckOptionLists, List *returningLists,
*/
plan = make_append(subplans, best_path->first_partial_path,
- tlist, best_path->partitioned_rels,
- partpruneinfo);
+ tlist, partpruneinfo);
copy_generic_path_info(&plan->plan, (Path *) best_path);
prunequal);
}
- node->partitioned_rels =
- flatten_partitioned_rels(best_path->partitioned_rels);
node->mergeplans = subplans;
node->part_prune_info = partpruneinfo;
best_path->operation,
best_path->canSetTag,
best_path->nominalRelation,
- best_path->partitioned_rels,
+ best_path->rootRelation,
best_path->partColsUpdated,
best_path->resultRelations,
subplans,
elog(ERROR, "unrecognized node type: %d", nodeTag(plan));
}
-/*
- * flatten_partitioned_rels
- * Convert List of Lists into a single List with all elements from the
- * sub-lists.
- */
-static List *
-flatten_partitioned_rels(List *partitioned_rels)
-{
- List *newlist = NIL;
- ListCell *lc;
-
- foreach(lc, partitioned_rels)
- {
- List *sublist = lfirst(lc);
-
- newlist = list_concat(newlist, list_copy(sublist));
- }
-
- return newlist;
-}
-
/*****************************************************************************
*
* PLAN NODE BUILDING ROUTINES
static Append *
make_append(List *appendplans, int first_partial_plan,
- List *tlist, List *partitioned_rels,
- PartitionPruneInfo *partpruneinfo)
+ List *tlist, PartitionPruneInfo *partpruneinfo)
{
Append *node = makeNode(Append);
Plan *plan = &node->plan;
plan->righttree = NULL;
node->appendplans = appendplans;
node->first_partial_plan = first_partial_plan;
- node->partitioned_rels = flatten_partitioned_rels(partitioned_rels);
node->part_prune_info = partpruneinfo;
return node;
}
static ModifyTable *
make_modifytable(PlannerInfo *root,
CmdType operation, bool canSetTag,
- Index nominalRelation, List *partitioned_rels,
+ Index nominalRelation, Index rootRelation,
bool partColsUpdated,
List *resultRelations, List *subplans, List *subroots,
List *withCheckOptionLists, List *returningLists,
node->operation = operation;
node->canSetTag = canSetTag;
node->nominalRelation = nominalRelation;
- node->partitioned_rels = flatten_partitioned_rels(partitioned_rels);
+ node->rootRelation = rootRelation;
node->partColsUpdated = partColsUpdated;
node->resultRelations = resultRelations;
node->resultRelIndex = -1; /* will be set correctly in setrefs.c */
index 89625f4f5b18dca8a0f3256c7bef603cd32f064e..c729a99f8b659364ccfaba1e6c0cd18be69e10a1 100644 (file)
glob->finalrtable = NIL;
glob->finalrowmarks = NIL;
glob->resultRelations = NIL;
- glob->nonleafResultRelations = NIL;
glob->rootResultRelations = NIL;
glob->relationOids = NIL;
glob->invalItems = NIL;
Assert(glob->finalrtable == NIL);
Assert(glob->finalrowmarks == NIL);
Assert(glob->resultRelations == NIL);
- Assert(glob->nonleafResultRelations == NIL);
Assert(glob->rootResultRelations == NIL);
top_plan = set_plan_references(root, top_plan);
/* ... and the subplans (both regular subplans and initplans) */
result->planTree = top_plan;
result->rtable = glob->finalrtable;
result->resultRelations = glob->resultRelations;
- result->nonleafResultRelations = glob->nonleafResultRelations;
result->rootResultRelations = glob->rootResultRelations;
result->subplans = glob->subplans;
result->rewindPlanIDs = glob->rewindPlanIDs;
Bitmapset *subqueryRTindexes;
Bitmapset *modifiableARIindexes;
int nominalRelation = -1;
+ Index rootRelation = 0;
List *final_rtable = NIL;
int save_rel_array_size = 0;
RelOptInfo **save_rel_array = NULL;
ListCell *lc;
Index rti;
RangeTblEntry *parent_rte;
- Relids partitioned_relids = NULL;
- List *partitioned_rels = NIL;
PlannerInfo *parent_root;
Query *parent_parse;
Bitmapset *parent_relids = bms_make_singleton(top_parentRTindex);
/*
* If the parent RTE is a partitioned table, we should use that as the
- * nominal relation, because the RTEs added for partitioned tables
+ * nominal target relation, because the RTEs added for partitioned tables
* (including the root parent) as child members of the inheritance set do
- * not appear anywhere else in the plan. The situation is exactly the
- * opposite in the case of non-partitioned inheritance parent as described
- * below. For the same reason, collect the list of descendant partitioned
- * tables to be saved in ModifyTable node, so that executor can lock those
- * as well.
+ * not appear anywhere else in the plan, so the confusion explained below
+ * for non-partitioning inheritance cases is not possible.
*/
parent_rte = rt_fetch(top_parentRTindex, root->parse->rtable);
if (parent_rte->relkind == RELKIND_PARTITIONED_TABLE)
{
nominalRelation = top_parentRTindex;
-
- /*
- * Root parent's RT index is always present in the partitioned_rels of
- * the ModifyTable node, if one is needed at all.
- */
- partitioned_relids = bms_make_singleton(top_parentRTindex);
+ rootRelation = top_parentRTindex;
}
/*
* inheritance parent.
*/
subroot->inhTargetKind =
- partitioned_relids ? INHKIND_PARTITIONED : INHKIND_INHERITED;
+ (rootRelation != 0) ? INHKIND_PARTITIONED : INHKIND_INHERITED;
/*
* If this child is further partitioned, remember it as a parent.
/*
* Set the nominal target relation of the ModifyTable node if not
- * already done. We use the inheritance parent RTE as the nominal
- * target relation if it's a partitioned table (see just above this
- * loop). In the non-partitioned parent case, we'll use the first
- * child relation (even if it's excluded) as the nominal target
- * relation. Because of the way expand_inherited_rtentry works, the
- * latter should be the RTE representing the parent table in its role
- * as a simple member of the inheritance set.
+ * already done. If the target is a partitioned table, we already set
+ * nominalRelation to refer to the partition root, above. For
+ * non-partitioned inheritance cases, we'll use the first child
+ * relation (even if it's excluded) as the nominal target relation.
+ * Because of the way expand_inherited_rtentry works, that should be
+ * the RTE representing the parent table in its role as a simple
+ * member of the inheritance set.
*
* It would be logically cleaner to *always* use the inheritance
* parent RTE as the nominal relation; but that RTE is not otherwise
if (IS_DUMMY_PATH(subpath))
continue;
- /*
- * Add the current parent's RT index to the partitioned_relids set if
- * we're creating the ModifyTable path for a partitioned root table.
- * (We only care about parents of non-excluded children.)
- */
- if (partitioned_relids)
- partitioned_relids = bms_add_member(partitioned_relids,
- appinfo->parent_relid);
-
/*
* If this is the first non-excluded child, its post-planning rtable
* becomes the initial contents of final_rtable; otherwise, append
else
rowMarks = root->rowMarks;
- if (partitioned_relids)
- {
- int i;
-
- i = -1;
- while ((i = bms_next_member(partitioned_relids, i)) >= 0)
- partitioned_rels = lappend_int(partitioned_rels, i);
-
- /*
- * If we're going to create ModifyTable at all, the list should
- * contain at least one member, that is, the root parent's index.
- */
- Assert(list_length(partitioned_rels) >= 1);
- partitioned_rels = list_make1(partitioned_rels);
- }
-
/* Create Path representing a ModifyTable to do the UPDATE/DELETE work */
add_path(final_rel, (Path *)
create_modifytable_path(root, final_rel,
parse->commandType,
parse->canSetTag,
nominalRelation,
- partitioned_rels,
+ rootRelation,
root->partColsUpdated,
resultRelations,
subpaths,
*/
if (parse->commandType != CMD_SELECT && !inheritance_update)
{
+ Index rootRelation;
List *withCheckOptionLists;
List *returningLists;
List *rowMarks;
+ /*
+ * If target is a partition root table, we need to mark the
+ * ModifyTable node appropriately for that.
+ */
+ if (rt_fetch(parse->resultRelation, parse->rtable)->relkind ==
+ RELKIND_PARTITIONED_TABLE)
+ rootRelation = parse->resultRelation;
+ else
+ rootRelation = 0;
+
/*
* Set up the WITH CHECK OPTION and RETURNING lists-of-lists, if
* needed.
parse->commandType,
parse->canSetTag,
parse->resultRelation,
- NIL,
+ rootRelation,
false,
list_make1_int(parse->resultRelation),
list_make1(path),
index 54293e25aff8ffa01bebbe97089923f8be2543b3..6d6ef1c3769d6c545bd8452978029ef007f9b8d7 100644 (file)
}
splan->nominalRelation += rtoffset;
+ if (splan->rootRelation)
+ splan->rootRelation += rtoffset;
splan->exclRelRTI += rtoffset;
- foreach(l, splan->partitioned_rels)
- {
- lfirst_int(l) += rtoffset;
- }
foreach(l, splan->resultRelations)
{
lfirst_int(l) += rtoffset;
list_copy(splan->resultRelations));
/*
- * If the main target relation is a partitioned table, the
- * following list contains the RT indexes of partitioned child
- * relations including the root, which are not included in the
- * above list. We also keep RT indexes of the roots
- * separately to be identified as such during the executor
- * initialization.
+ * If the main target relation is a partitioned table, also
+ * add the partition root's RT index to rootResultRelations,
+ * and remember its index in that list in rootResultRelIndex.
*/
- if (splan->partitioned_rels != NIL)
+ if (splan->rootRelation)
{
- root->glob->nonleafResultRelations =
- list_concat(root->glob->nonleafResultRelations,
- list_copy(splan->partitioned_rels));
- /* Remember where this root will be in the global list. */
splan->rootResultRelIndex =
list_length(root->glob->rootResultRelations);
root->glob->rootResultRelations =
lappend_int(root->glob->rootResultRelations,
- linitial_int(splan->partitioned_rels));
+ splan->rootRelation);
}
}
break;
*/
set_dummy_tlist_references(plan, rtoffset);
Assert(splan->plan.qual == NIL);
- foreach(l, splan->partitioned_rels)
- {
- lfirst_int(l) += rtoffset;
- }
foreach(l, splan->appendplans)
{
lfirst(l) = set_plan_refs(root,
*/
set_dummy_tlist_references(plan, rtoffset);
Assert(splan->plan.qual == NIL);
- foreach(l, splan->partitioned_rels)
- {
- lfirst_int(l) += rtoffset;
- }
foreach(l, splan->mergeplans)
{
lfirst(l) = set_plan_refs(root,
index c5aaaf5c2202e3bcc245fa812535fe749bf55fc6..d50d86b252fe3eb5e2a9e5bf6c65a316be1db3b3 100644 (file)
* 'operation' is the operation type
* 'canSetTag' is true if we set the command tag/es_processed
* 'nominalRelation' is the parent RT index for use of EXPLAIN
- * 'partitioned_rels' is an integer list of RT indexes of non-leaf tables in
- * the partition tree, if this is an UPDATE/DELETE to a partitioned table.
- * Otherwise NIL.
+ * 'rootRelation' is the partitioned table root RT index, or 0 if none
* 'partColsUpdated' is true if any partitioning columns are being updated,
* either from the target relation or a descendent partitioned table.
* 'resultRelations' is an integer list of actual RT indexes of target rel(s)
ModifyTablePath *
create_modifytable_path(PlannerInfo *root, RelOptInfo *rel,
CmdType operation, bool canSetTag,
- Index nominalRelation, List *partitioned_rels,
+ Index nominalRelation, Index rootRelation,
bool partColsUpdated,
List *resultRelations, List *subpaths,
List *subroots,
pathnode->operation = operation;
pathnode->canSetTag = canSetTag;
pathnode->nominalRelation = nominalRelation;
- pathnode->partitioned_rels = list_copy(partitioned_rels);
+ pathnode->rootRelation = rootRelation;
pathnode->partColsUpdated = partColsUpdated;
pathnode->resultRelations = resultRelations;
pathnode->subpaths = subpaths;
index 8b3743705769224cafa51aca55d672cc2310642c..5e3d4cdc58d8924c3e04e0a6b1422a555ac91cf1 100644 (file)
List *resultRelations; /* integer list of RT indexes, or NIL */
/*
- * rtable indexes of non-leaf target relations for UPDATE/DELETE on all
- * the partitioned tables mentioned in the query.
- */
- List *nonleafResultRelations;
-
- /*
- * rtable indexes of root target relations for UPDATE/DELETE; this list
- * maintains a subset of the RT indexes in nonleafResultRelations,
- * indicating the roots of the respective partition hierarchies.
+ * rtable indexes of partitioned table roots that are UPDATE/DELETE
+ * targets; needed for trigger firing.
*/
List *rootResultRelations;
* Apply rows produced by subplan(s) to result table(s),
* by inserting, updating, or deleting.
*
+ * If the originally named target table is a partitioned table, both
+ * nominalRelation and rootRelation contain the RT index of the partition
+ * root, which is not otherwise mentioned in the plan. Otherwise rootRelation
+ * is zero. However, nominalRelation will always be set, as it's the rel that
+ * EXPLAIN should claim is the INSERT/UPDATE/DELETE target.
+ *
* Note that rowMarks and epqParam are presumed to be valid for all the
* subplan(s); they can't contain any info that varies across subplans.
* ----------------
CmdType operation; /* INSERT, UPDATE, or DELETE */
bool canSetTag; /* do we set the command tag/es_processed? */
Index nominalRelation; /* Parent RT index for use of EXPLAIN */
- /* RT indexes of non-leaf tables in a partition tree */
- List *partitioned_rels;
+ Index rootRelation; /* Root RT index, if target is partitioned */
bool partColsUpdated; /* some part key in hierarchy updated */
List *resultRelations; /* integer list of RT indexes */
int resultRelIndex; /* index of first resultRel in plan's list */
*/
int first_partial_plan;
- /* RT indexes of non-leaf tables in a partition tree */
- List *partitioned_rels;
-
/* Info for run-time subplan pruning; NULL if we're not doing that */
struct PartitionPruneInfo *part_prune_info;
} Append;
typedef struct MergeAppend
{
Plan plan;
- /* RT indexes of non-leaf tables in a partition tree */
- List *partitioned_rels;
List *mergeplans;
- /* remaining fields are just like the sort-key info in struct Sort */
+ /* these fields are just like the sort-key info in struct Sort: */
int numCols; /* number of sort-key columns */
AttrNumber *sortColIdx; /* their indexes in the target list */
Oid *sortOperators; /* OIDs of operators to sort them by */
index adb42650479d81b03a4d4c4cf2ee59ed1bd7ad4c..88d37236f7d3c70e0dfbe066151e41f32b860b09 100644 (file)
List *resultRelations; /* "flat" list of integer RT indexes */
- List *nonleafResultRelations; /* "flat" list of integer RT indexes */
List *rootResultRelations; /* "flat" list of integer RT indexes */
List *relationOids; /* OIDs of relations the plan depends on */
CmdType operation; /* INSERT, UPDATE, or DELETE */
bool canSetTag; /* do we set the command tag/es_processed? */
Index nominalRelation; /* Parent RT index for use of EXPLAIN */
- /* RT indexes of non-leaf tables in a partition tree */
- List *partitioned_rels;
+ Index rootRelation; /* Root RT index, if target is partitioned */
bool partColsUpdated; /* some part key in hierarchy updated */
List *resultRelations; /* integer list of RT indexes */
List *subpaths; /* Path(s) producing source data */
index 7c5ff226501256893521a8a53e5a6a0c6d7657cf..81abcf53a83ea9a6d22f1a4cfab4c3b4ea088e41 100644 (file)
extern ModifyTablePath *create_modifytable_path(PlannerInfo *root,
RelOptInfo *rel,
CmdType operation, bool canSetTag,
- Index nominalRelation, List *partitioned_rels,
+ Index nominalRelation, Index rootRelation,
bool partColsUpdated,
List *resultRelations, List *subpaths,
List *subroots,