Some further performance tweaks for planning large inheritance trees that

are mostly excluded by constraints: do the CE test a bit earlier to save
some adjust_appendrel_attrs() work on excluded children, and arrange to
use array indexing rather than rt_fetch() to fetch RTEs in the main body
of the planner.  The latter is something I'd wanted to do for awhile anyway,
but seeing list_nth_cell() as 35% of the runtime gets one's attention.

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 469e056c2deb6ae70e72da8fed333baa68c22546..0c4d359f7cdc9ec384a3874e59b3398f99d6c397 100644 (file)
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -39,7 +39,8 @@ int                   geqo_threshold;
 
 
 static void set_base_rel_pathlists(PlannerInfo *root);
-static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti);
+static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
+                                                        Index rti, RangeTblEntry *rte);
 static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                                           RangeTblEntry *rte);
 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
@@ -144,7 +145,7 @@ set_base_rel_pathlists(PlannerInfo *root)
                if (rel->reloptkind != RELOPT_BASEREL)
                        continue;
 
-               set_rel_pathlist(root, rel, rti);
+               set_rel_pathlist(root, rel, rti, root->simple_rte_array[rti]);
        }
 }
 
@@ -153,10 +154,9 @@ set_base_rel_pathlists(PlannerInfo *root)
  *       Build access paths for a base relation
  */
 static void
