From 78b30f2428736d16e6708e601f1019243cc91838 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 11 Feb 1999 14:59:09 +0000 Subject: [PATCH] More optimizer speedups. --- src/backend/nodes/copyfuncs.c | 16 ++--- src/backend/nodes/equalfuncs.c | 20 +++---- src/backend/nodes/freefuncs.c | 10 ++-- src/backend/nodes/outfuncs.c | 20 +++---- src/backend/nodes/readfuncs.c | 20 +++---- src/backend/optimizer/geqo/geqo_paths.c | 2 +- src/backend/optimizer/path/indxpath.c | 6 +- src/backend/optimizer/path/joinpath.c | 4 +- src/backend/optimizer/path/joinutils.c | 6 +- src/backend/optimizer/path/mergeutils.c | 10 ++-- src/backend/optimizer/path/orindxpath.c | 6 +- src/backend/optimizer/path/prune.c | 2 +- src/backend/optimizer/plan/createplan.c | 6 +- src/backend/optimizer/util/ordering.c | 76 +++++++++++++++++++----- src/backend/optimizer/util/pathnode.c | 79 ++++++++++++++----------- src/include/nodes/relation.h | 2 +- src/include/optimizer/ordering.h | 4 +- 17 files changed, 175 insertions(+), 114 deletions(-) diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index 5b8932af75..52b09ffa0f 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -1093,26 +1093,26 @@ CopyPathFields(Path *from, Path *newnode) newnode->path_cost = from->path_cost; - newnode->path_order = makeNode(PathOrder); - newnode->path_order->ordtype = from->path_order->ordtype; - if (from->path_order->ordtype == SORTOP_ORDER) + newnode->pathorder = makeNode(PathOrder); + newnode->pathorder->ordtype = from->pathorder->ordtype; + if (from->pathorder->ordtype == SORTOP_ORDER) { int len, i; - Oid *ordering = from->path_order->ord.sortop; + Oid *ordering = from->pathorder->ord.sortop; if (ordering) { for (len = 0; ordering[len] != 0; len++) ; - newnode->path_order->ord.sortop = (Oid *) palloc(sizeof(Oid) * (len + 1)); + newnode->pathorder->ord.sortop = (Oid *) palloc(sizeof(Oid) * (len + 1)); for (i = 0; i < len; i++) - newnode->path_order->ord.sortop[i] = ordering[i]; - newnode->path_order->ord.sortop[len] = 0; + newnode->pathorder->ord.sortop[i] = ordering[i]; + newnode->pathorder->ord.sortop[len] = 0; } } else - Node_Copy(from, newnode, path_order->ord.merge); + Node_Copy(from, newnode, pathorder->ord.merge); Node_Copy(from, newnode, pathkeys); diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index b1ccc250e1..ffd13efdc6 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -337,33 +337,33 @@ _equalPath(Path *a, Path *b) /* * if (a->path_cost != b->path_cost) return(false); */ - if (a->path_order->ordtype == SORTOP_ORDER) + if (a->pathorder->ordtype == SORTOP_ORDER) { int i = 0; - if (a->path_order->ord.sortop == NULL || - b->path_order->ord.sortop == NULL) + if (a->pathorder->ord.sortop == NULL || + b->pathorder->ord.sortop == NULL) { - if (a->path_order->ord.sortop != b->path_order->ord.sortop) + if (a->pathorder->ord.sortop != b->pathorder->ord.sortop) return false; } else { - while (a->path_order->ord.sortop[i] != 0 && - b->path_order->ord.sortop[i] != 0) + while (a->pathorder->ord.sortop[i] != 0 && + b->pathorder->ord.sortop[i] != 0) { - if (a->path_order->ord.sortop[i] != b->path_order->ord.sortop[i]) + if (a->pathorder->ord.sortop[i] != b->pathorder->ord.sortop[i]) return false; i++; } - if (a->path_order->ord.sortop[i] != 0 || - b->path_order->ord.sortop[i] != 0) + if (a->pathorder->ord.sortop[i] != 0 || + b->pathorder->ord.sortop[i] != 0) return false; } } else { - if (!equal(a->path_order->ord.merge, b->path_order->ord.merge)) + if (!equal(a->pathorder->ord.merge, b->pathorder->ord.merge)) return false; } if (!equal(a->pathkeys, b->pathkeys)) diff --git a/src/backend/nodes/freefuncs.c b/src/backend/nodes/freefuncs.c index 88047007db..2520e05c5d 100644 --- a/src/backend/nodes/freefuncs.c +++ b/src/backend/nodes/freefuncs.c @@ -756,15 +756,15 @@ _freeRelOptInfo(RelOptInfo *node) static void FreePathFields(Path *node) { - if (node->path_order->ordtype == SORTOP_ORDER) + if (node->pathorder->ordtype == SORTOP_ORDER) { - if (node->path_order->ord.sortop) - pfree(node->path_order->ord.sortop); + if (node->pathorder->ord.sortop) + pfree(node->pathorder->ord.sortop); } else - freeObject(node->path_order->ord.merge); + freeObject(node->pathorder->ord.merge); - pfree(node->path_order); /* is it an object, but we don't have + pfree(node->pathorder); /* is it an object, but we don't have separate free for it */ freeObject(node->pathkeys); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index fd7b5d9b99..67034f5ade 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -964,8 +964,8 @@ _outPath(StringInfo str, Path *node) node->path_cost); _outNode(str, node->pathkeys); - appendStringInfo(str, " :path_order "); - _outNode(str, node->path_order); + appendStringInfo(str, " :pathorder "); + _outNode(str, node->pathorder); } /* @@ -980,8 +980,8 @@ _outIndexPath(StringInfo str, IndexPath *node) node->path.path_cost); _outNode(str, node->path.pathkeys); - appendStringInfo(str, " :path_order "); - _outNode(str, node->path.path_order); + appendStringInfo(str, " :pathorder "); + _outNode(str, node->path.pathorder); appendStringInfo(str, " :indexid "); _outIntList(str, node->indexid); @@ -1002,8 +1002,8 @@ _outJoinPath(StringInfo str, JoinPath *node) node->path.path_cost); _outNode(str, node->path.pathkeys); - appendStringInfo(str, " :path_order "); - _outNode(str, node->path.path_order); + appendStringInfo(str, " :pathorder "); + _outNode(str, node->path.pathorder); appendStringInfo(str, " :pathinfo "); _outNode(str, node->pathinfo); @@ -1033,8 +1033,8 @@ _outMergePath(StringInfo str, MergePath *node) node->jpath.path.path_cost); _outNode(str, node->jpath.path.pathkeys); - appendStringInfo(str, " :path_order "); - _outNode(str, node->jpath.path.path_order); + appendStringInfo(str, " :pathorder "); + _outNode(str, node->jpath.path.pathorder); appendStringInfo(str, " :pathinfo "); _outNode(str, node->jpath.pathinfo); @@ -1073,8 +1073,8 @@ _outHashPath(StringInfo str, HashPath *node) node->jpath.path.path_cost); _outNode(str, node->jpath.path.pathkeys); - appendStringInfo(str, " :path_order "); - _outNode(str, node->jpath.path.path_order); + appendStringInfo(str, " :pathorder "); + _outNode(str, node->jpath.path.pathorder); appendStringInfo(str, " :pathinfo "); _outNode(str, node->jpath.pathinfo); diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index 4071495bc0..bbb5ae7312 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -1522,8 +1522,8 @@ _readPath() token = lsptok(NULL, &length); /* now read it */ local_node->path_cost = (Cost) atof(token); - token = lsptok(NULL, &length); /* get :path_order */ - local_node->path_order = nodeRead(true); /* now read it */ + token = lsptok(NULL, &length); /* get :pathorder */ + local_node->pathorder = nodeRead(true); /* now read it */ token = lsptok(NULL, &length); /* get :pathkeys */ local_node->pathkeys = nodeRead(true); /* now read it */ @@ -1554,8 +1554,8 @@ _readIndexPath() token = lsptok(NULL, &length); /* now read it */ local_node->path.path_cost = (Cost) atof(token); - token = lsptok(NULL, &length); /* get :path_order */ - local_node->path.path_order = nodeRead(true); /* now read it */ + token = lsptok(NULL, &length); /* get :pathorder */ + local_node->path.pathorder = nodeRead(true); /* now read it */ token = lsptok(NULL, &length); /* get :pathkeys */ local_node->path.pathkeys = nodeRead(true); /* now read it */ @@ -1593,8 +1593,8 @@ _readJoinPath() token = lsptok(NULL, &length); /* now read it */ local_node->path.path_cost = (Cost) atof(token); - token = lsptok(NULL, &length); /* get :path_order */ - local_node->path.path_order = nodeRead(true); /* now read it */ + token = lsptok(NULL, &length); /* get :pathorder */ + local_node->path.pathorder = nodeRead(true); /* now read it */ token = lsptok(NULL, &length); /* get :pathkeys */ local_node->path.pathkeys = nodeRead(true); /* now read it */ @@ -1658,8 +1658,8 @@ _readMergePath() local_node->jpath.path.path_cost = (Cost) atof(token); - token = lsptok(NULL, &length); /* get :path_order */ - local_node->jpath.path.path_order = nodeRead(true); /* now read it */ + token = lsptok(NULL, &length); /* get :pathorder */ + local_node->jpath.path.pathorder = nodeRead(true); /* now read it */ token = lsptok(NULL, &length); /* get :pathkeys */ local_node->jpath.path.pathkeys = nodeRead(true); /* now read it */ @@ -1732,8 +1732,8 @@ _readHashPath() local_node->jpath.path.path_cost = (Cost) atof(token); - token = lsptok(NULL, &length); /* get :path_order */ - local_node->jpath.path.path_order = nodeRead(true); /* now read it */ + token = lsptok(NULL, &length); /* get :pathorder */ + local_node->jpath.path.pathorder = nodeRead(true); /* now read it */ token = lsptok(NULL, &length); /* get :pathkeys */ local_node->jpath.path.pathkeys = nodeRead(true); /* now read it */ diff --git a/src/backend/optimizer/geqo/geqo_paths.c b/src/backend/optimizer/geqo/geqo_paths.c index 7a5aa7218e..31f3f49b59 100644 --- a/src/backend/optimizer/geqo/geqo_paths.c +++ b/src/backend/optimizer/geqo/geqo_paths.c @@ -113,7 +113,7 @@ geqo_rel_paths(RelOptInfo *rel) { path = (Path *) lfirst(y); - if (!path->path_order->ord.sortop) + if (!path->pathorder->ord.sortop) break; } diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c index c2754d5639..2ebdf2d043 100644 --- a/src/backend/optimizer/path/indxpath.c +++ b/src/backend/optimizer/path/indxpath.c @@ -1290,9 +1290,9 @@ index_innerjoin(Query *root, RelOptInfo *rel, List *clausegroup_list, pathnode->path.pathtype = T_IndexScan; pathnode->path.parent = rel; - pathnode->path.path_order = makeNode(PathOrder); - pathnode->path.path_order->ordtype = SORTOP_ORDER; - pathnode->path.path_order->ord.sortop = index->ordering; + pathnode->path.pathorder = makeNode(PathOrder); + pathnode->path.pathorder->ordtype = SORTOP_ORDER; + pathnode->path.pathorder->ord.sortop = index->ordering; pathnode->path.pathkeys = NIL; pathnode->indexid = index->relids; diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index 44167cf692..7b233936b3 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -327,7 +327,7 @@ match_unsorted_outer(RelOptInfo *joinrel, outerpath = (Path *) lfirst(i); - outerpath_ordering = outerpath->path_order; + outerpath_ordering = outerpath->pathorder; if (outerpath_ordering) { @@ -470,7 +470,7 @@ match_unsorted_inner(RelOptInfo *joinrel, innerpath = (Path *) lfirst(i); - innerpath_ordering = innerpath->path_order; + innerpath_ordering = innerpath->pathorder; if (innerpath_ordering) { diff --git a/src/backend/optimizer/path/joinutils.c b/src/backend/optimizer/path/joinutils.c index 0c28e33a57..a278b9ce11 100644 --- a/src/backend/optimizer/path/joinutils.c +++ b/src/backend/optimizer/path/joinutils.c @@ -214,10 +214,12 @@ match_paths_joinkeys(List *joinkeys, foreach(i, paths) { Path *path = (Path *) lfirst(i); - + int more_sort; + key_match = every_func(joinkeys, path->pathkeys, which_subkey); - if (equal_path_ordering(ordering, path->path_order) && + if (pathorder_match(ordering, path->pathorder, &more_sort) && + more_sort == 0 && length(joinkeys) == length(path->pathkeys) && key_match) { diff --git a/src/backend/optimizer/path/mergeutils.c b/src/backend/optimizer/path/mergeutils.c index b16928fb88..d81ad74d6b 100644 --- a/src/backend/optimizer/path/mergeutils.c +++ b/src/backend/optimizer/path/mergeutils.c @@ -52,17 +52,17 @@ group_clauses_by_order(List *restrictinfo_list, * Create a new mergeinfo node and add it to 'mergeinfo-list' * if one does not yet exist for this merge ordering. */ - PathOrder *path_order; + PathOrder *pathorder; MergeInfo *xmergeinfo; Expr *clause = restrictinfo->clause; Var *leftop = get_leftop(clause); Var *rightop = get_rightop(clause); JoinKey *jmkeys; - path_order = makeNode(PathOrder); - path_order->ordtype = MERGE_ORDER; - path_order->ord.merge = merge_ordering; - xmergeinfo = match_order_mergeinfo(path_order, mergeinfo_list); + pathorder = makeNode(PathOrder); + pathorder->ordtype = MERGE_ORDER; + pathorder->ord.merge = merge_ordering; + xmergeinfo = match_order_mergeinfo(pathorder, mergeinfo_list); if (inner_relid == leftop->varno) { jmkeys = makeNode(JoinKey); diff --git a/src/backend/optimizer/path/orindxpath.c b/src/backend/optimizer/path/orindxpath.c index 2a2cc03267..6fc37e0bda 100644 --- a/src/backend/optimizer/path/orindxpath.c +++ b/src/backend/optimizer/path/orindxpath.c @@ -104,14 +104,14 @@ create_or_index_paths(Query *root, pathnode->path.pathtype = T_IndexScan; pathnode->path.parent = rel; - pathnode->path.path_order = makeNode(PathOrder); - pathnode->path.path_order->ordtype = SORTOP_ORDER; + pathnode->path.pathorder = makeNode(PathOrder); + pathnode->path.pathorder->ordtype = SORTOP_ORDER; /* * This is an IndexScan, but it does index lookups based * on the order of the fields specified in the WHERE clause, * not in any order, so the sortop is NULL. */ - pathnode->path.path_order->ord.sortop = NULL; + pathnode->path.pathorder->ord.sortop = NULL; pathnode->path.pathkeys = NIL; pathnode->indexqual = lcons(clausenode, NIL); diff --git a/src/backend/optimizer/path/prune.c b/src/backend/optimizer/path/prune.c index eb1cca4675..acf417d0da 100644 --- a/src/backend/optimizer/path/prune.c +++ b/src/backend/optimizer/path/prune.c @@ -109,7 +109,7 @@ prune_rel_paths(List *rel_list) { path = (Path *) lfirst(y); - if (!path->path_order->ord.sortop) + if (!path->pathorder->ord.sortop) break; } cheapest = (JoinPath *) prune_rel_path(rel, path); diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index f9fda31e59..21cb5d63f7 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -529,14 +529,14 @@ create_mergejoin_node(MergePath *best_path, outer_tlist, inner_tlist)); - opcode = get_opcode((best_path->jpath.path.path_order->ord.merge)->join_operator); + opcode = get_opcode((best_path->jpath.path.pathorder->ord.merge)->join_operator); outer_order = (Oid *) palloc(sizeof(Oid) * 2); - outer_order[0] = (best_path->jpath.path.path_order->ord.merge)->left_operator; + outer_order[0] = (best_path->jpath.path.pathorder->ord.merge)->left_operator; outer_order[1] = 0; inner_order = (Oid *) palloc(sizeof(Oid) * 2); - inner_order[0] = (best_path->jpath.path.path_order->ord.merge)->right_operator; + inner_order[0] = (best_path->jpath.path.pathorder->ord.merge)->right_operator; inner_order[1] = 0; /* diff --git a/src/backend/optimizer/util/ordering.c b/src/backend/optimizer/util/ordering.c index ccd2a40fd0..93b5c789b5 100644 --- a/src/backend/optimizer/util/ordering.c +++ b/src/backend/optimizer/util/ordering.c @@ -18,7 +18,7 @@ #include "optimizer/internal.h" #include "optimizer/ordering.h" -static bool equal_sortops_order(Oid *ordering1, Oid *ordering2); +static bool equal_sortops_order(Oid *ordering1, Oid *ordering2, int *more_sort); /* * equal-path-ordering-- @@ -26,14 +26,27 @@ static bool equal_sortops_order(Oid *ordering1, Oid *ordering2); * */ bool -equal_path_ordering(PathOrder *path_ordering1, - PathOrder *path_ordering2) +pathorder_match(PathOrder *path_ordering1, + PathOrder *path_ordering2, + int *more_sort) { + + *more_sort = 0; + if (path_ordering1 == path_ordering2) return true; + + if (!path_ordering2) + { + *more_sort = 1; + return true; + } - if (!path_ordering1 || !path_ordering2) - return false; + if (!path_ordering1) + { + *more_sort = 2; + return true; + } if (path_ordering1->ordtype == MERGE_ORDER && path_ordering2->ordtype == MERGE_ORDER) @@ -43,19 +56,28 @@ equal_path_ordering(PathOrder *path_ordering1, else if (path_ordering1->ordtype == SORTOP_ORDER && path_ordering2->ordtype == SORTOP_ORDER) { - return (equal_sortops_order(path_ordering1->ord.sortop, - path_ordering2->ord.sortop)); + return equal_sortops_order(path_ordering1->ord.sortop, + path_ordering2->ord.sortop, + more_sort); } else if (path_ordering1->ordtype == MERGE_ORDER && path_ordering2->ordtype == SORTOP_ORDER) { - return (path_ordering2->ord.sortop && - (path_ordering1->ord.merge->left_operator == path_ordering2->ord.sortop[0])); + if (!path_ordering2->ord.sortop) + { + *more_sort = 1; + return true; + } + return path_ordering1->ord.merge->left_operator == path_ordering2->ord.sortop[0]; } else { - return (path_ordering1->ord.sortop && - (path_ordering1->ord.sortop[0] == path_ordering2->ord.merge->left_operator)); + if (!path_ordering1->ord.sortop) + { + *more_sort = 2; + return true; + } + return path_ordering1->ord.sortop[0] == path_ordering2->ord.merge->left_operator; } } @@ -105,13 +127,27 @@ equal_merge_ordering(MergeOrder *merge_ordering1, * Returns true iff the sort operators are in the same order. */ static bool -equal_sortops_order(Oid *ordering1, Oid *ordering2) +equal_sortops_order(Oid *ordering1, Oid *ordering2, int *more_sort) { int i = 0; - if (ordering1 == NULL || ordering2 == NULL) - return ordering1 == ordering2; + *more_sort = 0; + + if (ordering1 == ordering2) + return true; + if (!ordering2) + { + *more_sort = 1; + return true; + } + + if (!ordering1) + { + *more_sort = 2; + return true; + } + while (ordering1[i] != 0 && ordering2[i] != 0) { if (ordering1[i] != ordering2[i]) @@ -119,5 +155,17 @@ equal_sortops_order(Oid *ordering1, Oid *ordering2) i++; } + if (ordering1[i] != 0 && ordering2[i] == 0) + { + *more_sort = 1; + return true; + } + + if (ordering1[i] == 0 && ordering2[i] != 0) + { + *more_sort = 2; + return true; + } + return ordering1[i] == 0 && ordering2[i] == 0; } diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index a33107cfbc..8070db812d 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -158,7 +158,8 @@ better_path(Path *new_path, List *unique_paths, bool *is_new) Path *path = (Path *) NULL; List *temp = NIL; int longer_key; - + int more_sort; + foreach(temp, unique_paths) { path = (Path *) lfirst(temp); @@ -176,18 +177,18 @@ better_path(Path *new_path, List *unique_paths, bool *is_new) length(lfirst(path->pathkeys)) < length(lfirst(new_path->pathkeys))) sleep(0); /* set breakpoint here */ } - if (!equal_path_ordering(new_path->path_order, path->path_order)) + if (!pathorder_match(new_path->pathorder, path->pathorder, &more_sort)) { printf("oldord\n"); - pprint(path->path_order); + pprint(path->pathorder); printf("neword\n"); - pprint(new_path->path_order); + pprint(new_path->pathorder); } #endif if (pathkeys_match(new_path->pathkeys, path->pathkeys, &longer_key)) { - if (equal_path_ordering(new_path->path_order, path->path_order)) + if (pathorder_match(new_path->pathorder, path->pathorder, &more_sort)) { /* * Replace pathkeys that match exactly, (1,2), (1,2). @@ -196,18 +197,28 @@ better_path(Path *new_path, List *unique_paths, bool *is_new) * path if it is not more expensive. */ - /* same keys, and new is cheaper, use it */ - if ((longer_key == 0 && new_path->path_cost < path->path_cost) || - /* new is longer, and cheaper, use it */ - (longer_key == 1 && new_path->path_cost <= path->path_cost)) + /* same keys, and new is cheaper, use it */ + if ((longer_key == 0 && more_sort == 0 && + new_path->path_cost < path->path_cost) || + + /* new is better, and cheaper, use it */ + ((longer_key == 1 && more_sort != 2) || + (longer_key != 2 && more_sort == 1)) && + new_path->path_cost <= path->path_cost) { *is_new = false; return new_path; } - /* same keys, new is more expensive, stop */ - else if ((longer_key == 0 && new_path->path_cost >= path->path_cost) || - /* old is longer, and less expensive, stop */ - (longer_key == 2 && new_path->path_cost >= path->path_cost)) + + /* same keys, new is more expensive, stop */ + else if + ((longer_key == 0 && more_sort == 0 && + new_path->path_cost >= path->path_cost) || + + /* old is better, and less expensive, stop */ + ((longer_key == 2 && more_sort != 1) || + (longer_key != 1 && more_sort == 2)) && + new_path->path_cost >= path->path_cost) { *is_new = false; return NULL; @@ -242,9 +253,9 @@ create_seqscan_path(RelOptInfo *rel) pathnode->pathtype = T_SeqScan; pathnode->parent = rel; pathnode->path_cost = 0.0; - pathnode->path_order = makeNode(PathOrder); - pathnode->path_order->ordtype = SORTOP_ORDER; - pathnode->path_order->ord.sortop = NULL; + pathnode->pathorder = makeNode(PathOrder); + pathnode->pathorder->ordtype = SORTOP_ORDER; + pathnode->pathorder->ord.sortop = NULL; pathnode->pathkeys = NIL; /* @@ -292,9 +303,9 @@ create_index_path(Query *root, pathnode->path.pathtype = T_IndexScan; pathnode->path.parent = rel; - pathnode->path.path_order = makeNode(PathOrder); - pathnode->path.path_order->ordtype = SORTOP_ORDER; - pathnode->path.path_order->ord.sortop = index->ordering; + pathnode->path.pathorder = makeNode(PathOrder); + pathnode->path.pathorder->ordtype = SORTOP_ORDER; + pathnode->path.pathorder->ord.sortop = index->ordering; pathnode->indexid = index->relids; pathnode->indexkeys = index->indexkeys; @@ -311,7 +322,7 @@ create_index_path(Query *root, * The index must have an ordering for the path to have (ordering) * keys, and vice versa. */ - if (pathnode->path.path_order->ord.sortop) + if (pathnode->path.pathorder->ord.sortop) { pathnode->path.pathkeys = collect_index_pathkeys(index->indexkeys, rel->targetlist); @@ -323,7 +334,7 @@ create_index_path(Query *root, * if no index keys were found, we can't order the path). */ if (pathnode->path.pathkeys == NULL) - pathnode->path.path_order->ord.sortop = NULL; + pathnode->path.pathorder->ord.sortop = NULL; } else pathnode->path.pathkeys = NULL; @@ -449,20 +460,20 @@ create_nestloop_path(RelOptInfo *joinrel, pathnode->path.joinid = NIL; pathnode->path.outerjoincost = (Cost) 0.0; pathnode->path.loc_restrictinfo = NIL; - pathnode->path.path_order = makeNode(PathOrder); + pathnode->path.pathorder = makeNode(PathOrder); if (pathkeys) { - pathnode->path.path_order->ordtype = outer_path->path_order->ordtype; - if (outer_path->path_order->ordtype == SORTOP_ORDER) - pathnode->path.path_order->ord.sortop = outer_path->path_order->ord.sortop; + pathnode->path.pathorder->ordtype = outer_path->pathorder->ordtype; + if (outer_path->pathorder->ordtype == SORTOP_ORDER) + pathnode->path.pathorder->ord.sortop = outer_path->pathorder->ord.sortop; else - pathnode->path.path_order->ord.merge = outer_path->path_order->ord.merge; + pathnode->path.pathorder->ord.merge = outer_path->pathorder->ord.merge; } else { - pathnode->path.path_order->ordtype = SORTOP_ORDER; - pathnode->path.path_order->ord.sortop = NULL; + pathnode->path.pathorder->ordtype = SORTOP_ORDER; + pathnode->path.pathorder->ord.sortop = NULL; } pathnode->path.path_cost = cost_nestloop(outer_path->path_cost, @@ -521,9 +532,9 @@ create_mergejoin_path(RelOptInfo *joinrel, pathnode->jpath.innerjoinpath = inner_path; pathnode->jpath.pathinfo = joinrel->restrictinfo; pathnode->jpath.path.pathkeys = pathkeys; - pathnode->jpath.path.path_order = makeNode(PathOrder); - pathnode->jpath.path.path_order->ordtype = MERGE_ORDER; - pathnode->jpath.path.path_order->ord.merge = order; + pathnode->jpath.path.pathorder = makeNode(PathOrder); + pathnode->jpath.path.pathorder->ordtype = MERGE_ORDER; + pathnode->jpath.path.pathorder->ord.merge = order; pathnode->path_mergeclauses = mergeclauses; pathnode->jpath.path.loc_restrictinfo = NIL; pathnode->outersortkeys = outersortkeys; @@ -587,9 +598,9 @@ create_hashjoin_path(RelOptInfo *joinrel, pathnode->jpath.pathinfo = joinrel->restrictinfo; pathnode->jpath.path.loc_restrictinfo = NIL; pathnode->jpath.path.pathkeys = pathkeys; - pathnode->jpath.path.path_order = makeNode(PathOrder); - pathnode->jpath.path.path_order->ordtype = SORTOP_ORDER; - pathnode->jpath.path.path_order->ord.sortop = NULL; + pathnode->jpath.path.pathorder = makeNode(PathOrder); + pathnode->jpath.path.pathorder->ordtype = SORTOP_ORDER; + pathnode->jpath.path.pathorder->ord.sortop = NULL; pathnode->jpath.path.outerjoincost = (Cost) 0.0; pathnode->jpath.path.joinid = (Relid) NULL; /* pathnode->hashjoinoperator = operator; */ diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h index 32b014c240..56c283d3aa 100644 --- a/src/include/nodes/relation.h +++ b/src/include/nodes/relation.h @@ -146,7 +146,7 @@ typedef struct Path NodeTag pathtype; - PathOrder *path_order; + PathOrder *pathorder; List *pathkeys; /* This is a List of List of Var nodes. * It is a List of Lists because of multi-key diff --git a/src/include/optimizer/ordering.h b/src/include/optimizer/ordering.h index 393432b994..1f91cb0105 100644 --- a/src/include/optimizer/ordering.h +++ b/src/include/optimizer/ordering.h @@ -15,8 +15,8 @@ #include -extern bool equal_path_ordering(PathOrder *path_ordering1, - PathOrder *path_ordering2); +extern bool pathorder_match(PathOrder *path_ordering1, + PathOrder *path_ordering2, int *more_sort); extern bool equal_path_merge_ordering(Oid *path_ordering, MergeOrder *merge_ordering); extern bool equal_merge_ordering(MergeOrder *merge_ordering1, -- 2.39.5