Allow left join removals and unique joins on partitioned tables

This allows left join removals and unique joins to work with partitioned
tables.  The planner just lacked sufficient proofs that a given join
would not cause any row duplication.  Unique indexes currently serve as
that proof, so have get_relation_info() populate the indexlist for
partitioned tables too.

Author: Arne Roland
Reviewed-by: Alvaro Herrera, Zhihong Yu, Amit Langote, David Rowley
Discussion: https://postgr.es/m/c3b2408b7a39433b8230bbcd02e9f302@index.de

diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 9f158f2421b0f7be3b6da784b098298d557bc410..d58c4a10782740b8d6dcfe7377fe79bf341ce4f9 100644 (file)
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -109,7 +109,9 @@ static void set_baserel_partition_constraint(Relation relation,
  * If inhparent is true, all we need to do is set up the attr arrays:
  * the RelOptInfo actually represents the appendrel formed by an inheritance
  * tree, and so the parent rel's physical size and index information isn't
- * important for it.
+ * important for it, however, for partitioned tables, we do populate the
+ * indexlist as the planner uses unique indexes as unique proofs for certain
+ * optimizations.
  */
 void
 get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
@@ -175,10 +177,14 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 
    /*
     * Make list of indexes.  Ignore indexes on system catalogs if told to.
-    * Don't bother with indexes for an inheritance parent, either.
+    * Don't bother with indexes from traditional inheritance parents.  For
+    * partitioned tables, we need a list of at least unique indexes as these
+    * serve as unique proofs for certain planner optimizations.  However,
+    * let's not discriminate here and just record all partitioned indexes
+    * whether they're unique indexes or not.
     */
-   if (inhparent ||
-       (IgnoreSystemIndexes && IsSystemRelation(relation)))
+   if ((inhparent && relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
+       || (IgnoreSystemIndexes && IsSystemRelation(relation)))
        hasindex = false;
    else
        hasindex = relation->rd_rel->relhasindex;
@@ -231,16 +237,6 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
                continue;
            }
 
-           /*
-            * Ignore partitioned indexes, since they are not usable for
-            * queries.
-            */
-           if (indexRelation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
-           {
-               index_close(indexRelation, NoLock);
-               continue;
-           }
-
            /*
             * If the index is valid, but cannot yet be used, ignore it; but
             * mark the plan we are generating as transient. See
@@ -285,105 +281,129 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 
            info->relam = indexRelation->rd_rel->relam;
 
-           /* We copy just the fields we need, not all of rd_indam */
-           amroutine = indexRelation->rd_indam;
-           info->amcanorderbyop = amroutine->amcanorderbyop;
-           info->amoptionalkey = amroutine->amoptionalkey;
-           info->amsearcharray = amroutine->amsearcharray;
-           info->amsearchnulls = amroutine->amsearchnulls;
-           info->amcanparallel = amroutine->amcanparallel;
-           info->amhasgettuple = (amroutine->amgettuple != NULL);
-           info->amhasgetbitmap = amroutine->amgetbitmap != NULL &&
-               relation->rd_tableam->scan_bitmap_next_block != NULL;
-           info->amcanmarkpos = (amroutine->ammarkpos != NULL &&
-                                 amroutine->amrestrpos != NULL);
-           info->amcostestimate = amroutine->amcostestimate;
-           Assert(info->amcostestimate != NULL);
-
-           /* Fetch index opclass options */
-           info->opclassoptions = RelationGetIndexAttOptions(indexRelation, true);
-
            /*
-            * Fetch the ordering information for the index, if any.
+            * We don't have an AM for partitioned indexes, so we'll just
+            * NULLify the AM related fields for those.
             */
-           if (info->relam == BTREE_AM_OID)
+           if (indexRelation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
            {
+               /* We copy just the fields we need, not all of rd_indam */
+               amroutine = indexRelation->rd_indam;
+               info->amcanorderbyop = amroutine->amcanorderbyop;
+               info->amoptionalkey = amroutine->amoptionalkey;
+               info->amsearcharray = amroutine->amsearcharray;
+               info->amsearchnulls = amroutine->amsearchnulls;
+               info->amcanparallel = amroutine->amcanparallel;
+               info->amhasgettuple = (amroutine->amgettuple != NULL);
+               info->amhasgetbitmap = amroutine->amgetbitmap != NULL &&
+                   relation->rd_tableam->scan_bitmap_next_block != NULL;
+               info->amcanmarkpos = (amroutine->ammarkpos != NULL &&
+                                     amroutine->amrestrpos != NULL);
+               info->amcostestimate = amroutine->amcostestimate;
+               Assert(info->amcostestimate != NULL);
+
+               /* Fetch index opclass options */
+               info->opclassoptions = RelationGetIndexAttOptions(indexRelation, true);
+
                /*
-                * If it's a btree index, we can use its opfamily OIDs
-                * directly as the sort ordering opfamily OIDs.
+                * Fetch the ordering information for the index, if any.
                 */
-               Assert(amroutine->amcanorder);
-
-               info->sortopfamily = info->opfamily;
-               info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
-               info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
-
-               for (i = 0; i < nkeycolumns; i++)
+               if (info->relam == BTREE_AM_OID)
                {
-                   int16       opt = indexRelation->rd_indoption[i];
+                   /*
+                    * If it's a btree index, we can use its opfamily OIDs
+                    * directly as the sort ordering opfamily OIDs.
+                    */
+                   Assert(amroutine->amcanorder);
 
-                   info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
-                   info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
-               }
-           }
-           else if (amroutine->amcanorder)
-           {
-               /*
-                * Otherwise, identify the corresponding btree opfamilies by
-                * trying to map this index's "<" operators into btree.  Since
-                * "<" uniquely defines the behavior of a sort order, this is
-                * a sufficient test.
-                *
-                * XXX This method is rather slow and also requires the
-                * undesirable assumption that the other index AM numbers its
-                * strategies the same as btree.  It'd be better to have a way
-                * to explicitly declare the corresponding btree opfamily for
-                * each opfamily of the other index type.  But given the lack
-                * of current or foreseeable amcanorder index types, it's not
-                * worth expending more effort on now.
-                */
-               info->sortopfamily = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
-               info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
-               info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
+                   info->sortopfamily = info->opfamily;
+                   info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
+                   info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
 
-               for (i = 0; i < nkeycolumns; i++)
-               {
-                   int16       opt = indexRelation->rd_indoption[i];
-                   Oid         ltopr;
-                   Oid         btopfamily;
-                   Oid         btopcintype;
-                   int16       btstrategy;
-
-                   info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
-                   info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
-
-                   ltopr = get_opfamily_member(info->opfamily[i],
-                                               info->opcintype[i],
-                                               info->opcintype[i],
-                                               BTLessStrategyNumber);
-                   if (OidIsValid(ltopr) &&
-                       get_ordering_op_properties(ltopr,
-                                                  &btopfamily,
-                                                  &btopcintype,
-                                                  &btstrategy) &&
-                       btopcintype == info->opcintype[i] &&
-                       btstrategy == BTLessStrategyNumber)
+                   for (i = 0; i < nkeycolumns; i++)
                    {
-                       /* Successful mapping */
-                       info->sortopfamily[i] = btopfamily;
+                       int16       opt = indexRelation->rd_indoption[i];
+
+                       info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
+                       info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
                    }
-                   else
+               }
+               else if (amroutine->amcanorder)
+               {
+                   /*
+                    * Otherwise, identify the corresponding btree opfamilies
+                    * by trying to map this index's "<" operators into btree.
+                    * Since "<" uniquely defines the behavior of a sort
+                    * order, this is a sufficient test.
+                    *
+                    * XXX This method is rather slow and also requires the
+                    * undesirable assumption that the other index AM numbers
+                    * its strategies the same as btree.  It'd be better to
+                    * have a way to explicitly declare the corresponding
+                    * btree opfamily for each opfamily of the other index
+                    * type.  But given the lack of current or foreseeable
+                    * amcanorder index types, it's not worth expending more
+                    * effort on now.
+                    */
+                   info->sortopfamily = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
+                   info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
+                   info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
+
+                   for (i = 0; i < nkeycolumns; i++)
                    {
-                       /* Fail ... quietly treat index as unordered */
-                       info->sortopfamily = NULL;
-                       info->reverse_sort = NULL;
-                       info->nulls_first = NULL;
-                       break;
+                       int16       opt = indexRelation->rd_indoption[i];
+                       Oid         ltopr;
+                       Oid         btopfamily;
+                       Oid         btopcintype;
+                       int16       btstrategy;
+
+                       info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
+                       info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
+
+                       ltopr = get_opfamily_member(info->opfamily[i],
+                                                   info->opcintype[i],
+                                                   info->opcintype[i],
+                                                   BTLessStrategyNumber);
+                       if (OidIsValid(ltopr) &&
+                           get_ordering_op_properties(ltopr,
+                                                      &btopfamily,
+                                                      &btopcintype,
+                                                      &btstrategy) &&
+                           btopcintype == info->opcintype[i] &&
+                           btstrategy == BTLessStrategyNumber)
+                       {
+                           /* Successful mapping */
+                           info->sortopfamily[i] = btopfamily;
+                       }
+                       else
+                       {
+                           /* Fail ... quietly treat index as unordered */
+                           info->sortopfamily = NULL;
+                           info->reverse_sort = NULL;
+                           info->nulls_first = NULL;
+                           break;
+                       }
                    }
                }
+               else
+               {
+                   info->sortopfamily = NULL;
+                   info->reverse_sort = NULL;
+                   info->nulls_first = NULL;
+               }
            }
            else
            {
+               info->amcanorderbyop = false;
+               info->amoptionalkey = false;
+               info->amsearcharray = false;
+               info->amsearchnulls = false;
+               info->amcanparallel = false;
+               info->amhasgettuple = false;
+               info->amhasgetbitmap = false;
+               info->amcanmarkpos = false;
+               info->amcostestimate = NULL;
+
                info->sortopfamily = NULL;
                info->reverse_sort = NULL;
                info->nulls_first = NULL;
@@ -416,31 +436,45 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
             * the number-of-tuples estimate to equal the parent table; if it
             * is partial then we have to use the same methods as we would for
             * a table, except we can be sure that the index is not larger
-            * than the table.
+            * than the table.  We must ignore partitioned indexes here as as
+            * there are not physical indexes.
             */
-           if (info->indpred == NIL)
+           if (indexRelation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
            {
-               info->pages = RelationGetNumberOfBlocks(indexRelation);
-               info->tuples = rel->tuples;
-           }
-           else
-           {
-               double      allvisfrac; /* dummy */
-
-               estimate_rel_size(indexRelation, NULL,
-                                 &info->pages, &info->tuples, &allvisfrac);
-               if (info->tuples > rel->tuples)
+               if (info->indpred == NIL)
+               {
+                   info->pages = RelationGetNumberOfBlocks(indexRelation);
                    info->tuples = rel->tuples;
-           }
+               }
+               else
+               {
+                   double      allvisfrac; /* dummy */
 
-           if (info->relam == BTREE_AM_OID)
-           {
-               /* For btrees, get tree height while we have the index open */
-               info->tree_height = _bt_getrootheight(indexRelation);
+                   estimate_rel_size(indexRelation, NULL,
+                                     &info->pages, &info->tuples, &allvisfrac);
+                   if (info->tuples > rel->tuples)
+                       info->tuples = rel->tuples;
+               }
+
+               if (info->relam == BTREE_AM_OID)
+               {
+                   /*
+                    * For btrees, get tree height while we have the index
+                    * open
+                    */
+                   info->tree_height = _bt_getrootheight(indexRelation);
+               }
+               else
+               {
+                   /* For other index types, just set it to "unknown" for now */
+                   info->tree_height = -1;
+               }
            }
            else
            {
-               /* For other index types, just set it to "unknown" for now */
+               /* Zero these out for partitioned indexes */
+               info->pages = 0;
+               info->tuples = 0.0;
                info->tree_height = -1;
            }
 

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index f50e58adbd63b264973cd80772f74cdd4ca10513..57de51f0db20b439f4880e523e654ae54c830921 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -5994,6 +5994,10 @@ get_actual_variable_range(PlannerInfo *root, VariableStatData *vardata,
    rte = root->simple_rte_array[rel->relid];
    Assert(rte->rtekind == RTE_RELATION);
 
+   /* ignore partitioned tables.  Any indexes here are not real indexes */
+   if (rte->relkind == RELKIND_PARTITIONED_TABLE)
+       return false;
+
    /* Search through the indexes to see if any match our problem */
    foreach(lc, rel->indexlist)
    {

diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index 1827e5064799082c887f66574b0f10d7a9ced3e0..c20b7298a3d879de8a3f0a7ec487495f39ecd348 100644 (file)
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -653,7 +653,7 @@ typedef struct PartitionSchemeData *PartitionScheme;
  *     lateral_referencers - relids of rels that reference this one laterally
  *             (includes both direct and indirect lateral references)
  *     indexlist - list of IndexOptInfo nodes for relation's indexes
- *                 (always NIL if it's not a table)
+ *                 (always NIL if it's not a table or partitioned table)
  *     pages - number of disk pages in relation (zero if not a table)
  *     tuples - number of tuples in relation (not considering restrictions)
  *     allvisfrac - fraction of disk pages that are marked all-visible
@@ -1097,11 +1097,11 @@ struct IndexOptInfo
    Oid        *opfamily pg_node_attr(array_size(nkeycolumns));
    /* OIDs of opclass declared input data types */
    Oid        *opcintype pg_node_attr(array_size(nkeycolumns));
-   /* OIDs of btree opfamilies, if orderable */
+   /* OIDs of btree opfamilies, if orderable.  NULL if partitioned index */
    Oid        *sortopfamily pg_node_attr(array_size(nkeycolumns));
-   /* is sort order descending? */
+   /* is sort order descending? or NULL if partitioned index */
    bool       *reverse_sort pg_node_attr(array_size(nkeycolumns));
-   /* do NULLs come first in the sort order? */
+   /* do NULLs come first in the sort order? or NULL if partitioned index */
    bool       *nulls_first pg_node_attr(array_size(nkeycolumns));
    /* opclass-specific options for columns */
    bytea     **opclassoptions pg_node_attr(read_write_ignore);
@@ -1139,7 +1139,7 @@ struct IndexOptInfo
 
    /*
     * Remaining fields are copied from the index AM's API struct
-    * (IndexAmRoutine).
+    * (IndexAmRoutine).  These fields are not set for partitioned indexes.
     */
    bool        amcanorderbyop;
    bool        amoptionalkey;

diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 3ddea3b683770432d4b27f99f4760d44c82b1754..c2b85d27950519c4a2c187b5133c627dae0dfdc1 100644 (file)
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -4860,6 +4860,16 @@ select 1 from (select a.id FROM a left join b on a.b_id = b.id) q,
          Filter: (a.id = i)
 (4 rows)
 
+CREATE TEMP TABLE parted_b (id int PRIMARY KEY) partition by range(id);
+CREATE TEMP TABLE parted_b1 partition of parted_b for values from (0) to (10);
+-- test join removals on a partitioned table
+explain (costs off)
+select a.* from a left join parted_b pb on a.b_id = pb.id;
+  QUERY PLAN   
+---------------
+ Seq Scan on a
+(1 row)
+
 rollback;
 create temp table parent (k int primary key, pd int);
 create temp table child (k int unique, cd int);

diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c59caf1cb3d962daea4ee6a66853ca863e5bfb24..c649c4aeaae45cc16e654b07cb747ad05327eb2c 100644 (file)
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -4874,7 +4874,7 @@ ANALYZE fract_t;
 SET max_parallel_workers_per_gather = 0;
 SET enable_partitionwise_join = on;
 EXPLAIN (COSTS OFF)
-SELECT * FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY id ASC LIMIT 10;
+SELECT x.id, y.id FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY x.id ASC LIMIT 10;
                               QUERY PLAN                               
 -----------------------------------------------------------------------
  Limit
@@ -4891,7 +4891,7 @@ SELECT * FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY id ASC LIMIT 10;
 (11 rows)
 
 EXPLAIN (COSTS OFF)
-SELECT * FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY id DESC LIMIT 10;
+SELECT x.id, y.id FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY x.id DESC LIMIT 10;
                                    QUERY PLAN                                   
 --------------------------------------------------------------------------------
  Limit

diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql
index 9fc6ef43768eda46d0bde5334033bc86af219376..027927354c09f69361e04fb2922d960df8536867 100644 (file)
--- a/src/test/regress/sql/join.sql
+++ b/src/test/regress/sql/join.sql
@@ -1709,6 +1709,13 @@ explain (costs off)
 select 1 from (select a.id FROM a left join b on a.b_id = b.id) q,
              lateral generate_series(1, q.id) gs(i) where q.id = gs.i;
 
+CREATE TEMP TABLE parted_b (id int PRIMARY KEY) partition by range(id);
+CREATE TEMP TABLE parted_b1 partition of parted_b for values from (0) to (10);
+
+-- test join removals on a partitioned table
+explain (costs off)
+select a.* from a left join parted_b pb on a.b_id = pb.id;
+
 rollback;
 
 create temp table parent (k int primary key, pd int);

diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index 67f506361f8661600c80b4dad65f1fb198a99d0a..9e16f1ca550fae192065d64612b8800577b2b30e 100644 (file)
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -1157,10 +1157,10 @@ SET max_parallel_workers_per_gather = 0;
 SET enable_partitionwise_join = on;
 
 EXPLAIN (COSTS OFF)
-SELECT * FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY id ASC LIMIT 10;
+SELECT x.id, y.id FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY x.id ASC LIMIT 10;
 
 EXPLAIN (COSTS OFF)
-SELECT * FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY id DESC LIMIT 10;
+SELECT x.id, y.id FROM fract_t x LEFT JOIN fract_t y USING (id) ORDER BY x.id DESC LIMIT 10;
 
 -- cleanup
 DROP TABLE fract_t;