diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index d869ac5..04a24c6 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -170,7 +170,6 @@ typedef struct CopyStateData PartitionTupleRouting *partition_tuple_routing; TransitionCaptureState *transition_capture; - TupleConversionMap **transition_tupconv_maps; /* * These variables are used to reduce overhead in textual COPY FROM. @@ -2481,19 +2480,7 @@ CopyFrom(CopyState cstate) * tuple). */ if (cstate->transition_capture != NULL) - { - int i; - - cstate->transition_tupconv_maps = (TupleConversionMap **) - palloc0(sizeof(TupleConversionMap *) * proute->num_partitions); - for (i = 0; i < proute->num_partitions; ++i) - { - cstate->transition_tupconv_maps[i] = - convert_tuples_by_name(RelationGetDescr(proute->partitions[i]->ri_RelationDesc), - RelationGetDescr(cstate->rel), - gettext_noop("could not convert row type")); - } - } + ExecSetupChildParentMapForLeaf(proute); } /* @@ -2650,7 +2637,8 @@ CopyFrom(CopyState cstate) */ cstate->transition_capture->tcs_original_insert_tuple = NULL; cstate->transition_capture->tcs_map = - cstate->transition_tupconv_maps[leaf_part_index]; + TupConvMapForLeaf(proute, saved_resultRelInfo, + leaf_part_index); } else { @@ -2667,7 +2655,7 @@ CopyFrom(CopyState cstate) * We might need to convert from the parent rowtype to the * partition rowtype. */ - tuple = ConvertPartitionTupleSlot(proute->partition_tupconv_maps[leaf_part_index], + tuple = ConvertPartitionTupleSlot(proute->parent_child_tupconv_maps[leaf_part_index], tuple, proute->partition_tuple_slot, &slot); diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c index 5100d82..9d3677f 100644 --- a/src/backend/executor/execPartition.c +++ b/src/backend/executor/execPartition.c @@ -73,7 +73,7 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, proute->num_partitions = list_length(leaf_parts); proute->partitions = (ResultRelInfo **) palloc(proute->num_partitions * sizeof(ResultRelInfo *)); - proute->partition_tupconv_maps = + proute->parent_child_tupconv_maps = (TupleConversionMap **) palloc0(proute->num_partitions * sizeof(TupleConversionMap *)); @@ -198,7 +198,7 @@ ExecSetupPartitionTupleRouting(ModifyTableState *mtstate, * Save a tuple conversion map to convert a tuple routed to this * partition from the parent's type to the partition's. */ - proute->partition_tupconv_maps[i] = + proute->parent_child_tupconv_maps[i] = convert_tuples_by_name(tupDesc, part_tupdesc, gettext_noop("could not convert row type")); @@ -358,6 +358,69 @@ ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd, } /* + * Initialize the per-leaf-partition child-to-root tuple conversion map array. + * + * This map is required for capturing transition tuples when the target table + * is a partitioned table. For tuple that is routed by INSERT or UPDATE, we + * need to convert from the leaf partition to the target table descriptor. + * + */ +void +ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute) +{ + Assert(proute != NULL); + + /* + * These array elements gets filled up with maps on an on-demand basis. + * Initially just set all of them to NULL. + */ + proute->child_parent_tupconv_maps = + palloc0(sizeof(TupleConversionMap *) * proute->num_partitions); + + /* Same is the case for this array. */ + proute->child_parent_tupconv_map_not_reqd = + (bool *) palloc0(sizeof(bool) * proute->num_partitions); +} + +/* + * TupConvMapForLeaf -- For a given leaf partitions index, get the tuple + * conversion map. + */ +TupleConversionMap * +TupConvMapForLeaf(PartitionTupleRouting *proute, + ResultRelInfo *rootRelInfo, int leaf_index) +{ + Assert(leaf_index >= 0 && leaf_index < proute->num_partitions); + Assert(proute->child_parent_tupconv_maps != NULL); + + /* If it is already determined that the map is not required, return NULL. */ + if (proute->child_parent_tupconv_map_not_reqd[leaf_index]) + return NULL; + else + { + ResultRelInfo **resultRelInfos = proute->partitions; + TupleConversionMap **map = proute->child_parent_tupconv_maps + leaf_index; + + /* + * Either the map is already allocated, or it is yet to be determined + * if the map is required. + */ + if (!*map) + { + *map = + convert_tuples_by_name(RelationGetDescr(resultRelInfos[leaf_index]->ri_RelationDesc), + RelationGetDescr(rootRelInfo->ri_RelationDesc), + gettext_noop("could not convert row type")); + + /* Update the array element with the new info */ + proute->child_parent_tupconv_map_not_reqd[leaf_index] = + (*map == NULL); + } + return *map; + } +} + +/* * ConvertPartitionTupleSlot -- convenience function for tuple conversion using * 'map'. The tuple, if converted, is stored in 'new_slot', and 'p_my_slot' is * updated with the 'new_slot'. 'new_slot' typically should be one of the diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 5f1c51f..0335339 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -64,7 +64,9 @@ static bool ExecOnConflictUpdate(ModifyTableState *mtstate, EState *estate, bool canSetTag, TupleTableSlot **returning); -static void ExecSetupChildParentMap(ModifyTableState *mtstate, bool perleaf); +static ResultRelInfo *getASTriggerResultRelInfo(ModifyTableState *node); +static void ExecSetupChildParentMapForTcs(ModifyTableState *mtstate); +static void ExecSetupChildParentMapForSubplan(ModifyTableState *mtstate); static inline TupleConversionMap *tupconv_map_for_subplan(ModifyTableState *node, int whichplan); /* @@ -336,9 +338,10 @@ ExecInsert(ModifyTableState *mtstate, */ mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL; - Assert(mtstate->mt_is_tupconv_perpart); mtstate->mt_transition_capture->tcs_map = - mtstate->mt_childparent_tupconv_maps[leaf_part_index]; + TupConvMapForLeaf(proute, + getASTriggerResultRelInfo(mtstate), + leaf_part_index); } else { @@ -352,16 +355,16 @@ ExecInsert(ModifyTableState *mtstate, } if (mtstate->mt_oc_transition_capture != NULL) { - Assert(mtstate->mt_is_tupconv_perpart); mtstate->mt_oc_transition_capture->tcs_map = - mtstate->mt_childparent_tupconv_maps[leaf_part_index]; + TupConvMapForLeaf(proute, getASTriggerResultRelInfo(mtstate), + leaf_part_index); } /* * We might need to convert from the parent rowtype to the partition * rowtype. */ - tuple = ConvertPartitionTupleSlot(proute->partition_tupconv_maps[leaf_part_index], + tuple = ConvertPartitionTupleSlot(proute->parent_child_tupconv_maps[leaf_part_index], tuple, proute->partition_tuple_slot, &slot); @@ -1682,8 +1685,7 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate) if (mtstate->mt_transition_capture != NULL || mtstate->mt_oc_transition_capture != NULL) { - ExecSetupChildParentMap(mtstate, - (mtstate->mt_partition_tuple_routing != NULL)); + ExecSetupChildParentMapForTcs(mtstate); /* * Install the conversion map for the first plan for UPDATE and DELETE @@ -1698,55 +1700,32 @@ ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate) } /* - * Initialize the child-to-root tuple conversion map array. + * Initialize the child-to-root tuple conversion map array for UPDATE subplans. * * This map array is required for two purposes: * 1. For update-tuple-routing. We need to convert the tuple from the subplan * result rel to the root partitioned table descriptor. - * 2. For capturing transition tuples when the target table is a partitioned - * table. For updates, we need to convert the tuple from the subplan result - * rel to the target table descriptor, and for inserts, we need to convert - * the inserted tuple from the leaf partition to the target table - * descriptor. - * - * The caller can request either a per-subplan map or per-leaf-partition map. + * 2. For capturing transition tuples For updates, we need to convert the tuple + * from the subplan result rel to the target table descriptor. */ -static void -ExecSetupChildParentMap(ModifyTableState *mtstate, bool perleaf) +void +ExecSetupChildParentMapForSubplan(ModifyTableState *mtstate) { ResultRelInfo *rootRelInfo = getASTriggerResultRelInfo(mtstate); - PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing; + ResultRelInfo *resultRelInfos = mtstate->resultRelInfo; TupleDesc outdesc; - int numResultRelInfos; + int numResultRelInfos = mtstate->mt_nplans; int i; - /* First check if there is already one */ - if (mtstate->mt_childparent_tupconv_maps) - { - /* - * If per-leaf map is required and the map is already created, that map - * has to be per-leaf. If that map is per-subplan, we won't be able to - * access the maps leaf-partition-wise. But if the map is per-leaf, we - * will be able to access the maps subplan-wise using the - * subplan_partition_offsets map using function - * tupconv_map_for_subplan(). So if the callers might need to access - * the map both leaf-partition-wise and subplan-wise, they should make - * sure that the first time this function is called, it should be - * called with perleaf=true so that the map created is per-leaf, not - * per-subplan. - */ - Assert(!(perleaf && !mtstate->mt_is_tupconv_perpart)); + /* + * First check if there is already one. Even if there is already a per-leaf + * map, we won't require a per-subplan one, since we will use the subplan + * offset array to convert the subplan index to per-leaf index. + */ + if (mtstate->mt_per_subplan_tupconv_maps || + (mtstate->mt_partition_tuple_routing && + mtstate->mt_partition_tuple_routing->child_parent_tupconv_maps)) return; - } - - /* If perleaf is true, partition tuple routing info has to be present */ - Assert(!perleaf || proute != NULL); - - numResultRelInfos = (perleaf ? proute->num_partitions : - mtstate->mt_nplans); - - /* Get tuple descriptor of the root partitioned table. */ - outdesc = RelationGetDescr(rootRelInfo->ri_RelationDesc); /* * Build array of conversion maps from each child's TupleDesc to the @@ -1754,48 +1733,55 @@ ExecSetupChildParentMap(ModifyTableState *mtstate, bool perleaf) * conversion is necessary, which is hopefully a common case for * partitions. */ - mtstate->mt_childparent_tupconv_maps = (TupleConversionMap **) + + /* Get tuple descriptor of the root partitioned table. */ + outdesc = RelationGetDescr(rootRelInfo->ri_RelationDesc); + + mtstate->mt_per_subplan_tupconv_maps = palloc(sizeof(TupleConversionMap *) * numResultRelInfos); - /* Choose the right set of partitions */ - if (perleaf) + for (i = 0; i < numResultRelInfos; ++i) { - /* - * For tuple routing among partitions, we need TupleDescs based on the - * partition routing table. - */ - ResultRelInfo **resultRelInfos; - - resultRelInfos = proute->partitions; + mtstate->mt_per_subplan_tupconv_maps[i] = + convert_tuples_by_name(RelationGetDescr(resultRelInfos[i].ri_RelationDesc), + outdesc, + gettext_noop("could not convert row type")); + } +} - for (i = 0; i < numResultRelInfos; ++i) - { - mtstate->mt_childparent_tupconv_maps[i] = - convert_tuples_by_name(RelationGetDescr(resultRelInfos[i]->ri_RelationDesc), - outdesc, - gettext_noop("could not convert row type")); - } +/* + * Initialize the child-to-root tuple conversion map array required for + * capturing transition tuples. + * + * For updates, a per-subplan map is required, and additionally a + * per-leaf-partition map is required when tuples are routed in case of updates + * or inserts. + */ +static void +ExecSetupChildParentMapForTcs(ModifyTableState *mtstate) +{ + PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing; + /* + * For transition tables, we need a subplan-indexed access, and where + * tuple-routing is present, we also require a leaf-indexed access. + */ + if (proute) + { /* - * Save the info that the tuple conversion map is per-leaf, not - * per-subplan + * If per-leaf map is to be created, the subplan map has to be NULL. + * If the subplan map is already created, we won't be able to access + * the map leaf-partition-wise. But if the map is per-leaf, we will be + * able to access the maps subplan-wise using the + * subplan_partition_offsets map using function + * tupconv_map_for_subplan(). */ - mtstate->mt_is_tupconv_perpart = true; - } - else - { - /* Otherwise we need the ResultRelInfo for each subplan. */ - ResultRelInfo *resultRelInfos = mtstate->resultRelInfo; + Assert(mtstate->mt_per_subplan_tupconv_maps == NULL); - for (i = 0; i < numResultRelInfos; ++i) - { - mtstate->mt_childparent_tupconv_maps[i] = - convert_tuples_by_name(RelationGetDescr(resultRelInfos[i].ri_RelationDesc), - outdesc, - gettext_noop("could not convert row type")); - } + ExecSetupChildParentMapForLeaf(proute); } - + else + ExecSetupChildParentMapForSubplan(mtstate); } /* @@ -1804,13 +1790,11 @@ ExecSetupChildParentMap(ModifyTableState *mtstate, bool perleaf) static inline TupleConversionMap * tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan) { - Assert(mtstate->mt_childparent_tupconv_maps != NULL); - /* * If the tuple conversion map array is per-partition, we need to first get * the index into the partition array. */ - if (mtstate->mt_is_tupconv_perpart) + if (mtstate->mt_per_subplan_tupconv_maps == NULL) { int leaf_index; PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing; @@ -1818,13 +1802,13 @@ tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan) Assert(proute && proute->subplan_partition_offsets != NULL); leaf_index = proute->subplan_partition_offsets[whichplan]; - Assert(leaf_index >= 0 && leaf_index < proute->num_partitions); - return mtstate->mt_childparent_tupconv_maps[leaf_index]; + return TupConvMapForLeaf(proute, getASTriggerResultRelInfo(mtstate), + leaf_index); } else { Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans); - return mtstate->mt_childparent_tupconv_maps[whichplan]; + return mtstate->mt_per_subplan_tupconv_maps[whichplan]; } } @@ -2270,7 +2254,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) * from the root. Skip this setup if it's not a partition key update. */ if (update_tuple_routing_needed) - ExecSetupChildParentMap(mtstate, false); + ExecSetupChildParentMapForSubplan(mtstate); /* * Initialize any WITH CHECK OPTION constraints if needed. diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h index 0afa41e..06e6edd 100644 --- a/src/include/executor/execPartition.h +++ b/src/include/executor/execPartition.h @@ -62,11 +62,22 @@ typedef struct PartitionDispatchData *PartitionDispatch; * for every leaf partition in the partition tree. * num_partitions Number of leaf partitions in the partition tree * (= 'partitions' array length) - * partition_tupconv_maps Array of TupleConversionMap objects with one + * parent_child_tupconv_maps Array of TupleConversionMap objects with one * 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) + * child_parent_tupconv_maps Array of TupleConversionMap objects with one + * entry for every leaf partition (required to + * convert input tuple based on the leaf + * partition's rowtype to the root table's rowtype + * after tuple routing is done) + * child_parent_tupconv_map_not_reqd + * Array of bool. True value means that a map is + * determined to be not required for the given + * partition. False means either we haven't yet + * checked if a map is required, or it was + * determined to be required. * subplan_partition_offsets int array ordered by UPDATE subplans. Each * element of this array has the index into the * corresponding partition in 'partitions' array. @@ -82,7 +93,9 @@ typedef struct PartitionTupleRouting int num_dispatch; ResultRelInfo **partitions; int num_partitions; - TupleConversionMap **partition_tupconv_maps; + TupleConversionMap **parent_child_tupconv_maps; + TupleConversionMap **child_parent_tupconv_maps; + bool *child_parent_tupconv_map_not_reqd; int *subplan_partition_offsets; TupleTableSlot *partition_tuple_slot; TupleTableSlot *root_tuple_slot; @@ -95,6 +108,9 @@ extern int ExecFindPartition(ResultRelInfo *resultRelInfo, PartitionDispatch *pd, TupleTableSlot *slot, EState *estate); +extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute); +extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute, + ResultRelInfo *rootRelInfo, int leaf_index); extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map, HeapTuple tuple, TupleTableSlot *new_slot, diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 8b5391d..defd5cd 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -991,9 +991,8 @@ typedef struct ModifyTableState /* controls transition table population for specified operation */ struct TransitionCaptureState *mt_oc_transition_capture; /* controls transition table population for INSERT...ON CONFLICT UPDATE */ - TupleConversionMap **mt_childparent_tupconv_maps; - /* Per plan/partition map for tuple conversion from child to root */ - bool mt_is_tupconv_perpart; /* Is the above map per-partition ? */ + TupleConversionMap **mt_per_subplan_tupconv_maps; + /* Per plan map for tuple conversion from child to root */ } ModifyTableState; /* ----------------