From 89f8740195189cc77391bdb844f5092c0440f061 Mon Sep 17 00:00:00 2001 From: amit Date: Mon, 26 Dec 2016 11:53:19 +0900 Subject: [PATCH 1/7] Allocate partition_tuple_slot in respective nodes ...instead of making it part of EState and its tuple table. Respective nodes means ModifyTableState and CopyState for now. Reported by: n/a Patch by: Amit Langote Reports: n/a --- src/backend/commands/copy.c | 30 +++++++++++++++++------------- src/backend/executor/execMain.c | 12 ++++++++++++ src/backend/executor/nodeModifyTable.c | 17 ++++++++--------- src/include/executor/executor.h | 1 + src/include/nodes/execnodes.h | 6 +++--- 5 files changed, 41 insertions(+), 25 deletions(-) diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index aa25a23336..e5a0f1bf80 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -161,11 +161,18 @@ typedef struct CopyStateData ExprState **defexprs; /* array of default att expressions */ bool volatile_defexprs; /* is any of defexprs volatile? */ List *range_table; + PartitionDispatch *partition_dispatch_info; - int num_dispatch; - int num_partitions; - ResultRelInfo *partitions; + /* Tuple-routing support info */ + int num_dispatch; /* Number of entries in the above array */ + int num_partitions; /* Number of members in the following + * arrays */ + ResultRelInfo *partitions; /* Per partition result relation */ TupleConversionMap **partition_tupconv_maps; + /* Per partition tuple conversion map */ + TupleTableSlot *partition_tuple_slot; + /* Slot used to manipulate a tuple after + * it is routed to a partition */ /* * These variables are used to reduce overhead in textual COPY FROM. @@ -1409,6 +1416,7 @@ BeginCopy(ParseState *pstate, PartitionDispatch *partition_dispatch_info; ResultRelInfo *partitions; TupleConversionMap **partition_tupconv_maps; + TupleTableSlot *partition_tuple_slot; int num_parted, num_partitions; @@ -1416,12 +1424,14 @@ BeginCopy(ParseState *pstate, &partition_dispatch_info, &partitions, &partition_tupconv_maps, + &partition_tuple_slot, &num_parted, &num_partitions); cstate->partition_dispatch_info = partition_dispatch_info; cstate->num_dispatch = num_parted; cstate->partitions = partitions; cstate->num_partitions = num_partitions; cstate->partition_tupconv_maps = partition_tupconv_maps; + cstate->partition_tuple_slot = partition_tuple_slot; } } else @@ -2436,15 +2446,6 @@ CopyFrom(CopyState cstate) estate->es_trig_tuple_slot = ExecInitExtraTupleSlot(estate); /* - * Initialize a dedicated slot to manipulate tuples of any given - * partition's rowtype. - */ - if (cstate->partition_dispatch_info) - estate->es_partition_tuple_slot = ExecInitExtraTupleSlot(estate); - else - estate->es_partition_tuple_slot = NULL; - - /* * It's more efficient to prepare a bunch of tuples for insertion, and * insert them in one heap_multi_insert() call, than call heap_insert() * separately for every tuple. However, we can't do that if there are @@ -2591,7 +2592,7 @@ CopyFrom(CopyState cstate) * we're finished dealing with the partition. */ oldslot = slot; - slot = estate->es_partition_tuple_slot; + slot = cstate->partition_tuple_slot; Assert(slot != NULL); ExecSetSlotDescriptor(slot, RelationGetDescr(partrel)); ExecStoreTuple(tuple, slot, InvalidBuffer, true); @@ -2756,6 +2757,9 @@ CopyFrom(CopyState cstate) ExecCloseIndices(resultRelInfo); heap_close(resultRelInfo->ri_RelationDesc, NoLock); } + + /* Release the standalone partition tuple descriptor */ + ExecDropSingleTupleTableSlot(cstate->partition_tuple_slot); } FreeExecutorState(estate); diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index bca34a509c..97c729d6b7 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -3012,6 +3012,9 @@ EvalPlanQualEnd(EPQState *epqstate) * entry for every leaf partition (required to convert input tuple based * on the root table's rowtype to a leaf partition's rowtype after tuple * routing is done + * 'partition_tuple_slot' receives a standalone TupleTableSlot to be used + * to manipulate any given leaf partition's rowtype after that partition + * is chosen by tuple-routing. * 'num_parted' receives the number of partitioned tables in the partition * tree (= the number of entries in the 'pd' output array) * 'num_partitions' receives the number of leaf partitions in the partition @@ -3026,6 +3029,7 @@ ExecSetupPartitionTupleRouting(Relation rel, PartitionDispatch **pd, ResultRelInfo **partitions, TupleConversionMap ***tup_conv_maps, + TupleTableSlot **partition_tuple_slot, int *num_parted, int *num_partitions) { TupleDesc tupDesc = RelationGetDescr(rel); @@ -3043,6 +3047,14 @@ ExecSetupPartitionTupleRouting(Relation rel, *tup_conv_maps = (TupleConversionMap **) palloc0(*num_partitions * sizeof(TupleConversionMap *)); + /* + * Initialize an empty slot that will be used to manipulate tuples of any + * given partition's rowtype. It is attached to the caller-specified node + * (such as ModifyTableState) and released when the node finishes + * processing. + */ + *partition_tuple_slot = MakeTupleTableSlot(); + leaf_part_rri = *partitions; i = 0; foreach(cell, leaf_parts) diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 0d85b151c2..df21f66df8 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -329,7 +329,7 @@ ExecInsert(ModifyTableState *mtstate, * Use the dedicated slot for that. */ oldslot = slot; - slot = estate->es_partition_tuple_slot; + slot = mtstate->mt_partition_tuple_slot; Assert(slot != NULL); ExecSetSlotDescriptor(slot, RelationGetDescr(partrel)); ExecStoreTuple(tuple, slot, InvalidBuffer, true); @@ -1738,6 +1738,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) PartitionDispatch *partition_dispatch_info; ResultRelInfo *partitions; TupleConversionMap **partition_tupconv_maps; + TupleTableSlot *partition_tuple_slot; int num_parted, num_partitions; @@ -1745,21 +1746,15 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) &partition_dispatch_info, &partitions, &partition_tupconv_maps, + &partition_tuple_slot, &num_parted, &num_partitions); mtstate->mt_partition_dispatch_info = partition_dispatch_info; mtstate->mt_num_dispatch = num_parted; mtstate->mt_partitions = partitions; mtstate->mt_num_partitions = num_partitions; mtstate->mt_partition_tupconv_maps = partition_tupconv_maps; - - /* - * Initialize a dedicated slot to manipulate tuples of any given - * partition's rowtype. - */ - estate->es_partition_tuple_slot = ExecInitExtraTupleSlot(estate); + mtstate->mt_partition_tuple_slot = partition_tuple_slot; } - else - estate->es_partition_tuple_slot = NULL; /* * Initialize any WITH CHECK OPTION constraints if needed. @@ -2100,6 +2095,10 @@ ExecEndModifyTable(ModifyTableState *node) heap_close(resultRelInfo->ri_RelationDesc, NoLock); } + /* Release the standalone partition tuple descriptor, if any */ + if (node->mt_partition_tuple_slot) + ExecDropSingleTupleTableSlot(node->mt_partition_tuple_slot); + /* * Free the exprcontext */ diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h index b74fa5eb5d..c217bd30cb 100644 --- a/src/include/executor/executor.h +++ b/src/include/executor/executor.h @@ -217,6 +217,7 @@ extern void ExecSetupPartitionTupleRouting(Relation rel, PartitionDispatch **pd, ResultRelInfo **partitions, TupleConversionMap ***tup_conv_maps, + TupleTableSlot **partition_tuple_slot, int *num_parted, int *num_partitions); extern int ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd, diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index d43ec56a2b..3624660861 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -384,9 +384,6 @@ typedef struct EState TupleTableSlot *es_trig_oldtup_slot; /* for TriggerEnabled */ TupleTableSlot *es_trig_newtup_slot; /* for TriggerEnabled */ - /* Slot used to manipulate a tuple after it is routed to a partition */ - TupleTableSlot *es_partition_tuple_slot; - /* Parameter info: */ ParamListInfo es_param_list_info; /* values of external params */ ParamExecData *es_param_exec_vals; /* values of internal params */ @@ -1165,6 +1162,9 @@ typedef struct ModifyTableState ResultRelInfo *mt_partitions; /* Per partition result relation */ TupleConversionMap **mt_partition_tupconv_maps; /* Per partition tuple conversion map */ + TupleTableSlot *mt_partition_tuple_slot; + /* Slot used to manipulate a tuple after + * it is routed to a partition */ } ModifyTableState; /* ---------------- -- 2.11.0