Assorted preparatory refactoring for partition-wise join.

Instead of duplicating the logic to search for a matching
ParamPathInfo in multiple places, factor it out into a separate
function.

Pass only the relevant bits of the PartitionKey to
partition_bounds_equal instead of the whole thing, because
partition-wise join will want to call this without having a
PartitionKey available.

Adjust allow_star_schema_join and calc_nestloop_required_outer
to take relevant Relids rather than the entire Path, because
partition-wise join will want to call it with the top-parent
relids to determine whether a child join is allowable.

Ashutosh Bapat.  Review and testing of the larger patch set of which
this is a part by Amit Langote, Rajkumar Raghuwanshi, Rafia Sabih,
Thomas Munro, Dilip Kumar, and me.

Discussion: http://postgr.es/m/CA+TgmobQK80vtXjAsPZWWXd7c8u13G86gmuLupN+uUJjA+i4nA@mail.gmail.com

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 71bc4b3d105c443bf646b80c64e0550f8a43eee6..c1a307c8d35c88dcd6cc9b9329162bc3d89931b3 100644 (file)
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -583,7 +583,7 @@ RelationBuildPartitionDesc(Relation rel)
  * representation of partition bounds.
  */
 bool
-partition_bounds_equal(PartitionKey key,
+partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
                       PartitionBoundInfo b1, PartitionBoundInfo b2)
 {
    int         i;
@@ -601,7 +601,7 @@ partition_bounds_equal(PartitionKey key,
    {
        int         j;
 
-       for (j = 0; j < key->partnatts; j++)
+       for (j = 0; j < partnatts; j++)
        {
            /* For range partitions, the bounds might not be finite. */
            if (b1->kind != NULL)
@@ -627,8 +627,7 @@ partition_bounds_equal(PartitionKey key,
             * context.  datumIsEqual() should be simple enough to be safe.
             */
            if (!datumIsEqual(b1->datums[i][j], b2->datums[i][j],
-                             key->parttypbyval[j],
-                             key->parttyplen[j]))
+                             parttypbyval[j], parttyplen[j]))
                return false;
        }
 
@@ -637,7 +636,7 @@ partition_bounds_equal(PartitionKey key,
    }
 
    /* There are ndatums+1 indexes in case of range partitions */
-   if (key->strategy == PARTITION_STRATEGY_RANGE &&
+   if (b1->strategy == PARTITION_STRATEGY_RANGE &&
        b1->indexes[i] != b2->indexes[i])
        return false;
 

diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c
index 511c734980523e5805f132156aabfdf0adbdf790..43833ea9c9fa86b861ac9e799e029b4bd7b5b659 100644 (file)
--- a/src/backend/optimizer/path/joinpath.c
+++ b/src/backend/optimizer/path/joinpath.c
@@ -318,18 +318,15 @@ add_paths_to_joinrel(PlannerInfo *root,
  */
 static inline bool
 allow_star_schema_join(PlannerInfo *root,
-                      Path *outer_path,
-                      Path *inner_path)
+                      Relids outerrelids,
+                      Relids inner_paramrels)
 {
-   Relids      innerparams = PATH_REQ_OUTER(inner_path);
-   Relids      outerrelids = outer_path->parent->relids;
-
    /*
     * It's a star-schema case if the outer rel provides some but not all of
     * the inner rel's parameterization.
     */
-   return (bms_overlap(innerparams, outerrelids) &&
-           bms_nonempty_difference(innerparams, outerrelids));
+   return (bms_overlap(inner_paramrels, outerrelids) &&
+           bms_nonempty_difference(inner_paramrels, outerrelids));
 }
 
 /*
@@ -348,6 +345,12 @@ try_nestloop_path(PlannerInfo *root,
 {
    Relids      required_outer;
    JoinCostWorkspace workspace;
+   RelOptInfo *innerrel = inner_path->parent;
+   RelOptInfo *outerrel = outer_path->parent;
+   Relids      innerrelids = innerrel->relids;
+   Relids      outerrelids = outerrel->relids;
+   Relids      inner_paramrels = PATH_REQ_OUTER(inner_path);
+   Relids      outer_paramrels = PATH_REQ_OUTER(outer_path);
 
    /*
     * Check to see if proposed path is still parameterized, and reject if the
@@ -356,14 +359,12 @@ try_nestloop_path(PlannerInfo *root,
     * doesn't like the look of it, which could only happen if the nestloop is
     * still parameterized.
     */
-   required_outer = calc_nestloop_required_outer(outer_path,
-                                                 inner_path);
+   required_outer = calc_nestloop_required_outer(outerrelids, outer_paramrels,
+                                                 innerrelids, inner_paramrels);
    if (required_outer &&
        ((!bms_overlap(required_outer, extra->param_source_rels) &&
-         !allow_star_schema_join(root, outer_path, inner_path)) ||
-        have_dangerous_phv(root,
-                           outer_path->parent->relids,
-                           PATH_REQ_OUTER(inner_path))))
+         !allow_star_schema_join(root, outerrelids, inner_paramrels)) ||
+        have_dangerous_phv(root, outerrelids, inner_paramrels)))
    {
        /* Waste no memory when we reject a path here */
        bms_free(required_outer);

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index f2d6385f18353ad4e4bf93e2db1c26ac493b6c25..26567cb7f65b18b75920881629caf6e7c6b5b7a0 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -1993,14 +1993,15 @@ create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel,
  * Note: result must not share storage with either input
  */
 Relids
-calc_nestloop_required_outer(Path *outer_path, Path *inner_path)
+calc_nestloop_required_outer(Relids outerrelids,
+                            Relids outer_paramrels,
+                            Relids innerrelids,
+                            Relids inner_paramrels)
 {
-   Relids      outer_paramrels = PATH_REQ_OUTER(outer_path);
-   Relids      inner_paramrels = PATH_REQ_OUTER(inner_path);
    Relids      required_outer;
 
    /* inner_path can require rels from outer path, but not vice versa */
-   Assert(!bms_overlap(outer_paramrels, inner_path->parent->relids));
+   Assert(!bms_overlap(outer_paramrels, innerrelids));
    /* easy case if inner path is not parameterized */
    if (!inner_paramrels)
        return bms_copy(outer_paramrels);
@@ -2008,7 +2009,7 @@ calc_nestloop_required_outer(Path *outer_path, Path *inner_path)
    required_outer = bms_union(outer_paramrels, inner_paramrels);
    /* ... and remove any mention of now-satisfied outer rels */
    required_outer = bms_del_members(required_outer,
-                                    outer_path->parent->relids);
+                                    outerrelids);
    /* maintain invariant that required_outer is exactly NULL if empty */
    if (bms_is_empty(required_outer))
    {

diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index c8e2b67da42cccc60a8db6ff59f549f658b636b5..8ad0b4a6697801daeaba2d439e3239feba38a6b7 100644 (file)
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1048,12 +1048,8 @@ get_baserel_parampathinfo(PlannerInfo *root, RelOptInfo *baserel,
    Assert(!bms_overlap(baserel->relids, required_outer));
 
    /* If we already have a PPI for this parameterization, just return it */
-   foreach(lc, baserel->ppilist)
-   {
-       ppi = (ParamPathInfo *) lfirst(lc);
-       if (bms_equal(ppi->ppi_req_outer, required_outer))
-           return ppi;
-   }
+   if ((ppi = find_param_path_info(baserel, required_outer)))
+       return ppi;
 
    /*
     * Identify all joinclauses that are movable to this base rel given this
@@ -1290,12 +1286,8 @@ get_joinrel_parampathinfo(PlannerInfo *root, RelOptInfo *joinrel,
    *restrict_clauses = list_concat(pclauses, *restrict_clauses);
 
    /* If we already have a PPI for this parameterization, just return it */
-   foreach(lc, joinrel->ppilist)
-   {
-       ppi = (ParamPathInfo *) lfirst(lc);
-       if (bms_equal(ppi->ppi_req_outer, required_outer))
-           return ppi;
-   }
+   if ((ppi = find_param_path_info(joinrel, required_outer)))
+       return ppi;
 
    /* Estimate the number of rows returned by the parameterized join */
    rows = get_parameterized_joinrel_size(root, joinrel,
@@ -1334,7 +1326,6 @@ ParamPathInfo *
 get_appendrel_parampathinfo(RelOptInfo *appendrel, Relids required_outer)
 {
    ParamPathInfo *ppi;
-   ListCell   *lc;
 
    /* Unparameterized paths have no ParamPathInfo */
    if (bms_is_empty(required_outer))
@@ -1343,12 +1334,8 @@ get_appendrel_parampathinfo(RelOptInfo *appendrel, Relids required_outer)
    Assert(!bms_overlap(appendrel->relids, required_outer));
 
    /* If we already have a PPI for this parameterization, just return it */
-   foreach(lc, appendrel->ppilist)
-   {
-       ppi = (ParamPathInfo *) lfirst(lc);
-       if (bms_equal(ppi->ppi_req_outer, required_outer))
-           return ppi;
-   }
+   if ((ppi = find_param_path_info(appendrel, required_outer)))
+       return ppi;
 
    /* Else build the ParamPathInfo */
    ppi = makeNode(ParamPathInfo);
@@ -1359,3 +1346,23 @@ get_appendrel_parampathinfo(RelOptInfo *appendrel, Relids required_outer)
 
    return ppi;
 }
+
+/*
+ * Returns a ParamPathInfo for the parameterization given by required_outer, if
+ * already available in the given rel. Returns NULL otherwise.
+ */
+ParamPathInfo *
+find_param_path_info(RelOptInfo *rel, Relids required_outer)
+{
+   ListCell   *lc;
+
+   foreach(lc, rel->ppilist)
+   {
+       ParamPathInfo *ppi = (ParamPathInfo *) lfirst(lc);
+
+       if (bms_equal(ppi->ppi_req_outer, required_outer))
+           return ppi;
+   }
+
+   return NULL;
+}

diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 6bd93b03d080162fbe6116ef689fd797ab8bfdea..2150fe9a3964079d7870af1f841662e6484e03ca 100644 (file)
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -1208,7 +1208,9 @@ equalPartitionDescs(PartitionKey key, PartitionDesc partdesc1,
            if (partdesc2->boundinfo == NULL)
                return false;
 
-           if (!partition_bounds_equal(key, partdesc1->boundinfo,
+           if (!partition_bounds_equal(key->partnatts, key->parttyplen,
+                                       key->parttypbyval,
+                                       partdesc1->boundinfo,
                                        partdesc2->boundinfo))
                return false;
        }

diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 434ded37d74f07cc2c90e4bd7c9d02138f6a1746..bef7a0f5fb6131cdcc18f9d069d02771f228dfc4 100644 (file)
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -71,8 +71,9 @@ typedef struct PartitionDispatchData
 typedef struct PartitionDispatchData *PartitionDispatch;
 
 extern void RelationBuildPartitionDesc(Relation relation);
-extern bool partition_bounds_equal(PartitionKey key,
-                      PartitionBoundInfo p1, PartitionBoundInfo p2);
+extern bool partition_bounds_equal(int partnatts, int16 *parttyplen,
+                      bool *parttypbyval, PartitionBoundInfo b1,
+                      PartitionBoundInfo b2);
 
 extern void check_new_partition_bound(char *relname, Relation parent,
                          PartitionBoundSpec *spec);

diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 0c0549db7f7e061ccda955b160f85d3a49a0bc8f..e372f8862b8816b87e51011de181b9d5e286e7d1 100644 (file)
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -112,7 +112,10 @@ extern ForeignPath *create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel,
                        Path *fdw_outerpath,
                        List *fdw_private);
 
-extern Relids calc_nestloop_required_outer(Path *outer_path, Path *inner_path);
+extern Relids calc_nestloop_required_outer(Relids outerrelids,
+                            Relids outer_paramrels,
+                            Relids innerrelids,
+                            Relids inner_paramrels);
 extern Relids calc_non_nestloop_required_outer(Path *outer_path, Path *inner_path);
 
 extern NestPath *create_nestloop_path(PlannerInfo *root,
@@ -285,5 +288,7 @@ extern ParamPathInfo *get_joinrel_parampathinfo(PlannerInfo *root,
                          List **restrict_clauses);
 extern ParamPathInfo *get_appendrel_parampathinfo(RelOptInfo *appendrel,
                            Relids required_outer);
+extern ParamPathInfo *find_param_path_info(RelOptInfo *rel,
+                    Relids required_outer);
 
 #endif                         /* PATHNODE_H */