open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

If a LIMIT is applied to a UNION ALL query, plan each UNION arm as

Browse Source 
if the limit were directly applied to it.  This does not actually
add a LIMIT plan node to the generated subqueries --- that would be
useless overhead --- but it does cause the planner to prefer fast-
start plans when the limit is small.  After an idea from Phil Endecott.
REL8_1_STABLE
Tom Lane 21 years ago
parent 39cee73889
commit 3b167a4099
3 changed files with 178 additions and 118 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 231
      src/backend/optimizer/plan/planner.c
  2. 60
      src/backend/optimizer/prep/prepunion.c
  3. 5
      src/include/optimizer/prep.h

231
src/backend/optimizer/plan/planner.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.188 2005/06/05 22:32:56 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.189 2005/06/10 02:21:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -58,6 +58,8 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
static Plan *inheritance_planner(PlannerInfo *root, List *inheritlist);
static Plan *grouping_planner(PlannerInfo *root, double tuple_fraction);
static double adjust_tuple_fraction_for_limit(PlannerInfo *root,
double tuple_fraction);
static bool choose_hashed_grouping(PlannerInfo *root, double tuple_fraction,
Path *cheapest_path, Path *sorted_path,
List *sort_pathkeys, List *group_pathkeys,
@ -648,15 +650,30 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
List *current_pathkeys;
List *sort_pathkeys;
/* Tweak caller-supplied tuple_fraction if have LIMIT */
if (parse->limitCount != NULL)
tuple_fraction = adjust_tuple_fraction_for_limit(root, tuple_fraction);
if (parse->setOperations)
{
List *set_sortclauses;
/*
* If there's a top-level ORDER BY, assume we have to fetch all
* the tuples. This might seem too simplistic given all the
* hackery below to possibly avoid the sort ... but a nonzero
* tuple_fraction is only of use to plan_set_operations() when
* the setop is UNION ALL, and the result of UNION ALL is always
* unsorted.
*/
if (parse->sortClause)
tuple_fraction = 0.0;
/*
* Construct the plan for set operations. The result will not
* need any work except perhaps a top-level sort and/or LIMIT.
*/
result_plan = plan_set_operations(root,
result_plan = plan_set_operations(root, tuple_fraction,
&set_sortclauses);
/*
@ -769,108 +786,6 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
else
root->query_pathkeys = NIL;
/*
* Adjust tuple_fraction if we see that we are going to apply
* limiting/grouping/aggregation/etc. This is not overridable by
* the caller, since it reflects plan actions that this routine
* will certainly take, not assumptions about context.
*/
if (parse->limitCount != NULL)
{
/*
* A LIMIT clause limits the absolute number of tuples
* returned. However, if it's not a constant LIMIT then we
* have to punt; for lack of a better idea, assume 10% of the
* plan's result is wanted.
*/
double limit_fraction = 0.0;
if (IsA(parse->limitCount, Const))
{
Const *limitc = (Const *) parse->limitCount;
int32 count = DatumGetInt32(limitc->constvalue);
/*
* A NULL-constant LIMIT represents "LIMIT ALL", which we
* treat the same as no limit (ie, expect to retrieve all
* the tuples).
*/
if (!limitc->constisnull && count > 0)
{
limit_fraction = (double) count;
/* We must also consider the OFFSET, if present */
if (parse->limitOffset != NULL)
{
if (IsA(parse->limitOffset, Const))
{
int32 offset;
limitc = (Const *) parse->limitOffset;
offset = DatumGetInt32(limitc->constvalue);
if (!limitc->constisnull && offset > 0)
limit_fraction += (double) offset;
}
else
{
/* OFFSET is an expression ... punt ... */
limit_fraction = 0.10;
}
}
}
}
else
{
/* LIMIT is an expression ... punt ... */
limit_fraction = 0.10;
}
if (limit_fraction > 0.0)
{
/*
* If we have absolute limits from both caller and LIMIT,
* use the smaller value; if one is fractional and the
* other absolute, treat the fraction as a fraction of the
* absolute value; else we can multiply the two fractions
* together.
*/
if (tuple_fraction >= 1.0)
{
if (limit_fraction >= 1.0)
{
/* both absolute */
tuple_fraction = Min(tuple_fraction, limit_fraction);
}
else
{
/* caller absolute, limit fractional */
tuple_fraction *= limit_fraction;
if (tuple_fraction < 1.0)
tuple_fraction = 1.0;
}
}
else if (tuple_fraction > 0.0)
{
if (limit_fraction >= 1.0)
{
/* caller fractional, limit absolute */
tuple_fraction *= limit_fraction;
if (tuple_fraction < 1.0)
tuple_fraction = 1.0;
}
else
{
/* both fractional */
tuple_fraction *= limit_fraction;
}
}
else
{
/* no info from caller, just use limit */
tuple_fraction = limit_fraction;
}
}
}
/*
* With grouping or aggregation, the tuple fraction to pass to
* query_planner() may be different from what it is at top level.
@ -1242,6 +1157,114 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
return result_plan;
}
/*
* adjust_tuple_fraction_for_limit - adjust tuple fraction for LIMIT
*
* If the query contains LIMIT, we adjust the caller-supplied tuple_fraction
* accordingly. This is not overridable by the caller, since it reflects plan
* actions that grouping_planner() will certainly take, not assumptions about
* context.
*/
static double
adjust_tuple_fraction_for_limit(PlannerInfo *root, double tuple_fraction)
{
Query *parse = root->parse;
double limit_fraction = 0.0;
/* Should not be called unless LIMIT */
Assert(parse->limitCount != NULL);
/*
* A LIMIT clause limits the absolute number of tuples returned. However,
* if it's not a constant LIMIT then we have to punt; for lack of a better
* idea, assume 10% of the plan's result is wanted.
*/
if (IsA(parse->limitCount, Const))
{
Const *limitc = (Const *) parse->limitCount;
int32 count = DatumGetInt32(limitc->constvalue);
/*
* A NULL-constant LIMIT represents "LIMIT ALL", which we treat the
* same as no limit (ie, expect to retrieve all the tuples).
*/
if (!limitc->constisnull && count > 0)
{
limit_fraction = (double) count;
/* We must also consider the OFFSET, if present */
if (parse->limitOffset != NULL)
{
if (IsA(parse->limitOffset, Const))
{
int32 offset;
limitc = (Const *) parse->limitOffset;
offset = DatumGetInt32(limitc->constvalue);
if (!limitc->constisnull && offset > 0)
limit_fraction += (double) offset;
}
else
{
/* OFFSET is an expression ... punt ... */
limit_fraction = 0.10;
}
}
}
}
else
{
/* LIMIT is an expression ... punt ... */
limit_fraction = 0.10;
}
if (limit_fraction > 0.0)
{
/*
* If we have absolute limits from both caller and LIMIT, use the
* smaller value; if one is fractional and the other absolute,
* treat the fraction as a fraction of the absolute value;
* else we can multiply the two fractions together.
*/
if (tuple_fraction >= 1.0)
{
if (limit_fraction >= 1.0)
{
/* both absolute */
tuple_fraction = Min(tuple_fraction, limit_fraction);
}
else
{
/* caller absolute, limit fractional */
tuple_fraction *= limit_fraction;
if (tuple_fraction < 1.0)
tuple_fraction = 1.0;
}
}
else if (tuple_fraction > 0.0)
{
if (limit_fraction >= 1.0)
{
/* caller fractional, limit absolute */
tuple_fraction *= limit_fraction;
if (tuple_fraction < 1.0)
tuple_fraction = 1.0;
}
else
{
/* both fractional */
tuple_fraction *= limit_fraction;
}
}
else
{
/* no info from caller, just use limit */
tuple_fraction = limit_fraction;
}
}
return tuple_fraction;
}
/*
* choose_hashed_grouping - should we use hashed grouping?
*/

60
src/backend/optimizer/prep/prepunion.c
Unescape View File

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.123 2005/06/09 04:18:59 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.124 2005/06/10 02:21:05 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -50,16 +50,19 @@ typedef struct
} adjust_inherited_attrs_context;
static Plan *recurse_set_operations(Node *setOp, PlannerInfo *root,
List *colTypes, bool junkOK,
int flag, List *refnames_tlist,
List **sortClauses);
double tuple_fraction,
List *colTypes, bool junkOK,
int flag, List *refnames_tlist,
List **sortClauses);
static Plan *generate_union_plan(SetOperationStmt *op, PlannerInfo *root,
List *refnames_tlist, List **sortClauses);
double tuple_fraction,
List *refnames_tlist, List **sortClauses);
static Plan *generate_nonunion_plan(SetOperationStmt *op, PlannerInfo *root,
List *refnames_tlist, List **sortClauses);
static List *recurse_union_children(Node *setOp, PlannerInfo *root,
SetOperationStmt *top_union,
List *refnames_tlist);
double tuple_fraction,
SetOperationStmt *top_union,
List *refnames_tlist);
static List *generate_setop_tlist(List *colTypes, int flag,
Index varno,
bool hack_constants,
@ -85,11 +88,17 @@ static List *adjust_inherited_tlist(List *tlist,
* Any top-level ORDER BY requested in root->parse->sortClause will be added
* when we return to grouping_planner.
*
* tuple_fraction is the fraction of tuples we expect will be retrieved.
* tuple_fraction is interpreted as for grouping_planner(); in particular,
* zero means "all the tuples will be fetched". Any LIMIT present at the
* top level has already been factored into tuple_fraction.
*
* *sortClauses is an output argument: it is set to a list of SortClauses
* representing the result ordering of the topmost set operation.
*/
Plan *
plan_set_operations(PlannerInfo *root, List **sortClauses)
plan_set_operations(PlannerInfo *root, double tuple_fraction,
List **sortClauses)
{
Query *parse = root->parse;
SetOperationStmt *topop = (SetOperationStmt *) parse->setOperations;
@ -124,7 +133,7 @@ plan_set_operations(PlannerInfo *root, List **sortClauses)
* output from the top-level node, plus possibly resjunk working
* columns (we can rely on upper-level nodes to deal with that).
*/
return recurse_set_operations((Node *) topop, root,
return recurse_set_operations((Node *) topop, root, tuple_fraction,
topop->colTypes, true, -1,
leftmostQuery->targetList,
sortClauses);
@ -134,6 +143,7 @@ plan_set_operations(PlannerInfo *root, List **sortClauses)
* recurse_set_operations
* Recursively handle one step in a tree of set operations
*
* tuple_fraction: fraction of tuples we expect to retrieve from node
* colTypes: list of type OIDs of expected output columns
* junkOK: if true, child resjunk columns may be left in the result
* flag: if >= 0, add a resjunk output column indicating value of flag
@ -142,6 +152,7 @@ plan_set_operations(PlannerInfo *root, List **sortClauses)
*/
static Plan *
recurse_set_operations(Node *setOp, PlannerInfo *root,
double tuple_fraction,
List *colTypes, bool junkOK,
int flag, List *refnames_tlist,
List **sortClauses)
@ -159,7 +170,7 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
/*
* Generate plan for primitive subquery
*/
subplan = subquery_planner(subquery, 0.0 /* default case */, NULL);
subplan = subquery_planner(subquery, tuple_fraction, NULL);
/*
* Add a SubqueryScan with the caller-requested targetlist
@ -189,10 +200,12 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
/* UNIONs are much different from INTERSECT/EXCEPT */
if (op->op == SETOP_UNION)
plan = generate_union_plan(op, root, refnames_tlist,
plan = generate_union_plan(op, root, tuple_fraction,
refnames_tlist,
sortClauses);
else
plan = generate_nonunion_plan(op, root, refnames_tlist,
plan = generate_nonunion_plan(op, root,
refnames_tlist,
sortClauses);
/*
@ -235,6 +248,7 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
*/
static Plan *
generate_union_plan(SetOperationStmt *op, PlannerInfo *root,
double tuple_fraction,
List *refnames_tlist,
List **sortClauses)
{
@ -242,6 +256,20 @@ generate_union_plan(SetOperationStmt *op, PlannerInfo *root,
List *tlist;
Plan *plan;
/*
* If plain UNION, tell children to fetch all tuples.
*
* Note: in UNION ALL, we pass the top-level tuple_fraction unmodified
* to each arm of the UNION ALL. One could make a case for reducing
* the tuple fraction for later arms (discounting by the expected size
* of the earlier arms' results) but it seems not worth the trouble.
* The normal case where tuple_fraction isn't already zero is a LIMIT
* at top level, and passing it down as-is is usually enough to get the
* desired result of preferring fast-start plans.
*/
if (!op->all)
tuple_fraction = 0.0;
/*
* If any of my children are identical UNION nodes (same op, all-flag,
* and colTypes) then they can be merged into this node so that we
@ -249,8 +277,10 @@ generate_union_plan(SetOperationStmt *op, PlannerInfo *root,
* such nodes and compute their children's plans.
*/
planlist = list_concat(recurse_union_children(op->larg, root,
tuple_fraction,
op, refnames_tlist),
recurse_union_children(op->rarg, root,
tuple_fraction,
op, refnames_tlist));
/*
@ -309,10 +339,12 @@ generate_nonunion_plan(SetOperationStmt *op, PlannerInfo *root,
/* Recurse on children, ensuring their outputs are marked */
lplan = recurse_set_operations(op->larg, root,
0.0 /* all tuples needed */,
op->colTypes, false, 0,
refnames_tlist,
&child_sortclauses);
rplan = recurse_set_operations(op->rarg, root,
0.0 /* all tuples needed */,
op->colTypes, false, 1,
refnames_tlist,
&child_sortclauses);
@ -377,6 +409,7 @@ generate_nonunion_plan(SetOperationStmt *op, PlannerInfo *root,
*/
static List *
recurse_union_children(Node *setOp, PlannerInfo *root,
double tuple_fraction,
SetOperationStmt *top_union,
List *refnames_tlist)
{
@ -392,9 +425,11 @@ recurse_union_children(Node *setOp, PlannerInfo *root,
{
/* Same UNION, so fold children into parent's subplan list */
return list_concat(recurse_union_children(op->larg, root,
tuple_fraction,
top_union,
refnames_tlist),
recurse_union_children(op->rarg, root,
tuple_fraction,
top_union,
refnames_tlist));
}
@ -411,6 +446,7 @@ recurse_union_children(Node *setOp, PlannerInfo *root,
* resjunk anyway.
*/
return list_make1(recurse_set_operations(setOp, root,
tuple_fraction,
top_union->colTypes, false,
-1, refnames_tlist,
&child_sortclauses));

5
src/include/optimizer/prep.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/optimizer/prep.h,v 1.50 2005/06/05 22:32:58 tgl Exp $
* $PostgreSQL: pgsql/src/include/optimizer/prep.h,v 1.51 2005/06/10 02:21:05 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -45,7 +45,8 @@ extern List *preprocess_targetlist(PlannerInfo *root, List *tlist);
/*
* prototypes for prepunion.c
*/
extern Plan *plan_set_operations(PlannerInfo *root, List **sortClauses);
extern Plan *plan_set_operations(PlannerInfo *root, double tuple_fraction,
List **sortClauses);
extern List *find_all_inheritors(Oid parentrel);

Write Preview
Loading…
Cancel
Save