Generalize ri_RootToPartitionMap to use for non-partition children

ri_RootToPartitionMap is currently only initialized for tuple routing
target partitions, though a future commit will need the ability to use
it even for the non-partition child tables, so make adjustments to the
decouple it from the partitioning code.

Also, make it lazily initialized via ExecGetRootToChildMap(), making
that function its preferred access path.  Existing third-party code
accessing it directly should no longer do so; consequently, it's been
renamed to ri_RootToChildMap, which also makes it consistent with
ri_ChildToRootMap.

ExecGetRootToChildMap() houses the logic of setting the map appropriately
depending on whether a given child relation is partition or not.

To support this, also add a separate entry point for TupleConversionMap
creation that receives an AttrMap.  No new code here, just split an
existing function in two.

Author: Amit Langote <[email protected]>
Discussion: https://postgr.es/m/CA+HiwqEYUhDXSK5BTvG_xk=eaAEJCD4GS3C6uH7ybBvv+Z_Tmg@mail.gmail.com

diff --git a/src/backend/access/common/tupconvert.c b/src/backend/access/common/tupconvert.c
index b2f892d2fdf0bbfcf855de5d943ca979e822ff53..4023f533d74d944f9972fe368469bc2df41425bc 100644 (file)
--- a/src/backend/access/common/tupconvert.c
+++ b/src/backend/access/common/tupconvert.c
@@ -102,9 +102,7 @@ TupleConversionMap *
 convert_tuples_by_name(TupleDesc indesc,
                                           TupleDesc outdesc)
 {
-       TupleConversionMap *map;
        AttrMap    *attrMap;
-       int                     n = outdesc->natts;
 
        /* Verify compatibility and prepare attribute-number map */
        attrMap = build_attrmap_by_name_if_req(indesc, outdesc, false);
@@ -115,6 +113,23 @@ convert_tuples_by_name(TupleDesc indesc,
                return NULL;
        }
 
+       return convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
+}
+
+/*
+ * Set up tuple conversion for input and output TupleDescs using the given
+ * AttrMap.
+ */
+TupleConversionMap *
+convert_tuples_by_name_attrmap(TupleDesc indesc,
+                                                          TupleDesc outdesc,
+                                                          AttrMap *attrMap)
+{
+       int                     n = outdesc->natts;
+       TupleConversionMap *map;
+
+       Assert(attrMap != NULL);
+
        /* Prepare the map structure */
        map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap));
        map->indesc = indesc;

diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c
index a079c70152f4b953d3bd8f85fbfdfac159051a98..504afcb8110cb5d5cb54188e628ae6eca9080158 100644 (file)
--- a/src/backend/commands/copyfrom.c
+++ b/src/backend/commands/copyfrom.c
@@ -1088,7 +1088,7 @@ CopyFrom(CopyFromState cstate)
                         * We might need to convert from the root rowtype to the partition
                         * rowtype.
                         */
