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.
This commit is contained in:
Tom Lane
parent
ac7e6c0665
commit
afcf09dd90
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.162 2007/04/21 06:18:52 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.163 2007/04/21 21:01:44 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.84 2007/02/19 07:03:28 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.85 2007/04/21 21:01:44 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@
|
|||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.180 2007/04/21 02:41:13 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.181 2007/04/21 21:01:44 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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);
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.228 2007/04/06 22:33:42 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.229 2007/04/21 21:01:44 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planagg.c,v 1.30 2007/03/17 00:11:04 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planagg.c,v 1.31 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planmain.c,v 1.99 2007/01/20 20:45:39 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planmain.c,v 1.100 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.138 2007/02/06 02:59:12 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.139 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.133 2007/04/06 22:33:42 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.134 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/relnode.c,v 1.86 2007/02/22 22:00:25 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/optimizer/util/relnode.c,v 1.87 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.232 2007/04/06 22:33:42 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.233 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.140 2007/04/06 22:33:43 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.141 2007/04/21 21:01:45 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue