Don't lock tables in RelationGetPartitionDispatchInfo.

Instead, lock them in the caller using find_all_inheritors so that
they get locked in the standard order, minimizing deadlock risks.

Also in RelationGetPartitionDispatchInfo, avoid opening tables which
are not partitioned; there's no need.

Amit Langote, reviewed by Ashutosh Bapat and Amit Khandekar

Discussion: http://postgr.es/m/91b36fa1-c197-b72f-ca6e-56c593bae68c@lab.ntt.co.jp

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 71bc4b3d105c443bf646b80c64e0550f8a43eee6..21901380cb250f09553220c8d59ff2760480dd7c 100644 (file)
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1000,12 +1000,16 @@ get_partition_qual_relid(Oid relid)
  * RelationGetPartitionDispatchInfo
  *             Returns information necessary to route tuples down a partition tree
  *
- * All the partitions will be locked with lockmode, unless it is NoLock.
- * A list of the OIDs of all the leaf partitions of rel is returned in
- * *leaf_part_oids.
+ * The number of elements in the returned array (that is, the number of
+ * PartitionDispatch objects for the partitioned tables in the partition tree)
+ * is returned in *num_parted and a list of the OIDs of all the leaf
+ * partitions of rel is returned in *leaf_part_oids.
+ *
+ * All the relations in the partition tree (including 'rel') must have been
+ * locked (using at least the AccessShareLock) by the caller.
  */
 PartitionDispatch *
-RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
+RelationGetPartitionDispatchInfo(Relation rel,
                                                                 int *num_parted, List **leaf_part_oids)
 {
        PartitionDispatchData **pd;
@@ -1020,14 +1024,18 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
                                offset;
 
        /*
-        * Lock partitions and make a list of the partitioned ones to prepare
-        * their PartitionDispatch objects below.
+        * We rely on the relcache to traverse the partition tree to build both
+        * the leaf partition OIDs list and the array of PartitionDispatch objects
+        * for the partitioned tables in the tree.  That means every partitioned
+        * table in the tree must be locked, which is fine since we require the
+        * caller to lock all the partitions anyway.
         *
-        * Cannot use find_all_inheritors() here, because then the order of OIDs
-        * in parted_rels list would be unknown, which does not help, because we
-        * assign indexes within individual PartitionDispatch in an order that is
-        * predetermined (determined by the order of OIDs in individual partition
-        * descriptors).
+        * For every partitioned table in the tree, starting with the root
+        * partitioned table, add its relcache entry to parted_rels, while also
+        * queuing its partitions (in the order in which they appear in the
+        * partition descriptor) to be looked at later in the same loop.  This is
+        * a bit tricky but works because the foreach() macro doesn't fetch the
+        * next list element until the bottom of the loop.
         */
        *num_parted = 1;
        parted_rels = list_make1(rel);
@@ -1036,29 +1044,24 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
        APPEND_REL_PARTITION_OIDS(rel, all_parts, all_parents);
        forboth(lc1, all_parts, lc2, all_parents)
        {
-               Relation        partrel = heap_open(lfirst_oid(lc1), lockmode);
+               Oid                     partrelid = lfirst_oid(lc1);
                Relation        parent = lfirst(lc2);
-               PartitionDesc partdesc = RelationGetPartitionDesc(partrel);
 
-               /*
-                * If this partition is a partitioned table, add its children to the
-                * end of the list, so that they are processed as well.
-                */
-               if (partdesc)
+               if (get_rel_relkind(partrelid) == RELKIND_PARTITIONED_TABLE)
                {
+                       /*
+                        * Already locked by the caller.  Note that it is the
+                        * responsibility of the caller to close the below relcache entry,
+                        * once done using the information being collected here (for
+                        * example, in ExecEndModifyTable).
+                        */
+                       Relation        partrel = heap_open(partrelid, NoLock);
+
                        (*num_parted)++;
                        parted_rels = lappend(parted_rels, partrel);
                        parted_rel_parents = lappend(parted_rel_parents, parent);
                        APPEND_REL_PARTITION_OIDS(partrel, all_parts, all_parents);
                }
-               else
-                       heap_close(partrel, NoLock);
-
-               /*
-                * We keep the partitioned ones open until we're done using the
-                * information being collected here (for example, see
-                * ExecEndModifyTable).
-                */
        }
 
        /*

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 6671a25ffb367e299d528ba3029843e4080f676e..74071eede6e30adf61402c477fe14894883fb6b1 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -43,6 +43,7 @@
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/partition.h"
+#include "catalog/pg_inherits_fn.h"
 #include "catalog/pg_publication.h"
 #include "commands/matview.h"
 #include "commands/trigger.h"
@@ -3249,9 +3250,12 @@ ExecSetupPartitionTupleRouting(Relation rel,
        int                     i;
        ResultRelInfo *leaf_part_rri;
 
-       /* Get the tuple-routing information and lock partitions */
-       *pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock, num_parted,
-                                                                                  &leaf_parts);
+       /*
+        * Get the information about the partition tree after locking all the
+        * partitions.
+        */
+       (void) find_all_inheritors(RelationGetRelid(rel), RowExclusiveLock, NULL);
+       *pd = RelationGetPartitionDispatchInfo(rel, num_parted, &leaf_parts);
        *num_partitions = list_length(leaf_parts);
        *partitions = (ResultRelInfo *) palloc(*num_partitions *
                                                                                   sizeof(ResultRelInfo));

diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 434ded37d74f07cc2c90e4bd7c9d02138f6a1746..7e415fe8727b15d2bbc1ef34212f529c94425fb1 100644 (file)
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -87,8 +87,7 @@ extern Expr *get_partition_qual_relid(Oid relid);
 
 /* For tuple routing */
 extern PartitionDispatch *RelationGetPartitionDispatchInfo(Relation rel,
-                                                                int lockmode, int *num_parted,
-                                                                List **leaf_part_oids);
+                                                                int *num_parted, List **leaf_part_oids);
 extern void FormPartitionKeyDatum(PartitionDispatch pd,
                                          TupleTableSlot *slot,
                                          EState *estate,