-                       map = resultRelInfo->ri_RootToPartitionMap;
+                       map = ExecGetRootToChildMap(resultRelInfo, estate);
                        if (insertMethod == CIM_SINGLE || !leafpart_use_multi_insert)
                        {
                                /* non batch insert */

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index b6751da5743a22c140c12b8daf018fb06e2187b9..12ff4f3de582a6fa36bbff4cd871144e4ea43c13 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1256,9 +1256,11 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo,
         * this field is filled in ExecInitModifyTable().
         */
        resultRelInfo->ri_RootResultRelInfo = partition_root_rri;
-       resultRelInfo->ri_RootToPartitionMap = NULL;    /* set by
-                                                                                                        * ExecInitRoutingInfo */
-       resultRelInfo->ri_PartitionTupleSlot = NULL;    /* ditto */
+       /* Set by ExecGetRootToChildMap */
+       resultRelInfo->ri_RootToChildMap = NULL;
+       resultRelInfo->ri_RootToChildMapValid = false;
+       /* Set by ExecInitRoutingInfo */
+       resultRelInfo->ri_PartitionTupleSlot = NULL;
        resultRelInfo->ri_ChildToRootMap = NULL;
        resultRelInfo->ri_ChildToRootMapValid = false;
        resultRelInfo->ri_CopyMultiInsertBuffer = NULL;

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 8e6453aec2a52b8f39bc9da05c65ccf33e18d80f..88d0ea3adb1fae26f24ed887398e544e4c51ebbf 100644 (file)
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -463,7 +463,7 @@ ExecFindPartition(ModifyTableState *mtstate,
                         */
                        if (is_leaf)
                        {
-                               TupleConversionMap *map = rri->ri_RootToPartitionMap;
+                               TupleConversionMap *map = ExecGetRootToChildMap(rri, estate);
 
                                if (map)
                                        slot = execute_attr_map_slot(map->attrMap, rootslot,
@@ -727,7 +727,7 @@ ExecInitPartitionInfo(ModifyTableState *mtstate, EState *estate,
                        OnConflictSetState *onconfl = makeNode(OnConflictSetState);
                        TupleConversionMap *map;
 
-                       map = leaf_part_rri->ri_RootToPartitionMap;
+                       map = ExecGetRootToChildMap(leaf_part_rri, estate);
 
                        Assert(node->onConflictSet != NIL);
                        Assert(rootResultRelInfo->ri_onConflict != NULL);
@@ -977,33 +977,24 @@ ExecInitRoutingInfo(ModifyTableState *mtstate,
                                        int partidx,
                                        bool is_borrowed_rel)
 {
-       ResultRelInfo *rootRelInfo = partRelInfo->ri_RootResultRelInfo;
        MemoryContext oldcxt;
        int                     rri_index;
 
        oldcxt = MemoryContextSwitchTo(proute->memcxt);
 
        /*
-        * Set up a tuple conversion map to convert a tuple routed to the
-        * partition from the parent's type to the partition's.
+        * Set up tuple conversion between root parent and the partition if the
+        * two have different rowtypes.  If conversion is indeed required, also
+        * initialize a slot dedicated to storing this partition's converted
+        * tuples.  Various operations that are applied to tuples after routing,
+        * such as checking constraints, will refer to this slot.
         */
-       partRelInfo->ri_RootToPartitionMap =
-               convert_tuples_by_name(RelationGetDescr(rootRelInfo->ri_RelationDesc),
-                                                          RelationGetDescr(partRelInfo->ri_RelationDesc));
-
-       /*
-        * If a partition has a different rowtype than the root parent, initialize
-        * a slot dedicated to storing this partition's tuples.  The slot is used
-        * for various operations that are applied to tuples after routing, such
-        * as checking constraints.
-        */
-       if (partRelInfo->ri_RootToPartitionMap != NULL)
+       if (ExecGetRootToChildMap(partRelInfo, estate) != NULL)
        {
                Relation        partrel = partRelInfo->ri_RelationDesc;
 
                /*
-                * Initialize the slot itself setting its descriptor to this
-                * partition's TupleDesc; TupleDesc reference will be released at the
+                * This pins the partition's TupleDesc, which will be released at the
                 * end of the command.
                 */
                partRelInfo->ri_PartitionTupleSlot =

diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 9695de85b9ab76deb9e8b402acd6f5e896b86a83..572c87e4536918a78694a929f1261ffd4ef6abd6 100644 (file)
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -1253,6 +1253,45 @@ ExecGetChildToRootMap(ResultRelInfo *resultRelInfo)
        return resultRelInfo->ri_ChildToRootMap;
 }
 
+/*
+ * Returns the map needed to convert given root result relation's tuples to
+ * the rowtype of the given child relation.  Note that a NULL result is valid
+ * and means that no conversion is needed.
+ */
+TupleConversionMap *
+ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)
+{
+       /* Mustn't get called for a non-child result relation. */
+       Assert(resultRelInfo->ri_RootResultRelInfo);
+
+       /* If we didn't already do so, compute the map for this child. */
+       if (!resultRelInfo->ri_RootToChildMapValid)
+       {
+               ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
+               TupleDesc       indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
+               TupleDesc       outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
+               Relation        childrel = resultRelInfo->ri_RelationDesc;
+               AttrMap    *attrMap;
+               MemoryContext oldcontext;
+
+               /*
+                * When this child table is not a partition (!relispartition), it may
+                * have columns that are not present in the root table, which we ask
+                * to ignore by passing true for missing_ok.
+                */
+               oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
+               attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
+                                                                                          !childrel->rd_rel->relispartition);
+               if (attrMap)
+                       resultRelInfo->ri_RootToChildMap =
+                               convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
+               MemoryContextSwitchTo(oldcontext);
+               resultRelInfo->ri_RootToChildMapValid = true;
+       }
+
+       return resultRelInfo->ri_RootToChildMap;
+}
+
 /* Return a bitmap representing columns being inserted */
 Bitmapset *
 ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate)
@@ -1273,10 +1312,10 @@ ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate)
        {
                ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
                RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
+               TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
 
-               if (relinfo->ri_RootToPartitionMap != NULL)
-                       return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
-                                                                                rte->insertedCols);
+               if (map != NULL)
+                       return execute_attr_map_cols(map->attrMap, rte->insertedCols);
                else
                        return rte->insertedCols;
        }
@@ -1307,10 +1346,10 @@ ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate)
        {
                ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
                RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
+               TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
 
-               if (relinfo->ri_RootToPartitionMap != NULL)
-                       return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
-                                                                                rte->updatedCols);
+               if (map != NULL)
+                       return execute_attr_map_cols(map->attrMap, rte->updatedCols);
                else
                        return rte->updatedCols;
        }
