*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.66 1999/02/10 03:52:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.67 1999/02/11 14:58:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.29 1999/02/10 21:02:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.30 1999/02/11 14:58:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* 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))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.6 1999/02/10 21:02:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.7 1999/02/11 14:58:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.68 1999/02/10 03:52:35 momjian Exp $
+ * $Id: outfuncs.c,v 1.69 1999/02/11 14:58:49 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
node->path_cost);
_outNode(str, node->pathkeys);
- appendStringInfo(str, " :path_order ");
- _outNode(str, node->path_order);
+ appendStringInfo(str, " :pathorder ");
+ _outNode(str, node->pathorder);
}
/*
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);
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);
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);
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);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.53 1999/02/10 03:52:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.54 1999/02/11 14:58:49 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
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 */
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 */
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 */
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 */
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 */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_paths.c,v 1.15 1999/02/10 21:02:35 momjian Exp $
+ * $Id: geqo_paths.c,v 1.16 1999/02/11 14:58:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
path = (Path *) lfirst(y);
- if (!path->path_order->ord.sortop)
+ if (!path->pathorder->ord.sortop)
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.42 1999/02/10 21:02:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.43 1999/02/11 14:58:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.19 1999/02/10 21:02:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.20 1999/02/11 14:58:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
outerpath = (Path *) lfirst(i);
- outerpath_ordering = outerpath->path_order;
+ outerpath_ordering = outerpath->pathorder;
if (outerpath_ordering)
{
innerpath = (Path *) lfirst(i);
- innerpath_ordering = innerpath->path_order;
+ innerpath_ordering = innerpath->pathorder;
if (innerpath_ordering)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.17 1999/02/11 05:29:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.18 1999/02/11 14:58:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.16 1999/02/10 03:52:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.17 1999/02/11 14:58:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* 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);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.18 1999/02/10 21:02:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.19 1999/02/11 14:58:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.26 1999/02/10 21:02:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.27 1999/02/11 14:58:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
path = (Path *) lfirst(y);
- if (!path->path_order->ord.sortop)
+ if (!path->pathorder->ord.sortop)
break;
}
cheapest = (JoinPath *) prune_rel_path(rel, path);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.42 1999/02/10 17:14:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.43 1999/02/11 14:58:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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;
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.11 1999/02/06 17:29:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.12 1999/02/11 14:58:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#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--
*
*/
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)
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;
}
}
* 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])
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;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.25 1999/02/11 05:29:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.26 1999/02/11 14:59:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Path *path = (Path *) NULL;
List *temp = NIL;
int longer_key;
-
+ int more_sort;
+
foreach(temp, unique_paths)
{
path = (Path *) lfirst(temp);
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).
* 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;
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;
/*
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;
* 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);
* 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;
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,
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;
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; */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.18 1999/02/10 03:52:50 momjian Exp $
+ * $Id: relation.h,v 1.19 1999/02/11 14:59:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ordering.h,v 1.10 1999/02/06 17:29:30 momjian Exp $
+ * $Id: ordering.h,v 1.11 1999/02/11 14:59:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include <nodes/relation.h>
-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,