-set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti)
+set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
+                                Index rti, RangeTblEntry *rte)
 {
-       RangeTblEntry *rte = rt_fetch(rti, root->parse->rtable);
-
        if (rte->inh)
        {
                /* It's an "append relation", process accordingly */
@@ -200,8 +200,11 @@ set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
         * If we can prove we don't need to scan the rel via constraint exclusion,
         * set up a single dummy path for it.  (Rather than inventing a special
         * "dummy" path type, we represent this as an AppendPath with no members.)
+        * We only need to check for regular baserels; if it's an otherrel, CE
+        * was already checked in set_append_rel_pathlist().
         */
-       if (relation_excluded_by_constraints(rel, rte))
+       if (rel->reloptkind == RELOPT_BASEREL &&
+               relation_excluded_by_constraints(rel, rte))
        {
                /* Set dummy size estimates --- we leave attr_widths[] as zeroes */
                rel->rows = 0;
@@ -294,6 +297,7 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
        {
                AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
                int                     childRTindex;
+               RangeTblEntry *childRTE;
                RelOptInfo *childrel;
                Path       *childpath;
                ListCell   *parentvars;
@@ -304,6 +308,7 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                        continue;
 
                childRTindex = appinfo->child_relid;
+               childRTE = root->simple_rte_array[childRTindex];
 
                /*
                 * The child rel's RelOptInfo was already created during
@@ -313,18 +318,29 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
                /*
-                * Copy the parent's targetlist and quals to the child, with
-                * appropriate substitution of variables.
+                * We have to copy the parent's targetlist and quals to the child,
+                * with appropriate substitution of variables.  However, only the
+                * baserestrictinfo quals are needed before we can check for
+                * constraint exclusion; so do that first and then check to see
+                * if we can disregard this child.
                 */
-               childrel->reltargetlist = (List *)
-                       adjust_appendrel_attrs((Node *) rel->reltargetlist,
-                                                                  appinfo);
                childrel->baserestrictinfo = (List *)
                        adjust_appendrel_attrs((Node *) rel->baserestrictinfo,
                                                                   appinfo);
+
+               if (relation_excluded_by_constraints(childrel, childRTE))
+               {
+                       /* this child need not be scanned, so just disregard it */
+                       continue;
+               }
+
+               /* CE failed, so finish copying targetlist and join quals */
                childrel->joininfo = (List *)
                        adjust_appendrel_attrs((Node *) rel->joininfo,
                                                                   appinfo);
+               childrel->reltargetlist = (List *)
+                       adjust_appendrel_attrs((Node *) rel->reltargetlist,
+                                                                  appinfo);
 
                /*
                 * We have to make child entries in the EquivalenceClass data
@@ -353,12 +369,9 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                 * It's possible that the child is itself an appendrel, in which case
                 * we can "cut out the middleman" and just add its child paths to our
                 * own list.  (We don't try to do this earlier because we need to
-                * apply both levels of transformation to the quals.) This test also
-                * handles the case where the child rel need not be scanned because of
-                * constraint exclusion: it'll have an Append path with no subpaths,
-                * and will vanish from our list.
+                * apply both levels of transformation to the quals.)
                 */
-               set_rel_pathlist(root, childrel, childRTindex);
+               set_rel_pathlist(root, childrel, childRTindex, childRTE);
 
                childpath = childrel->cheapest_total_path;
                if (IsA(childpath, AppendPath))

diff --git a/src/backend/optimizer/path/clausesel.c b/src/backend/optimizer/path/clausesel.c
index 6f8dee88305cacaf0eaf11b4e238c6fcef992aa7..ab05270ee16fad29a9699028877a0a9f6173f1d0 100644 (file)
--- a/src/backend/optimizer/path/clausesel.c
+++ b/src/backend/optimizer/path/clausesel.c
@@ -500,7 +500,7 @@ clause_selectivity(PlannerInfo *root,
                if (var->varlevelsup == 0 &&
                        (varRelid == 0 || varRelid == (int) var->varno))
                {
-                       RangeTblEntry *rte = rt_fetch(var->varno, root->parse->rtable);
+                       RangeTblEntry *rte = planner_rt_fetch(var->varno, root);
 
                        if (rte->rtekind == RTE_SUBQUERY)
                        {

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 7c10f475368f1165de543b6b40712967f438cf2e..74b4c8ed268b16ad89ce7d80b0bdf0299be29a70 100644 (file)
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -856,7 +856,7 @@ cost_functionscan(Path *path, PlannerInfo *root, RelOptInfo *baserel)
 
        /* Should only be applied to base relations that are functions */
        Assert(baserel->relid > 0);
-       rte = rt_fetch(baserel->relid, root->parse->rtable);
+       rte = planner_rt_fetch(baserel->relid, root);
        Assert(rte->rtekind == RTE_FUNCTION);
 
        /* Estimate costs of executing the function expression */
@@ -2297,7 +2297,7 @@ set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel)
 
        /* Should only be applied to base relations that are functions */
        Assert(rel->relid > 0);
-       rte = rt_fetch(rel->relid, root->parse->rtable);
+       rte = planner_rt_fetch(rel->relid, root);
        Assert(rte->rtekind == RTE_FUNCTION);
 
        /* Estimate number of rows the function itself will return */
@@ -2323,7 +2323,7 @@ set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel)
 
        /* Should only be applied to base relations that are values lists */
        Assert(rel->relid > 0);
-       rte = rt_fetch(rel->relid, root->parse->rtable);
+       rte = planner_rt_fetch(rel->relid, root);
        Assert(rte->rtekind == RTE_VALUES);
 
        /*

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index ab248e21f7f21d991a14570b9b46ca4629cda18a..57a5a078377444c7ec1e94cc762cc7855e5f8ed5 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -1353,7 +1353,7 @@ create_functionscan_plan(PlannerInfo *root, Path *best_path,
 
        /* it should be a function base rel... */
        Assert(scan_relid > 0);
-       rte = rt_fetch(scan_relid, root->parse->rtable);
+       rte = planner_rt_fetch(scan_relid, root);
        Assert(rte->rtekind == RTE_FUNCTION);
 
        /* Sort clauses into best execution order */
@@ -1388,7 +1388,7 @@ create_valuesscan_plan(PlannerInfo *root, Path *best_path,
 
        /* it should be a values base rel... */
        Assert(scan_relid > 0);
-       rte = rt_fetch(scan_relid, root->parse->rtable);
+       rte = planner_rt_fetch(scan_relid, root);
        Assert(rte->rtekind == RTE_VALUES);
 
        /* Sort clauses into best execution order */

diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c
index 530dbe77ca020361aa2959c1ba85810a78578374..dad950320d68885c91a57882225bcb1235125017 100644 (file)
--- a/src/backend/optimizer/plan/planagg.c
+++ b/src/backend/optimizer/plan/planagg.c
@@ -116,7 +116,7 @@ optimize_minmax_aggregates(PlannerInfo *root, List *tlist, Path *best_path)
        if (!IsA(jtnode, RangeTblRef))
                return NULL;
        rtr = (RangeTblRef *) jtnode;
-       rte = rt_fetch(rtr->rtindex, parse->rtable);
+       rte = planner_rt_fetch(rtr->rtindex, root);
        if (rte->rtekind != RTE_RELATION || rte->inh)
                return NULL;
        rel = find_base_rel(root, rtr->rtindex);

diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
index 4eefaa7d71a9898f9194953265584946dfc60d3a..c0b8dab4cbcfeba8ce1850d44eb6ef528cabd177 100644 (file)
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -86,6 +86,7 @@ query_planner(PlannerInfo *root, List *tlist, double tuple_fraction,
        Path       *cheapestpath;
        Path       *sortedpath;
        Index           rti;
+       ListCell   *lc;
        double          total_pages;
 
        /* Make tuple_fraction accessible to lower-level routines */
@@ -123,6 +124,20 @@ query_planner(PlannerInfo *root, List *tlist, double tuple_fraction,
        root->full_join_clauses = NIL;
        root->oj_info_list = NIL;
 
+       /*
+        * Make a flattened version of the rangetable for faster access (this
+        * is OK because the rangetable won't change any more).
+        */
+       root->simple_rte_array = (RangeTblEntry **)
+               palloc0(root->simple_rel_array_size * sizeof(RangeTblEntry *));
+       rti = 1;
+       foreach(lc, parse->rtable)
+       {
+               RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
+
+               root->simple_rte_array[rti++] = rte;
+       }
+
        /*
         * Construct RelOptInfo nodes for all base relations in query, and
         * indirectly for all appendrel member relations ("other rels").  This

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index be273186f152746b5470666e9200cfa53ce1c83f..ce25b077db442a0903afd30d61abdc21722c52e9 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -800,7 +800,7 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath)
         */
        if (sub_targetlist && rel->rtekind == RTE_SUBQUERY)
        {
-               RangeTblEntry *rte = rt_fetch(rel->relid, root->parse->rtable);
+               RangeTblEntry *rte = planner_rt_fetch(rel->relid, root);
                List       *sub_tlist_colnos;
 
                sub_tlist_colnos = translate_sub_tlist(sub_targetlist, rel->relid);

diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 7a898833f4ceb05ae5922f343a975865c3ad2cfe..fd29e537204e1b68f395a7d4c4d55f7acd86a53e 100644 (file)
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -497,6 +497,9 @@ get_relation_constraints(Oid relationObjectId, RelOptInfo *rel)
  * Detect whether the relation need not be scanned because it has either
  * self-inconsistent restrictions, or restrictions inconsistent with the
  * relation's CHECK constraints.
+ *
+ * Note: this examines only rel->relid and rel->baserestrictinfo; therefore
+ * it can be called before filling in other fields of the RelOptInfo.
  */
 bool
 relation_excluded_by_constraints(RelOptInfo *rel, RangeTblEntry *rte)
@@ -595,7 +598,7 @@ build_physical_tlist(PlannerInfo *root, RelOptInfo *rel)
 {
        List       *tlist = NIL;
        Index           varno = rel->relid;
-       RangeTblEntry *rte = rt_fetch(varno, root->parse->rtable);
+       RangeTblEntry *rte = planner_rt_fetch(varno, root);
        Relation        relation;
        Query      *subquery;
        Var                *var;

diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index dbbcfe0b2040526de53ce9827f09b59eabc8ebd2..a0806e58b846805b225d43e5f76b40a4129a2717 100644 (file)
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -56,15 +56,15 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptKind reloptkind)
        RelOptInfo *rel;
        RangeTblEntry *rte;
 
-       /* Fetch RTE for relation */
-       Assert(relid > 0 && relid <= list_length(root->parse->rtable));
-       rte = rt_fetch(relid, root->parse->rtable);
-
        /* Rel should not exist already */
-       Assert(relid < root->simple_rel_array_size);
+       Assert(relid > 0 && relid < root->simple_rel_array_size);
        if (root->simple_rel_array[relid] != NULL)
                elog(ERROR, "rel %d already exists", relid);
 
+       /* Fetch RTE for relation */
+       rte = root->simple_rte_array[relid];
+       Assert(rte != NULL);
+
        rel = makeNode(RelOptInfo);
        rel->reloptkind = reloptkind;
        rel->relids = bms_make_singleton(relid);

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index abc45ea7902f0dc03386550827fdc0c9eeaaa3da..10915624109665b0e1c0f16c5460929291d93606 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -3487,7 +3487,7 @@ examine_variable(PlannerInfo *root, Node *node, int varRelid,
                vardata->atttype = var->vartype;
                vardata->atttypmod = var->vartypmod;
 
-               rte = rt_fetch(var->varno, root->parse->rtable);
+               rte = root->simple_rte_array[var->varno];
 
                if (rte->inh)
                {

diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index caf01c28e5ff4cc8a85b6ebe60a93f7f2aa7db6b..95a4a4057d1542ec04a76d9fc9daf38ba5dd5d67 100644 (file)
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -108,6 +108,14 @@ typedef struct PlannerInfo
        struct RelOptInfo **simple_rel_array;           /* All 1-rel RelOptInfos */
        int                     simple_rel_array_size;  /* allocated size of array */
 
+       /*
+        * simple_rte_array is the same length as simple_rel_array and holds
+        * pointers to the associated rangetable entries.  This lets us avoid
+        * rt_fetch(), which can be a bit slow once large inheritance sets have
+        * been expanded.
+        */
+       RangeTblEntry **simple_rte_array;                       /* rangetable as an array */
+
        /*
         * join_rel_list is a list of all join-relation RelOptInfos we have
         * considered in this planning run.  For small problems we just scan the
@@ -167,6 +175,16 @@ typedef struct PlannerInfo
 } PlannerInfo;
 
 
+/*
+ * In places where it's known that simple_rte_array[] must have been prepared
+ * already, we just index into it to fetch RTEs.  In code that might be
+ * executed before or after entering query_planner(), use this macro.
+ */
+#define planner_rt_fetch(rti, root) \
+       ((root)->simple_rte_array ? (root)->simple_rte_array[rti] : \
+        rt_fetch(rti, (root)->parse->rtable))
+
+
 /*----------
  * RelOptInfo
  *             Per-relation information for planning/optimization