@@ -1333,10 +1372,10 @@ ExecGetExtraUpdatedCols(ResultRelInfo *relinfo, EState *estate)
        {
                ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
                RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
+               TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
 
-               if (relinfo->ri_RootToPartitionMap != NULL)
-                       return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
-                                                                                rte->extraUpdatedCols);
+               if (map != NULL)
+                       return execute_attr_map_cols(map->attrMap, rte->extraUpdatedCols);
                else
                        return rte->extraUpdatedCols;
        }

diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 271ff2be8efe2d5ce3749730bbca27c83d2af9d1..a3988b117543a19710868348cbb79ed093655ca8 100644 (file)
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -3481,7 +3481,7 @@ ExecPrepareTupleRouting(ModifyTableState *mtstate,
        /*
         * Convert the tuple, if necessary.
         */
-       map = partrel->ri_RootToPartitionMap;
+       map = ExecGetRootToChildMap(partrel, estate);
        if (map != NULL)
        {
                TupleTableSlot *new_slot = partrel->ri_PartitionTupleSlot;

diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c
index e48a3f589aefbfe4369c38f7fee1c976679ea186..f9efe6c4c674541d78411459f8dd52dfbae8c040 100644 (file)
--- a/src/backend/replication/logical/worker.c
+++ b/src/backend/replication/logical/worker.c
@@ -2193,7 +2193,7 @@ apply_handle_tuple_routing(ApplyExecutionData *edata,
        remoteslot_part = partrelinfo->ri_PartitionTupleSlot;
        if (remoteslot_part == NULL)
                remoteslot_part = table_slot_create(partrel, &estate->es_tupleTable);
-       map = partrelinfo->ri_RootToPartitionMap;
+       map = ExecGetRootToChildMap(partrelinfo, estate);
        if (map != NULL)
        {
                attrmap = map->attrMap;
@@ -2353,7 +2353,7 @@ apply_handle_tuple_routing(ApplyExecutionData *edata,
                                        if (remoteslot_part == NULL)
                                                remoteslot_part = table_slot_create(partrel_new,
                                                                                                                        &estate->es_tupleTable);
-                                       map = partrelinfo_new->ri_RootToPartitionMap;
+                                       map = ExecGetRootToChildMap(partrelinfo_new, estate);
                                        if (map != NULL)
                                        {
                                                remoteslot_part = execute_attr_map_slot(map->attrMap,

diff --git a/src/include/access/tupconvert.h b/src/include/access/tupconvert.h
index a37dafc666d9be051215b6dfaa8183b55be8c672..2badb8c239da84715ca5363312e60fef12807afa 100644 (file)
--- a/src/include/access/tupconvert.h
+++ b/src/include/access/tupconvert.h
@@ -39,6 +39,9 @@ extern TupleConversionMap *convert_tuples_by_position(TupleDesc indesc,
 
 extern TupleConversionMap *convert_tuples_by_name(TupleDesc indesc,
                                                                                                  TupleDesc outdesc);
+extern TupleConversionMap *convert_tuples_by_name_attrmap(TupleDesc indesc,
+                                                                                                                 TupleDesc outdesc,
+                                                                                                                 AttrMap *attrMap);
 
 extern HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map);
 extern TupleTableSlot *execute_attr_map_slot(AttrMap *attrMap,

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index ed95ed1176da9dfb7e3e8b3eb7c114bd4b77e72c..aaf2bc78b9c71c4dcdeb8fc2ad09ec3c50bc0070 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -600,6 +600,7 @@ extern TupleTableSlot *ExecGetTriggerOldSlot(EState *estate, ResultRelInfo *relI
 extern TupleTableSlot *ExecGetTriggerNewSlot(EState *estate, ResultRelInfo *relInfo);
 extern TupleTableSlot *ExecGetReturningSlot(EState *estate, ResultRelInfo *relInfo);
 extern TupleConversionMap *ExecGetChildToRootMap(ResultRelInfo *resultRelInfo);
+extern TupleConversionMap *ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate);
 
 extern Bitmapset *ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate);
 extern Bitmapset *ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate);

diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index a2008846c63f7ee81bd569bb42e0d5bf346832b9..71248a9466071c6e0196f997c2cebf822ca48262 100644 (file)
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -538,6 +538,21 @@ typedef struct ResultRelInfo
        /* partition check expression state (NULL if not set up yet) */
        ExprState  *ri_PartitionCheckExpr;
 
+       /*
+        * Map to convert child result relation tuples to the format of the table
+        * actually mentioned in the query (called "root").  Computed only if
+        * needed.  A NULL map value indicates that no conversion is needed, so we
+        * must have a separate flag to show if the map has been computed.
+        */
+       TupleConversionMap *ri_ChildToRootMap;
+       bool            ri_ChildToRootMapValid;
+
+       /*
+        * As above, but in the other direction.
+        */
+       TupleConversionMap *ri_RootToChildMap;
+       bool            ri_RootToChildMapValid;
+
        /*
         * Information needed by tuple routing target relations
         *
@@ -546,23 +561,12 @@ typedef struct ResultRelInfo
         * mentioned in the query is an inherited table, nor when tuple routing is
         * not needed.
         *
-        * RootToPartitionMap and PartitionTupleSlot, initialized by
-        * ExecInitRoutingInfo, are non-NULL if partition has a different tuple
-        * format than the root table.
+        * PartitionTupleSlot is non-NULL if RootToChild conversion is needed and
+        * the relation is a partition.
         */
        struct ResultRelInfo *ri_RootResultRelInfo;
-       TupleConversionMap *ri_RootToPartitionMap;
        TupleTableSlot *ri_PartitionTupleSlot;
 
-       /*
-        * Map to convert child result relation tuples to the format of the table
-        * actually mentioned in the query (called "root").  Computed only if
-        * needed.  A NULL map value indicates that no conversion is needed, so we
-        * must have a separate flag to show if the map has been computed.
-        */
-       TupleConversionMap *ri_ChildToRootMap;
-       bool            ri_ChildToRootMapValid;
-
        /* for use by copyfrom.c when performing multi-inserts */
        struct CopyMultiInsertBuffer *ri_CopyMultiInsertBuffer;