Fix interaction of triggers, partitioning, and EXPLAIN ANALYZE.

Add a new EState member es_leaf_result_relations, so that the trigger
code knows about ResultRelInfos created by tuple routing.  Also make
sure ExplainPrintTriggers knows about partition-related
ResultRelInfos.

Etsuro Fujita, reviewed by Amit Langote

Discussion: http://postgr.es/m/57163e18-8e56-da83-337a-22f2c0008051@lab.ntt.co.jp

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a258965c200941521d60bfd29f51d7426b8fdf58..375a25fbcf843a52b19c89c1e512e6b0a65adc43 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -1415,59 +1415,6 @@ BeginCopy(ParseState *pstate,
                                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                                         errmsg("table \"%s\" does not have OIDs",
                                                        RelationGetRelationName(cstate->rel))));
-
-               /*
-                * If there are any triggers with transition tables on the named
-                * relation, we need to be prepared to capture transition tuples.
-                */
-               cstate->transition_capture = MakeTransitionCaptureState(rel->trigdesc);
-
-               /* Initialize state for CopyFrom tuple routing. */
-               if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
-               {
-                       PartitionDispatch *partition_dispatch_info;
-                       ResultRelInfo *partitions;
-                       TupleConversionMap **partition_tupconv_maps;
-                       TupleTableSlot *partition_tuple_slot;
-                       int                     num_parted,
-                                               num_partitions;
-
-                       ExecSetupPartitionTupleRouting(rel,
-                                                                                  1,
-                                                                                  &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;
-
-                       /*
-                        * If we are capturing transition tuples, they may need to be
-                        * converted from partition format back to partitioned table
-                        * format (this is only ever necessary if a BEFORE trigger
-                        * modifies the tuple).
-                        */
-                       if (cstate->transition_capture != NULL)
-                       {
-                               int                     i;
-
-                               cstate->transition_tupconv_maps = (TupleConversionMap **)
-                                       palloc0(sizeof(TupleConversionMap *) *
-                                                       cstate->num_partitions);
-                               for (i = 0; i < cstate->num_partitions; ++i)
-                               {
-                                       cstate->transition_tupconv_maps[i] =
-                                               convert_tuples_by_name(RelationGetDescr(cstate->partitions[i].ri_RelationDesc),
-                                                                                          RelationGetDescr(rel),
-                                                                                          gettext_noop("could not convert row type"));
-                               }
-                       }
-               }
        }
        else
        {
@@ -2482,6 +2429,63 @@ CopyFrom(CopyState cstate)
        /* Triggers might need a slot as well */
        estate->es_trig_tuple_slot = ExecInitExtraTupleSlot(estate);
 
+       /*
+        * If there are any triggers with transition tables on the named relation,
+        * we need to be prepared to capture transition tuples.
+        */
+       cstate->transition_capture =
+               MakeTransitionCaptureState(cstate->rel->trigdesc);
+
+       /*
+        * If the named relation is a partitioned table, initialize state for
+        * CopyFrom tuple routing.
+        */
+       if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+       {
+               PartitionDispatch *partition_dispatch_info;
+               ResultRelInfo *partitions;
+               TupleConversionMap **partition_tupconv_maps;
+               TupleTableSlot *partition_tuple_slot;
+               int                     num_parted,
+                                       num_partitions;
+
+               ExecSetupPartitionTupleRouting(cstate->rel,
+                                                                          1,
+                                                                          estate,
+                                                                          &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;
+
+               /*
+                * If we are capturing transition tuples, they may need to be
+                * converted from partition format back to partitioned table format
+                * (this is only ever necessary if a BEFORE trigger modifies the
+                * tuple).
+                */
+               if (cstate->transition_capture != NULL)
+               {
+                       int                     i;
+
+                       cstate->transition_tupconv_maps = (TupleConversionMap **)
+                               palloc0(sizeof(TupleConversionMap *) * cstate->num_partitions);
+                       for (i = 0; i < cstate->num_partitions; ++i)
+                       {
+                               cstate->transition_tupconv_maps[i] =
+                                       convert_tuples_by_name(RelationGetDescr(cstate->partitions[i].ri_RelationDesc),
+                                                                                  RelationGetDescr(cstate->rel),
+                                                                                  gettext_noop("could not convert row type"));
+                       }
+               }
+       }
+
        /*
         * 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()

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 7648201218e18ad6a88aa5544c58fe1dc30d178f..953e74d73cae354f394c70dd037c6bee8bc6edb2 100644 (file)
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -656,17 +656,30 @@ ExplainPrintTriggers(ExplainState *es, QueryDesc *queryDesc)
        ResultRelInfo *rInfo;
        bool            show_relname;
        int                     numrels = queryDesc->estate->es_num_result_relations;
+       int                     numrootrels = queryDesc->estate->es_num_root_result_relations;
+       List       *leafrels = queryDesc->estate->es_leaf_result_relations;
        List       *targrels = queryDesc->estate->es_trig_target_relations;
        int                     nr;
        ListCell   *l;
 
        ExplainOpenGroup("Triggers", "Triggers", false, es);
 
-       show_relname = (numrels > 1 || targrels != NIL);
+       show_relname = (numrels > 1 || numrootrels > 0 ||
+                                       leafrels != NIL || targrels != NIL);
        rInfo = queryDesc->estate->es_result_relations;
        for (nr = 0; nr < numrels; rInfo++, nr++)
                report_triggers(rInfo, show_relname, es);
 
+       rInfo = queryDesc->estate->es_root_result_relations;
+       for (nr = 0; nr < numrootrels; rInfo++, nr++)
+               report_triggers(rInfo, show_relname, es);
+
+       foreach(l, leafrels)
+       {
+               rInfo = (ResultRelInfo *) lfirst(l);
+               report_triggers(rInfo, show_relname, es);
+       }
+
        foreach(l, targrels)
        {
                rInfo = (ResultRelInfo *) lfirst(l);

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 74071eede6e30adf61402c477fe14894883fb6b1..4582a3caa00de7f6c67085cb8c0ac7ede8dcc736 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1365,16 +1365,18 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo,
  *
  * Get a ResultRelInfo for a trigger target relation.  Most of the time,
  * triggers are fired on one of the result relations of the query, and so
- * we can just return a member of the es_result_relations array.  (Note: in
- * self-join situations there might be multiple members with the same OID;
- * if so it doesn't matter which one we pick.)  However, it is sometimes
- * necessary to fire triggers on other relations; this happens mainly when an
- * RI update trigger queues additional triggers on other relations, which will
- * be processed in the context of the outer query.  For efficiency's sake,
- * we want to have a ResultRelInfo for those triggers too; that can avoid
- * repeated re-opening of the relation.  (It also provides a way for EXPLAIN
- * ANALYZE to report the runtimes of such triggers.)  So we make additional
- * ResultRelInfo's as needed, and save them in es_trig_target_relations.
+ * we can just return a member of the es_result_relations array, the
+ * es_root_result_relations array (if any), or the es_leaf_result_relations
+ * list (if any).  (Note: in self-join situations there might be multiple
+ * members with the same OID; if so it doesn't matter which one we pick.)
+ * However, it is sometimes necessary to fire triggers on other relations;
+ * this happens mainly when an RI update trigger queues additional triggers
+ * on other relations, which will be processed in the context of the outer
+ * query.  For efficiency's sake, we want to have a ResultRelInfo for those
+ * triggers too; that can avoid repeated re-opening of the relation.  (It
+ * also provides a way for EXPLAIN ANALYZE to report the runtimes of such
+ * triggers.)  So we make additional ResultRelInfo's as needed, and save them
+ * in es_trig_target_relations.
  */
 ResultRelInfo *
 ExecGetTriggerResultRel(EState *estate, Oid relid)
@@ -1395,6 +1397,23 @@ ExecGetTriggerResultRel(EState *estate, Oid relid)
                rInfo++;
                nr--;
        }
+       /* Second, search through the root result relations, if any */
+       rInfo = estate->es_root_result_relations;
+       nr = estate->es_num_root_result_relations;
+       while (nr > 0)
+       {
+               if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
+                       return rInfo;
+               rInfo++;
+               nr--;
+       }
+       /* Third, search through the leaf result relations, if any */
+       foreach(l, estate->es_leaf_result_relations)
+       {
+               rInfo = (ResultRelInfo *) lfirst(l);
+               if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
+                       return rInfo;
+       }
        /* Nope, but maybe we already made an extra ResultRelInfo for it */
        foreach(l, estate->es_trig_target_relations)
        {
@@ -3238,6 +3257,7 @@ EvalPlanQualEnd(EPQState *epqstate)
 void
 ExecSetupPartitionTupleRouting(Relation rel,
                                                           Index resultRTindex,
+                                                          EState *estate,
                                                           PartitionDispatch **pd,
                                                           ResultRelInfo **partitions,
                                                           TupleConversionMap ***tup_conv_maps,
@@ -3301,7 +3321,10 @@ ExecSetupPartitionTupleRouting(Relation rel,
                                                  partrel,
                                                  resultRTindex,
                                                  rel,
-                                                 0);
+                                                 estate->es_instrument);
+
+               estate->es_leaf_result_relations =
+                       lappend(estate->es_leaf_result_relations, leaf_part_rri);
 
                /*
                 * Open partition indices (remember we do not support ON CONFLICT in

diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 25772fc603122917e4322db3c40c365aeafc028d..c3988468795e2920010ad072eac8c34e4417400f 100644 (file)
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -115,6 +115,11 @@ CreateExecutorState(void)
        estate->es_num_result_relations = 0;
        estate->es_result_relation_info = NULL;
 
+       estate->es_root_result_relations = NULL;
+       estate->es_num_root_result_relations = 0;
+
+       estate->es_leaf_result_relations = NIL;
+
        estate->es_trig_target_relations = NIL;
        estate->es_trig_tuple_slot = NULL;
        estate->es_trig_oldtup_slot = NULL;

diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 36b2b43bc6215cab135f2e222a8abdbd2bf0ce8b..70a6b847a0ead693e8fc4c0c60b296b78d5dc730 100644 (file)
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1919,6 +1919,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 
                ExecSetupPartitionTupleRouting(rel,
                                                                           node->nominalRelation,
+                                                                          estate,
                                                                           &partition_dispatch_info,
                                                                           &partitions,
                                                                           &partition_tupconv_maps,

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 60326f9d0372425fc8865f3e20cedfa685ea75cd..eacbea3c3655aec2314954648515f17235629777 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -208,6 +208,7 @@ extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti,
 extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
 extern void ExecSetupPartitionTupleRouting(Relation rel,
                                                           Index resultRTindex,
+                                                          EState *estate,
                                                           PartitionDispatch **pd,
                                                           ResultRelInfo **partitions,
                                                           TupleConversionMap ***tup_conv_maps,

diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 577499465d60ec90f48c60b0b7dbbfa58c4ab749..3272c4b315575f6f17cbc67afe1f68decb6f4338 100644 (file)
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -452,6 +452,9 @@ typedef struct EState
        ResultRelInfo *es_root_result_relations;        /* array of ResultRelInfos */
        int                     es_num_root_result_relations;   /* length of the array */
 
+       /* Info about leaf partitions of partitioned table(s) for insert queries: */
+       List       *es_leaf_result_relations;   /* List of ResultRelInfos */
+
        /* Stuff used for firing triggers: */
        List       *es_trig_target_relations;   /* trigger-only ResultRelInfos */
        TupleTableSlot *es_trig_tuple_slot; /* for trigger output tuples */