Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit034967b

Browse files
committed
Reimplement planner's handling of MIN/MAX aggregate optimization.
Per my recent proposal, get rid of all the direct inspection of indexesand manual generation of paths in planagg.c. Instead, set upEquivalenceClasses for the aggregate argument expressions, and let theregular path generation logic deal with creating paths that can satisfythose sort orders. This makes planagg.c a bit more visible to the restof the planner than it was originally, but the approach is basically a lotcleaner than before. A major advantage of doing it this way is that we getMIN/MAX optimization on inheritance trees (using MergeAppend of indexscans)practically for free, whereas in the old way we'd have had to add a wholelot more duplicative logic.One small disadvantage of this approach is that MIN/MAX aggregates can nolonger exploit partial indexes having an "x IS NOT NULL" predicate, unlessthat restriction or something that implies it is specified in the query.The previous implementation was able to use the added "x IS NOT NULL"condition as an extra predicate proof condition, but in this version werely entirely on indexes that are considered usable by the main planningprocess. That seems a fair tradeoff for the simplicity and functionalitygained.
1 parent0abc8fd commit034967b

File tree

18 files changed

+873
-471
lines changed

18 files changed

+873
-471
lines changed

‎src/backend/nodes/copyfuncs.c

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1837,6 +1837,22 @@ _copyPlaceHolderInfo(PlaceHolderInfo *from)
18371837
returnnewnode;
18381838
}
18391839

