*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.68 1999/02/12 05:56:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.69 1999/02/12 06:43:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* ----------------
- * CopyJoinPathFields
+ * CopyNestPathFields
*
- * This function copies the fields of the JoinPath node. It is used by
- * all the copy functions for classes which inherit from JoinPath.
+ * This function copies the fields of the NestPath node. It is used by
+ * all the copy functions for classes which inherit from NestPath.
* ----------------
*/
static void
-CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
+CopyNestPathFields(NestPath *from, NestPath *newnode)
{
Node_Copy(from, newnode, pathinfo);
Node_Copy(from, newnode, outerjoinpath);
}
/* ----------------
- * _copyJoinPath
+ * _copyNestPath
* ----------------
*/
-static JoinPath *
-_copyJoinPath(JoinPath *from)
+static NestPath *
+_copyNestPath(NestPath *from)
{
- JoinPath *newnode = makeNode(JoinPath);
+ NestPath *newnode = makeNode(NestPath);
/* ----------------
* copy the node superclass fields
* ----------------
*/
CopyPathFields((Path *) from, (Path *) newnode);
- CopyJoinPathFields(from, newnode);
+ CopyNestPathFields(from, newnode);
return newnode;
}
* ----------------
*/
CopyPathFields((Path *) from, (Path *) newnode);
- CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
+ CopyNestPathFields((NestPath *) from, (NestPath *) newnode);
/* ----------------
* copy the remainder of the node
* ----------------
*/
CopyPathFields((Path *) from, (Path *) newnode);
- CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
+ CopyNestPathFields((NestPath *) from, (NestPath *) newnode);
/* ----------------
* copy remainder of node
case T_IndexPath:
retval = _copyIndexPath(from);
break;
- case T_JoinPath:
- retval = _copyJoinPath(from);
+ case T_NestPath:
+ retval = _copyNestPath(from);
break;
case T_MergePath:
retval = _copyMergePath(from);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.30 1999/02/11 14:58:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.31 1999/02/12 06:43:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
static bool
-_equalJoinPath(JoinPath *a, JoinPath *b)
+_equalNestPath(NestPath *a, NestPath *b)
{
Assert(IsA_JoinPath(a));
Assert(IsA_JoinPath(b));
Assert(IsA(a, MergePath));
Assert(IsA(b, MergePath));
- if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b))
+ if (!_equalNestPath((NestPath *) a, (NestPath *) b))
return false;
if (!equal(a->path_mergeclauses, b->path_mergeclauses))
return false;
Assert(IsA(a, HashPath));
Assert(IsA(b, HashPath));
- if (!_equalJoinPath((JoinPath *) a, (JoinPath *) b))
+ if (!_equalNestPath((NestPath *) a, (NestPath *) b))
return false;
if (!equal((a->path_hashclauses), (b->path_hashclauses)))
return false;
case T_IndexPath:
retval = _equalIndexPath(a, b);
break;
- case T_JoinPath:
- retval = _equalJoinPath(a, b);
+ case T_NestPath:
+ retval = _equalNestPath(a, b);
break;
case T_MergePath:
retval = _equalMergePath(a, b);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.8 1999/02/12 05:56:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.9 1999/02/12 06:43:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* ----------------
- * FreeJoinPathFields
+ * FreeNestPathFields
*
- * This function frees the fields of the JoinPath node. It is used by
- * all the free functions for classes which inherit node JoinPath.
+ * This function frees the fields of the NestPath node. It is used by
+ * all the free functions for classes which inherit node NestPath.
* ----------------
*/
static void
-FreeJoinPathFields(JoinPath *node)
+FreeNestPathFields(NestPath *node)
{
freeObject(node->pathinfo);
freeObject(node->outerjoinpath);
}
/* ----------------
- * _freeJoinPath
+ * _freeNestPath
* ----------------
*/
static void
-_freeJoinPath(JoinPath *node)
+_freeNestPath(NestPath *node)
{
/* ----------------
* free the node superclass fields
* ----------------
*/
FreePathFields((Path *) node);
- FreeJoinPathFields(node);
+ FreeNestPathFields(node);
pfree(node);
}
* ----------------
*/
FreePathFields((Path *) node);
- FreeJoinPathFields((JoinPath *) node);
+ FreeNestPathFields((NestPath *) node);
/* ----------------
* free the remainder of the node
* ----------------
*/
FreePathFields((Path *) node);
- FreeJoinPathFields((JoinPath *) node);
+ FreeNestPathFields((NestPath *) node);
/* ----------------
* free remainder of node
case T_IndexPath:
_freeIndexPath(node);
break;
- case T_JoinPath:
- _freeJoinPath(node);
+ case T_NestPath:
+ _freeNestPath(node);
break;
case T_MergePath:
_freeMergePath(node);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.70 1999/02/12 05:56:46 momjian Exp $
+ * $Id: outfuncs.c,v 1.71 1999/02/12 06:43:24 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
}
/*
- * JoinPath is a subclass of Path
+ * NestPath is a subclass of Path
*/
static void
-_outJoinPath(StringInfo str, JoinPath *node)
+_outNestPath(StringInfo str, NestPath *node)
{
appendStringInfo(str,
- " JOINPATH :pathtype %d :cost %f :pathkeys ",
+ " NESTPATH :pathtype %d :cost %f :pathkeys ",
node->path.pathtype,
node->path.path_cost);
_outNode(str, node->path.pathkeys);
}
/*
- * MergePath is a subclass of JoinPath.
+ * MergePath is a subclass of NestPath.
*/
static void
_outMergePath(StringInfo str, MergePath *node)
}
/*
- * HashPath is a subclass of JoinPath.
+ * HashPath is a subclass of NestPath.
*/
static void
_outHashPath(StringInfo str, HashPath *node)
case T_IndexPath:
_outIndexPath(str, obj);
break;
- case T_JoinPath:
- _outJoinPath(str, obj);
+ case T_NestPath:
+ _outNestPath(str, obj);
break;
case T_MergePath:
_outMergePath(str, obj);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.55 1999/02/12 05:56:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.56 1999/02/12 06:43:24 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
}
/* ----------------
- * _readJoinPath
+ * _readNestPath
*
- * JoinPath is a subclass of Path
+ * NestPath is a subclass of Path
* ----------------
*/
-static JoinPath *
-_readJoinPath()
+static NestPath *
+_readNestPath()
{
- JoinPath *local_node;
+ NestPath *local_node;
char *token;
int length;
- local_node = makeNode(JoinPath);
+ local_node = makeNode(NestPath);
token = lsptok(NULL, &length); /* get :pathtype */
token = lsptok(NULL, &length); /* now read it */
/* ----------------
* _readMergePath
*
- * MergePath is a subclass of JoinPath.
+ * MergePath is a subclass of NestPath.
* ----------------
*/
static MergePath *
/* ----------------
* _readHashPath
*
- * HashPath is a subclass of JoinPath.
+ * HashPath is a subclass of NestPath.
* ----------------
*/
static HashPath *
return_value = _readPath();
else if (!strncmp(token, "INDEXPATH", length))
return_value = _readIndexPath();
- else if (!strncmp(token, "JOINPATH", length))
- return_value = _readJoinPath();
+ else if (!strncmp(token, "NESTPATH", length))
+ return_value = _readNestPath();
else if (!strncmp(token, "MERGEPATH", length))
return_value = _readMergePath();
else if (!strncmp(token, "HASHPATH", length))
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_misc.c,v 1.14 1999/02/10 21:02:34 momjian Exp $
+ * $Id: geqo_misc.c,v 1.15 1999/02/12 06:43:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
geqo_print_path(Query *root, Path *path, int indent)
{
char *ptype = NULL;
- JoinPath *jp;
+ NestPath *jp;
bool join = false;
int i;
ptype = "IdxScan";
join = false;
break;
- case T_JoinPath:
+ case T_NestPath:
ptype = "Nestloop";
join = true;
break;
{
int size = path->parent->size;
- jp = (JoinPath *) path;
+ jp = (NestPath *) path;
printf("%s size=%d cost=%f\n", ptype, size, path->path_cost);
switch (nodeTag(path))
{
for (i = 0; i < indent + 1; i++)
printf("\t");
printf(" clauses=(");
- geqo_print_joinclauses(root,
- ((JoinPath *) path)->pathinfo);
+ geqo_print_joinclauses(root, ((NestPath *) path)->pathinfo);
printf(")\n");
if (nodeTag(path) == T_MergePath)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_paths.c,v 1.17 1999/02/12 05:56:48 momjian Exp $
+ * $Id: geqo_paths.c,v 1.18 1999/02/12 06:43:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
void
geqo_set_cheapest(RelOptInfo *rel)
{
- JoinPath *cheapest = (JoinPath *)set_cheapest(rel, rel->pathlist);
+ NestPath *cheapest = (NestPath *)set_cheapest(rel, rel->pathlist);
if (IsA_JoinPath(cheapest))
rel->size = compute_joinrel_size(cheapest);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.28 1999/02/12 05:56:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.29 1999/02/12 06:43:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
print_path(Query *root, Path *path, int indent)
{
char *ptype = NULL;
- JoinPath *jp;
+ NestPath *jp;
bool join = false;
int i;
ptype = "IdxScan";
join = false;
break;
- case T_JoinPath:
+ case T_NestPath:
ptype = "Nestloop";
join = true;
break;
{
int size = path->parent->size;
- jp = (JoinPath *) path;
+ jp = (NestPath *) path;
printf("%s size=%d cost=%f\n", ptype, size, path->path_cost);
switch (nodeTag(path))
{
for (i = 0; i < indent + 1; i++)
printf("\t");
printf(" clauses=(");
- print_joinclauses(root, ((JoinPath *) path)->pathinfo);
+ print_joinclauses(root, ((NestPath *) path)->pathinfo);
printf(")\n");
if (nodeTag(path) == T_MergePath)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.29 1999/02/10 21:02:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.30 1999/02/12 06:43:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Returns a fixnum.
*/
int
-compute_joinrel_size(JoinPath *joinpath)
+compute_joinrel_size(NestPath *joinpath)
{
Cost temp = 1.0;
int temp1 = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.20 1999/02/11 14:58:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.21 1999/02/12 06:43:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* list of integers.
*/
innerrel = (length(innerrelids) == 1) ?
- get_base_rel(root, lfirsti(innerrelids)) : get_join_rel(root, innerrelids);
+ get_base_rel(root, lfirsti(innerrelids)) :
+ get_join_rel(root, innerrelids);
outerrel = (length(outerrelids) == 1) ?
- get_base_rel(root, lfirsti(outerrelids)) : get_join_rel(root, outerrelids);
+ get_base_rel(root, lfirsti(outerrelids)) :
+ get_join_rel(root, outerrelids);
+
+ bestinnerjoin = best_innerjoin(innerrel->innerjoin, outerrel->relids);
- bestinnerjoin = best_innerjoin(innerrel->innerjoin,
- outerrel->relids);
if (_enable_mergejoin_)
- {
mergeinfo_list = group_clauses_by_order(joinrel->restrictinfo,
lfirsti(innerrel->relids));
- }
if (_enable_hashjoin_)
- {
hashinfo_list = group_clauses_by_hashop(joinrel->restrictinfo,
lfirsti(innerrel->relids));
- }
/* need to flatten the relids list */
joinrel->relids = intAppend(outerrelids, innerrelids);
outerpath_ordering = outerpath->pathorder;
if (outerpath_ordering)
- {
xmergeinfo = match_order_mergeinfo(outerpath_ordering,
- mergeinfo_list);
- }
+ mergeinfo_list);
if (xmergeinfo)
clauses = xmergeinfo->jmethod.clauses;
List *clauses = xmergeinfo->jmethod.clauses;
matchedJoinKeys = match_pathkeys_joinkeys(outerpath->pathkeys,
- jmkeys,
- clauses,
- OUTER,
- &matchedJoinClauses);
- merge_pathkeys = new_join_pathkeys(outerpath->pathkeys,
- joinrel->targetlist, clauses);
+ jmkeys,
+ clauses,
+ OUTER,
+ &matchedJoinClauses);
+ merge_pathkeys = new_join_pathkeys(outerpath->pathkeys,
+ joinrel->targetlist, clauses);
}
else
merge_pathkeys = outerpath->pathkeys;
* found, and
* 2. sorting the cheapest outer path is cheaper than using an ordered
* but unsorted outer path(as was considered in
- * (match-unsorted-outer)),
- * then this merge path is considered.
+ * (match-unsorted-outer)), then this merge path is considered.
*
* 'joinrel' is the join result relation
* 'outerrel' is the outer join relation
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.15 1999/02/03 21:16:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.16 1999/02/12 06:43:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* (not a join) iff it has
* a non-NULL cinfo field */
-static void xfunc_predmig(JoinPath pathnode, Stream streamroot,
+static void xfunc_predmig(NestPath pathnode, Stream streamroot,
Stream laststream, bool *progressp);
static bool xfunc_series_llel(Stream stream);
static bool xfunc_llel_chains(Stream root, Stream bottom);
static Stream xfunc_complete_stream(Stream stream);
static bool xfunc_prdmig_pullup(Stream origstream, Stream pullme,
- JoinPath joinpath);
+ NestPath joinpath);
static void xfunc_form_groups(Stream root, Stream bottom);
static void xfunc_free_stream(Stream root);
static Stream xfunc_add_clauses(Stream current);
do
{
progress = false;
- Assert(IsA(root, JoinPath));
- xfunc_predmig((JoinPath) root, (Stream) NULL, (Stream) NULL,
+ Assert(IsA(root, NestPath));
+ xfunc_predmig((NestPath) root, (Stream) NULL, (Stream) NULL,
&progress);
if (changed && progress)
elog(DEBUG, "Needed to do a second round of predmig!\n");
** Destructively modifies the join tree (via predicate pullup).
*/
static void
-xfunc_predmig(JoinPath pathnode,/* root of the join tree */
+xfunc_predmig(NestPath pathnode,/* root of the join tree */
Stream streamroot,
Stream laststream,/* for recursive calls -- these are the
* root of the stream under construction,
else
{
/* visit left child */
- xfunc_predmig((JoinPath) get_outerjoinpath(pathnode),
+ xfunc_predmig((NestPath) get_outerjoinpath(pathnode),
streamroot, newstream, progressp);
/* visit right child */
- xfunc_predmig((JoinPath) get_innerjoinpath(pathnode),
+ xfunc_predmig((NestPath) get_innerjoinpath(pathnode),
streamroot, newstream, progressp);
}
*/
Assert(xfunc_num_relids(pathstream) > xfunc_num_relids(tmpstream));
progress = xfunc_prdmig_pullup(origstream, tmpstream,
- (JoinPath) get_pathptr(pathstream));
+ (NestPath) get_pathptr(pathstream));
}
if (get_downstream(tmpstream))
pathstream = (Stream) xfunc_get_downjoin((Stream) get_downstream(tmpstream));
/*
** xfunc_prdmig_pullup
- ** pullup a clause in a path above joinpath. Since the JoinPath tree
+ ** pullup a clause in a path above joinpath. Since the NestPath tree
** doesn't have upward pointers, it's difficult to deal with. Thus we
** require the original stream, which maintains pointers to all the path
** nodes. We use the original stream to find out what joins are
** above the clause.
*/
static bool
-xfunc_prdmig_pullup(Stream origstream, Stream pullme, JoinPath joinpath)
+xfunc_prdmig_pullup(Stream origstream, Stream pullme, NestPath joinpath)
{
RestrictInfo restrictinfo = get_cinfo(pullme);
bool progress = false;
/* pull up this node as far as it should go */
for (upjoin = (Stream) xfunc_get_upjoin(orignode);
upjoin != (Stream) NULL
- && (JoinPath) get_pathptr((Stream) xfunc_get_downjoin(upjoin))
+ && (NestPath) get_pathptr((Stream) xfunc_get_downjoin(upjoin))
!= joinpath;
upjoin = (Stream) xfunc_get_upjoin(upjoin))
{
#endif
/* move clause up in path */
if (get_pathptr((Stream) get_downstream(upjoin))
- == (pathPtr) get_outerjoinpath((JoinPath) get_pathptr(upjoin)))
+ == (pathPtr) get_outerjoinpath((NestPath) get_pathptr(upjoin)))
whichchild = OUTER;
else
whichchild = INNER;
restrictinfo = xfunc_pullup((Path) get_pathptr((Stream) get_downstream(upjoin)),
- (JoinPath) get_pathptr(upjoin),
+ (NestPath) get_pathptr(upjoin),
restrictinfo,
whichchild,
get_clausetype(orignode));
temp = (Stream) get_downstream(temp))
set_pathptr
(temp, (pathPtr)
- get_outerjoinpath((JoinPath) get_pathptr(upjoin)));
+ get_outerjoinpath((NestPath) get_pathptr(upjoin)));
set_pathptr
(temp,
- (pathPtr) get_outerjoinpath((JoinPath) get_pathptr(upjoin)));
+ (pathPtr) get_outerjoinpath((NestPath) get_pathptr(upjoin)));
}
else
{
temp = (Stream) get_downstream(temp))
set_pathptr
(temp, (pathPtr)
- get_innerjoinpath((JoinPath) get_pathptr(upjoin)));
+ get_innerjoinpath((NestPath) get_pathptr(upjoin)));
set_pathptr
(temp, (pathPtr)
- get_innerjoinpath((JoinPath) get_pathptr(upjoin)));
+ get_innerjoinpath((NestPath) get_pathptr(upjoin)));
}
progress = true;
}
if (!is_clause(temp))
{
if (get_pathptr((Stream) get_downstream(temp))
- == (pathPtr) get_outerjoinpath((JoinPath) get_pathptr(temp)))
+ == (pathPtr) get_outerjoinpath((NestPath) get_pathptr(temp)))
whichchild = OUTER;
else
whichchild = INNER;
set_groupcost(temp,
- xfunc_join_expense((JoinPath) get_pathptr(temp),
+ xfunc_join_expense((NestPath) get_pathptr(temp),
whichchild));
- if (primjoin = xfunc_primary_join((JoinPath) get_pathptr(temp)))
+ if (primjoin = xfunc_primary_join((NestPath) get_pathptr(temp)))
{
set_groupsel(temp,
compute_clause_selec(queryInfo,
}
/* and add in the join clauses */
- if (IsA(get_pathptr(current), JoinPath))
+ if (IsA(get_pathptr(current), NestPath))
{
- primjoin = xfunc_primary_join((JoinPath) get_pathptr(current));
- foreach(temp, get_pathrestrictinfo((JoinPath) get_pathptr(current)))
+ primjoin = xfunc_primary_join((NestPath) get_pathptr(current));
+ foreach(temp, get_pathrestrictinfo((NestPath) get_pathptr(current)))
{
if (!equal(get_clause((RestrictInfo) lfirst(temp)), primjoin))
topnode = xfunc_streaminsert((RestrictInfo) lfirst(temp), topnode,
static int
xfunc_num_relids(Stream node)
{
- if (!node || !IsA(get_pathptr(node), JoinPath))
+ if (!node || !IsA(get_pathptr(node), NestPath))
return 0;
else
return (length
- (get_relids(get_parent((JoinPath) get_pathptr(node)))));
+ (get_relids(get_parent((NestPath) get_pathptr(node)))));
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.28 1999/02/12 05:56:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.29 1999/02/12 06:43:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
List *x = NIL;
RelOptInfo *rel = (RelOptInfo *) NULL;
- JoinPath *cheapest;
+ NestPath *cheapest;
foreach(x, rel_list)
{
rel = (RelOptInfo *) lfirst(x);
- cheapest = (JoinPath *) set_cheapest(rel, rel->pathlist);
+ cheapest = (NestPath *) set_cheapest(rel, rel->pathlist);
if (IsA_JoinPath(cheapest))
rel->size = compute_joinrel_size(cheapest);
else
- elog(ERROR, "non JoinPath called");
+ elog(ERROR, "non NestPath called");
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.25 1999/02/10 21:02:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.26 1999/02/12 06:43:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
LispValue y; /* list ptr */
RestrictInfo maxcinfo; /* The RestrictInfo to pull up, as
* calculated by xfunc_shouldpull() */
- JoinPath curpath; /* current path in list */
+ NestPath curpath; /* current path in list */
int progress; /* has progress been made this time
* through? */
int clausetype;
progress = false; /* no progress yet in this iteration */
foreach(y, get_pathlist(rel))
{
- curpath = (JoinPath) lfirst(y);
+ curpath = (NestPath) lfirst(y);
/*
* * for each operand, attempt to pullup predicates until
int
xfunc_shouldpull(Query *queryInfo,
Path childpath,
- JoinPath parentpath,
+ NestPath parentpath,
int whichchild,
RestrictInfo * maxcinfopt) /* Out: pointer to clause
* to pullup */
* see if any join clause has even higher rank than the highest *
* local predicate
*/
- if (is_join(childpath) && xfunc_num_join_clauses((JoinPath) childpath) > 1)
- for (tmplist = get_pathrestrictinfo((JoinPath) childpath);
+ if (is_join(childpath) && xfunc_num_join_clauses((NestPath) childpath) > 1)
+ for (tmplist = get_pathrestrictinfo((NestPath) childpath);
tmplist != LispNil;
tmplist = lnext(tmplist))
{
|| (joincost == 0 && joinselec < 1)
|| (!is_join(childpath)
&& (whichchild == INNER)
- && IsA(parentpath, JoinPath)
+ && IsA(parentpath, NestPath)
&&!IsA(parentpath, HashPath)
&&!IsA(parentpath, MergePath)))))
{
RestrictInfo
xfunc_pullup(Query *queryInfo,
Path childpath,
- JoinPath parentpath,
+ NestPath parentpath,
RestrictInfo cinfo, /* clause to pull up */
int whichchild, /* whether child is INNER or OUTER of join */
int clausetype) /* whether clause to pull is join or local */
else
{
set_pathrestrictinfo
- ((JoinPath) newkid,
+ ((NestPath) newkid,
xfunc_LispRemove((LispValue) cinfo,
- (List) get_pathrestrictinfo((JoinPath) newkid)));
+ (List) get_pathrestrictinfo((NestPath) newkid)));
}
/*
** Find global expense of a join clause
*/
Cost
-xfunc_join_expense(Query *queryInfo, JoinPath path, int whichchild)
+xfunc_join_expense(Query *queryInfo, NestPath path, int whichchild)
{
LispValue primjoinclause = xfunc_primary_join(path);
** min rank pathclause
*/
LispValue
-xfunc_primary_join(JoinPath pathnode)
+xfunc_primary_join(NestPath pathnode)
{
LispValue joinclauselist = get_pathrestrictinfo(pathnode);
RestrictInfo mincinfo;
* * Now add in any node-specific expensive function costs. * Again,
* we must ensure that the clauses are sorted by rank.
*/
- if (IsA(pathnode, JoinPath))
+ if (IsA(pathnode, NestPath))
{
if (XfuncMode != XFUNC_OFF)
- set_pathrestrictinfo((JoinPath) pathnode, lisp_qsort
- (get_pathrestrictinfo((JoinPath) pathnode),
+ set_pathrestrictinfo((NestPath) pathnode, lisp_qsort
+ (get_pathrestrictinfo((NestPath) pathnode),
xfunc_cinfo_compare));
- for (tmplist = get_pathrestrictinfo((JoinPath) pathnode), selec = 1.0;
+ for (tmplist = get_pathrestrictinfo((NestPath) pathnode), selec = 1.0;
tmplist != LispNil;
tmplist = lnext(tmplist))
{
** Recalculate the cost of a path node. This includes the basic cost of the
** node, as well as the cost of its expensive functions.
** We need to do this to the parent after pulling a clause from a child into a
- ** parent. Thus we should only be calling this function on JoinPaths.
+ ** parent. Thus we should only be calling this function on NestPaths.
*/
Cost
-xfunc_total_path_cost(JoinPath pathnode)
+xfunc_total_path_cost(NestPath pathnode)
{
Cost cost = xfunc_get_path_cost((Path) pathnode);
- Assert(IsA(pathnode, JoinPath));
+ Assert(IsA(pathnode, NestPath));
if (IsA(pathnode, MergePath))
{
MergePath mrgnode = (MergePath) pathnode;
*/
Cost
-xfunc_expense_per_tuple(JoinPath joinnode, int whichchild)
+xfunc_expense_per_tuple(NestPath joinnode, int whichchild)
{
RelOptInfo outerrel = get_parent((Path) get_outerjoinpath(joinnode));
RelOptInfo innerrel = get_parent((Path) get_innerjoinpath(joinnode));
else
/* nestloop */
{
- Assert(IsA(joinnode, JoinPath));
+ Assert(IsA(joinnode, NestPath));
return _CPU_PAGE_WEIGHT_;
}
}
** Find the number of join clauses associated with this join path
*/
int
-xfunc_num_join_clauses(JoinPath path)
+xfunc_num_join_clauses(NestPath path)
{
int num = length(get_pathrestrictinfo(path));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.43 1999/02/11 14:58:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.44 1999/02/12 06:43:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static List *switch_outer(List *clauses);
static Scan *create_scan_node(Path *best_path, List *tlist);
-static Join *create_join_node(JoinPath *best_path, List *tlist);
+static Join *create_join_node(NestPath *best_path, List *tlist);
static SeqScan *create_seqscan_node(Path *best_path, List *tlist,
List *scan_clauses);
static IndexScan *create_indexscan_node(IndexPath *best_path, List *tlist,
List *scan_clauses);
-static NestLoop *create_nestloop_node(JoinPath *best_path, List *tlist,
+static NestLoop *create_nestloop_node(NestPath *best_path, List *tlist,
List *clauses, Plan *outer_node, List *outer_tlist,
Plan *inner_node, List *inner_tlist);
static MergeJoin *create_mergejoin_node(MergePath *best_path, List *tlist,
case T_HashJoin:
case T_MergeJoin:
case T_NestLoop:
- plan_node = (Plan *) create_join_node((JoinPath *) best_path, tlist);
+ plan_node = (Plan *) create_join_node((NestPath *) best_path, tlist);
break;
default:
/* do nothing */
* Returns the join node.
*/
static Join *
-create_join_node(JoinPath *best_path, List *tlist)
+create_join_node(NestPath *best_path, List *tlist)
{
Plan *outer_node;
List *outer_tlist;
inner_tlist);
break;
case T_NestLoop:
- retval = (Join *) create_nestloop_node((JoinPath *) best_path,
+ retval = (Join *) create_nestloop_node((NestPath *) best_path,
tlist,
clauses,
outer_node,
*****************************************************************************/
static NestLoop *
-create_nestloop_node(JoinPath *best_path,
+create_nestloop_node(NestPath *best_path,
List *tlist,
List *clauses,
Plan *outer_node,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.33 1999/02/12 05:56:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.34 1999/02/12 06:43:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Returns the resulting path node.
*
*/
-JoinPath *
+NestPath *
create_nestloop_path(RelOptInfo *joinrel,
RelOptInfo *outer_rel,
Path *outer_path,
Path *inner_path,
List *pathkeys)
{
- JoinPath *pathnode = makeNode(JoinPath);
+ NestPath *pathnode = makeNode(NestPath);
pathnode->path.pathtype = T_NestLoop;
pathnode->path.parent = joinrel;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.41 1999/02/09 17:03:11 momjian Exp $
+ * $Id: nodes.h,v 1.42 1999/02/12 06:43:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
T_PathOrder,
T_Path,
T_IndexPath,
- T_JoinPath,
+ T_NestPath,
T_MergePath,
T_HashPath,
T_OrderKey,
* ----------------------------------------------------------------
*/
#define IsA_JoinPath(jp) \
- (nodeTag(jp)==T_JoinPath || nodeTag(jp)==T_MergePath || \
+ (nodeTag(jp)==T_NestPath || nodeTag(jp)==T_MergePath || \
nodeTag(jp)==T_HashPath)
#define IsA_Join(j) \
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.20 1999/02/12 05:57:01 momjian Exp $
+ * $Id: relation.h,v 1.21 1999/02/12 06:43:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int *indexkeys; /* to transform heap attnos into index ones */
} IndexPath;
-typedef struct JoinPath
+typedef struct NestPath
{
Path path;
List *pathinfo;
Path *outerjoinpath;
Path *innerjoinpath;
-} JoinPath;
+} NestPath;
typedef struct MergePath
{
- JoinPath jpath;
+ NestPath jpath;
List *path_mergeclauses;
List *outersortkeys;
List *innersortkeys;
typedef struct HashPath
{
- JoinPath jpath;
+ NestPath jpath;
List *path_hashclauses;
List *outerhashkeys;
List *innerhashkeys;
/*
** Stream:
** A stream represents a root-to-leaf path in a plan tree (i.e. a tree of
-** JoinPaths and Paths). The stream includes pointers to all Path nodes,
+** NestPaths and Paths). The stream includes pointers to all Path nodes,
** as well as to any clauses that reside above Path nodes. This structure
** is used to make Path nodes and clauses look similar, so that Predicate
** Migration can run.
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: cost.h,v 1.14 1999/02/10 21:02:43 momjian Exp $
+ * $Id: cost.h,v 1.15 1999/02/12 06:43:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int outerwidth, int innerwidth);
extern int compute_rel_size(RelOptInfo *rel);
extern int compute_rel_width(RelOptInfo *rel);
-extern int compute_joinrel_size(JoinPath *joinpath);
+extern int compute_joinrel_size(NestPath *joinpath);
extern int page_size(int tuples, int width);
/*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pathnode.h,v 1.12 1999/02/10 21:02:49 momjian Exp $
+ * $Id: pathnode.h,v 1.13 1999/02/12 06:43:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Path *create_seqscan_path(RelOptInfo *rel);
extern IndexPath *create_index_path(Query *root, RelOptInfo *rel, RelOptInfo *index,
List *restriction_clauses, bool is_join_scan);
-extern JoinPath *create_nestloop_path(RelOptInfo *joinrel, RelOptInfo *outer_rel,
+extern NestPath *create_nestloop_path(RelOptInfo *joinrel, RelOptInfo *outer_rel,
Path *outer_path, Path *inner_path, List *pathkeys);
extern MergePath *create_mergejoin_path(RelOptInfo *joinrel, int outersize,
int innersize, int outerwidth, int innerwidth, Path *outer_path,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xfunc.h,v 1.12 1999/02/10 21:02:50 momjian Exp $
+ * $Id: xfunc.h,v 1.13 1999/02/12 06:43:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* function prototypes from planner/path/xfunc.c */
extern void xfunc_trypullup(RelOptInfo *rel);
-extern int xfunc_shouldpull(Path *childpath, JoinPath *parentpath,
+extern int xfunc_shouldpull(Path *childpath, NestPath *parentpath,
int whichchild, RestrictInfo * maxcinfopt);
-extern RestrictInfo *xfunc_pullup(Path *childpath, JoinPath *parentpath, RestrictInfo * cinfo,
+extern RestrictInfo *xfunc_pullup(Path *childpath, NestPath *parentpath, RestrictInfo * cinfo,
int whichchild, int clausetype);
extern Cost xfunc_rank(Expr *clause);
extern Cost xfunc_expense(Query *queryInfo, Expr *clause);
-extern Cost xfunc_join_expense(JoinPath *path, int whichchild);
+extern Cost xfunc_join_expense(NestPath *path, int whichchild);
extern Cost xfunc_local_expense(Expr *clause);
extern Cost xfunc_func_expense(Expr *node, List *args);
extern int xfunc_width(Expr *clause);
/* extern int xfunc_card_unreferenced(Expr *clause, Relid referenced); */
extern int xfunc_card_product(Relid relids);
extern List *xfunc_find_references(List *clause);
-extern List *xfunc_primary_join(JoinPath *pathnode);
+extern List *xfunc_primary_join(NestPath *pathnode);
extern Cost xfunc_get_path_cost(Path *pathnode);
-extern Cost xfunc_total_path_cost(JoinPath *pathnode);
-extern Cost xfunc_expense_per_tuple(JoinPath *joinnode, int whichchild);
+extern Cost xfunc_total_path_cost(NestPath *pathnode);
+extern Cost xfunc_expense_per_tuple(NestPath *joinnode, int whichchild);
extern void xfunc_fixvars(Expr *clause, RelOptInfo *rel, int varno);
extern int xfunc_cinfo_compare(void *arg1, void *arg2);
extern int xfunc_clause_compare(void *arg1, void *arg2);
extern int xfunc_disjunct_compare(void *arg1, void *arg2);
extern int xfunc_func_width(RegProcedure funcid, List *args);
extern int xfunc_tuple_width(Relation rd);
-extern int xfunc_num_join_clauses(JoinPath *path);
+extern int xfunc_num_join_clauses(NestPath *path);
extern List *xfunc_LispRemove(List *foo, List *bar);
extern bool xfunc_copyrel(RelOptInfo *from, RelOptInfo ** to);
projects / postgresql.git / commitdiff