1840+
/*
1841+
* _copyMinMaxAggInfo
1842+
*/
1843+
staticMinMaxAggInfo*
1844+
_copyMinMaxAggInfo(MinMaxAggInfo*from)
1845+
{
1846+
MinMaxAggInfo*newnode=makeNode(MinMaxAggInfo);
1847+
1848+
COPY_SCALAR_FIELD(aggfnoid);
1849+
COPY_SCALAR_FIELD(aggsortop);
1850+
COPY_NODE_FIELD(target);
1851+
COPY_NODE_FIELD(pathkeys);
1852+
1853+
returnnewnode;
1854+
}
1855+
18401856
/* ****************************************************************
18411857
*parsenodes.h copy functions
18421858
* ****************************************************************
@@ -3921,6 +3937,9 @@ copyObject(void *from)
39213937
caseT_PlaceHolderInfo:
39223938
retval=_copyPlaceHolderInfo(from);
39233939
break;
3940+
caseT_MinMaxAggInfo:
3941+
retval=_copyMinMaxAggInfo(from);
3942+
break;
39243943

39253944
/*
39263945
* VALUE NODES

‎src/backend/nodes/equalfuncs.c

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -844,6 +844,17 @@ _equalPlaceHolderInfo(PlaceHolderInfo *a, PlaceHolderInfo *b)
844844
return true;
845845
}
846846

847+
staticbool
848+
_equalMinMaxAggInfo(MinMaxAggInfo*a,MinMaxAggInfo*b)
849+
{
850+
COMPARE_SCALAR_FIELD(aggfnoid);
851+
COMPARE_SCALAR_FIELD(aggsortop);
852+
COMPARE_NODE_FIELD(target);
853+
COMPARE_NODE_FIELD(pathkeys);
854+
855+
return true;
856+
}
857+
847858

848859
/*
849860
* Stuff from parsenodes.h
@@ -2568,6 +2579,9 @@ equal(void *a, void *b)
25682579
caseT_PlaceHolderInfo:
25692580
retval=_equalPlaceHolderInfo(a,b);
25702581
break;
2582+
caseT_MinMaxAggInfo:
2583+
retval=_equalMinMaxAggInfo(a,b);
2584+
break;
25712585

25722586
caseT_List:
25732587
caseT_IntList:

‎src/backend/nodes/outfuncs.c

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1608,6 +1608,7 @@ _outPlannerInfo(StringInfo str, PlannerInfo *node)
16081608
WRITE_NODE_FIELD(window_pathkeys);
16091609
WRITE_NODE_FIELD(distinct_pathkeys);
16101610
WRITE_NODE_FIELD(sort_pathkeys);
1611+
WRITE_NODE_FIELD(minmax_aggs);
16111612
WRITE_FLOAT_FIELD(total_table_pages,"%.0f");
16121613
WRITE_FLOAT_FIELD(tuple_fraction,"%.4f");
16131614
WRITE_BOOL_FIELD(hasInheritedTarget);
@@ -1808,6 +1809,17 @@ _outPlaceHolderInfo(StringInfo str, PlaceHolderInfo *node)
18081809
WRITE_INT_FIELD(ph_width);
18091810
}
18101811

1812+
staticvoid
1813+
_outMinMaxAggInfo(StringInfostr,MinMaxAggInfo*node)
1814+
{
1815+
WRITE_NODE_TYPE("MINMAXAGGINFO");
1816+
1817+
WRITE_OID_FIELD(aggfnoid);
1818+
WRITE_OID_FIELD(aggsortop);
1819+
WRITE_NODE_FIELD(target);
1820+
WRITE_NODE_FIELD(pathkeys);
1821+
}
1822+
18111823
staticvoid
18121824
_outPlannerParamItem(StringInfostr,PlannerParamItem*node)
18131825
{
@@ -2845,6 +2857,9 @@ _outNode(StringInfo str, void *obj)
28452857
caseT_PlaceHolderInfo:
28462858
_outPlaceHolderInfo(str,obj);
28472859
break;
2860+
caseT_MinMaxAggInfo:
2861+
_outMinMaxAggInfo(str,obj);
2862+
break;
28482863
caseT_PlannerParamItem:
28492864
_outPlannerParamItem(str,obj);
28502865
break;

‎src/backend/optimizer/path/pathkeys.c

Lines changed: 92 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -912,6 +912,39 @@ make_pathkeys_for_sortclauses(PlannerInfo *root,
912912
returnpathkeys;
913913
}
914914

915+
/****************************************************************************
916+
*PATHKEYS AND AGGREGATES
917+
****************************************************************************/
918+
919+
/*
920+
* make_pathkeys_for_aggregate
921+
*Generate a pathkeys list (always a 1-item list) that represents
922+
*the sort order needed by a MIN/MAX aggregate
923+
*
924+
* This is only called before EquivalenceClass merging, so we can assume
925+
* we are not supposed to canonicalize.
926+
*/
927+
List*
928+
make_pathkeys_for_aggregate(PlannerInfo*root,
929+
Expr*aggtarget,
930+
Oidaggsortop)
931+
{
932+
PathKey*pathkey;
933+
934+
/*
935+
* We arbitrarily set nulls_first to false. Actually, a MIN/MAX agg can
936+
* use either nulls ordering option, but that is dealt with elsewhere.
937+
*/
938+
pathkey=make_pathkey_from_sortinfo(root,
939+
aggtarget,
940+
aggsortop,
941+
false,/* nulls_first */
942+
0,
943+
true,
944+
false);
945+
returnlist_make1(pathkey);
946+
}
947+
915948
/****************************************************************************
916949
*PATHKEYS AND MERGECLAUSES
917950
****************************************************************************/
@@ -1379,10 +1412,11 @@ make_inner_pathkeys_for_merge(PlannerInfo *root,
13791412
*PATHKEY USEFULNESS CHECKS
13801413
*
13811414
* We only want to remember as many of the pathkeys of a path as have some
1382-
* potential use, either for subsequent mergejoins or for meeting the query's
1383-
* requested output ordering. This ensures that add_path() won't consider
1384-
* a path to have a usefully different ordering unless it really is useful.
1385-
* These routines check for usefulness of given pathkeys.
1415+
* potential use, which can include subsequent mergejoins, meeting the query's
1416+
* requested output ordering, or implementing MIN/MAX aggregates. This
1417+
* ensures that add_path() won't consider a path to have a usefully different
1418+
* ordering unless it really is useful. These routines check for usefulness
1419+
* of given pathkeys.
13861420
****************************************************************************/
13871421

13881422
/*
@@ -1403,7 +1437,7 @@ make_inner_pathkeys_for_merge(PlannerInfo *root,
14031437
* that direction should be preferred, in hopes of avoiding a final sort step.
14041438
* right_merge_direction() implements this heuristic.
14051439
*/
1406-
int
1440+
staticint
14071441
pathkeys_useful_for_merging(PlannerInfo*root,RelOptInfo*rel,List*pathkeys)
14081442
{
14091443
intuseful=0;
@@ -1506,7 +1540,7 @@ right_merge_direction(PlannerInfo *root, PathKey *pathkey)
15061540
* no good to order by just the first key(s) of the requested ordering.
15071541
* So the result is always either 0 or list_length(root->query_pathkeys).
15081542
*/
1509-
int
1543+
staticint
15101544
pathkeys_useful_for_ordering(PlannerInfo*root,List*pathkeys)
15111545
{
15121546
if (root->query_pathkeys==NIL)
@@ -1524,6 +1558,50 @@ pathkeys_useful_for_ordering(PlannerInfo *root, List *pathkeys)
15241558
return0;/* path ordering not useful */
15251559
}
15261560

1561+
/*
1562+
* pathkeys_useful_for_minmax
1563+
*Count the number of pathkeys that are useful for implementing
1564+
*some MIN/MAX aggregate.
1565+
*
1566+
* Like pathkeys_useful_for_ordering, this is a yes-or-no affair, but
1567+
* there could be several MIN/MAX aggregates and we can match to any one.
1568+
*
1569+
* We can't use pathkeys_contained_in() because we would like to match
1570+
* pathkeys regardless of the nulls_first setting. However, we know that
1571+
* MIN/MAX aggregates will have at most one item in their pathkeys, so it's
1572+
* not too complicated to match by brute force.
1573+
*/
1574+
staticint
1575+
pathkeys_useful_for_minmax(PlannerInfo*root,List*pathkeys)
1576+
{
1577+
PathKey*pathkey;
1578+
ListCell*lc;
1579+
1580+
if (pathkeys==NIL)
1581+
return0;/* unordered path */
1582+
pathkey= (PathKey*)linitial(pathkeys);
1583+
1584+
foreach(lc,root->minmax_aggs)
1585+
{
1586+
MinMaxAggInfo*mminfo= (MinMaxAggInfo*)lfirst(lc);
1587+
PathKey*mmpathkey;
1588+
1589+
/* Ignore minmax agg if its pathkey turned out to be redundant */
1590+
if (mminfo->pathkeys==NIL)
1591+
continue;
1592+
1593+
Assert(list_length(mminfo->pathkeys)==1);
1594+
mmpathkey= (PathKey*)linitial(mminfo->pathkeys);
1595+
1596+
if (mmpathkey->pk_eclass==pathkey->pk_eclass&&
1597+
mmpathkey->pk_opfamily==pathkey->pk_opfamily&&
1598+
mmpathkey->pk_strategy==pathkey->pk_strategy)
1599+
return1;
1600+
}
1601+
1602+
return0;/* path ordering not useful */
1603+
}
1604+
15271605
/*
15281606
* truncate_useless_pathkeys
15291607
*Shorten the given pathkey list to just the useful pathkeys.
@@ -1535,11 +1613,15 @@ truncate_useless_pathkeys(PlannerInfo *root,
15351613
{
15361614
intnuseful;
15371615
intnuseful2;
1616+
intnuseful3;
15381617

15391618
nuseful=pathkeys_useful_for_merging(root,rel,pathkeys);
15401619
nuseful2=pathkeys_useful_for_ordering(root,pathkeys);
15411620
if (nuseful2>nuseful)
15421621
nuseful=nuseful2;
1622+
nuseful3=pathkeys_useful_for_minmax(root,pathkeys);
1623+
if (nuseful3>nuseful)
1624+
nuseful=nuseful3;
15431625

15441626
/*
15451627
* Note: not safe to modify input list destructively, but we can avoid
@@ -1565,8 +1647,8 @@ truncate_useless_pathkeys(PlannerInfo *root,
15651647
*
15661648
* We could make the test more complex, for example checking to see if any of
15671649
* the joinclauses are really mergejoinable, but that likely wouldn't win
1568-
* often enough to repay the extra cycles.Queries withneither ajoin nor
1569-
*a sortare reasonably common, though, so this much work seems worthwhile.
1650+
* often enough to repay the extra cycles.Queries withnojoin, sort, or
1651+
*aggregate at allare reasonably common, so this much work seems worthwhile.
15701652
*/
15711653
bool
15721654
has_useful_pathkeys(PlannerInfo*root,RelOptInfo*rel)
@@ -1575,5 +1657,7 @@ has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
15751657
return true;/* might be able to use pathkeys for merging */
15761658
if (root->query_pathkeys!=NIL)
15771659
return true;/* might be able to use them for ordering */
1660+
if (root->minmax_aggs!=NIL)
1661+
return true;/* might be able to use them for MIN/MAX */
15781662
return false;/* definitely useless */
15791663
}

‎src/backend/optimizer/plan/createplan.c

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@ static Node *replace_nestloop_params(PlannerInfo *root, Node *expr);
8181
staticNode*replace_nestloop_params_mutator(Node*node,PlannerInfo*root);
8282
staticList*fix_indexqual_references(PlannerInfo*root,IndexPath*index_path,
8383
List*indexquals);
84+
staticNode*fix_indexqual_operand(Node*node,IndexOptInfo*index);
8485
staticList*get_switched_clauses(List*clauses,Relidsouterrelids);
8586
staticList*order_qual_clauses(PlannerInfo*root,List*clauses);
8687
staticvoidcopy_path_costsize(Plan*dest,Path*src);
@@ -2396,10 +2397,8 @@ fix_indexqual_references(PlannerInfo *root, IndexPath *index_path,
23962397
/*
23972398
* fix_indexqual_operand
23982399
* Convert an indexqual expression to a Var referencing the index column.
2399-
*
2400-
* This is exported because planagg.c needs it.
24012400
*/
2402-
Node*
2401+
staticNode*
24032402
fix_indexqual_operand(Node*node,IndexOptInfo*index)
24042403
{
24052404
/*

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp