aboutsummaryrefslogtreecommitdiff
path: root/src/backend/optimizer/path/xfunc.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/backend/optimizer/path/xfunc.c')
-rw-r--r--src/backend/optimizer/path/xfunc.c42
1 files changed, 21 insertions, 21 deletions
diff --git a/src/backend/optimizer/path/xfunc.c b/src/backend/optimizer/path/xfunc.c
index c8efb254c0a..048fce5ad2e 100644
--- a/src/backend/optimizer/path/xfunc.c
+++ b/src/backend/optimizer/path/xfunc.c
@@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.26 1999/02/12 06:43:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.27 1999/02/12 17:24:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -61,7 +61,7 @@ xfunc_trypullup(RelOptInfo rel)
LispValue y; /* list ptr */
RestrictInfo maxcinfo; /* The RestrictInfo to pull up, as
* calculated by xfunc_shouldpull() */
- NestPath curpath; /* current path in list */
+ JoinPath curpath; /* current path in list */
int progress; /* has progress been made this time
* through? */
int clausetype;
@@ -71,7 +71,7 @@ xfunc_trypullup(RelOptInfo rel)
progress = false; /* no progress yet in this iteration */
foreach(y, get_pathlist(rel))
{
- curpath = (NestPath) lfirst(y);
+ curpath = (JoinPath) lfirst(y);
/*
* * for each operand, attempt to pullup predicates until
@@ -142,7 +142,7 @@ xfunc_trypullup(RelOptInfo rel)
int
xfunc_shouldpull(Query *queryInfo,
Path childpath,
- NestPath parentpath,
+ JoinPath parentpath,
int whichchild,
RestrictInfo * maxcinfopt) /* Out: pointer to clause
* to pullup */
@@ -184,8 +184,8 @@ xfunc_shouldpull(Query *queryInfo,
* see if any join clause has even higher rank than the highest *
* local predicate
*/
- if (is_join(childpath) && xfunc_num_join_clauses((NestPath) childpath) > 1)
- for (tmplist = get_pathrestrictinfo((NestPath) childpath);
+ if (is_join(childpath) && xfunc_num_join_clauses((JoinPath) childpath) > 1)
+ for (tmplist = get_pathrestrictinfo((JoinPath) childpath);
tmplist != LispNil;
tmplist = lnext(tmplist))
{
@@ -263,7 +263,7 @@ xfunc_shouldpull(Query *queryInfo,
RestrictInfo
xfunc_pullup(Query *queryInfo,
Path childpath,
- NestPath parentpath,
+ JoinPath 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 */
@@ -285,9 +285,9 @@ xfunc_pullup(Query *queryInfo,
else
{
set_pathrestrictinfo
- ((NestPath) newkid,
+ ((JoinPath) newkid,
xfunc_LispRemove((LispValue) cinfo,
- (List) get_pathrestrictinfo((NestPath) newkid)));
+ (List) get_pathrestrictinfo((JoinPath) newkid)));
}
/*
@@ -390,7 +390,7 @@ LispValue clause;
** Find global expense of a join clause
*/
Cost
-xfunc_join_expense(Query *queryInfo, NestPath path, int whichchild)
+xfunc_join_expense(Query *queryInfo, JoinPath path, int whichchild)
{
LispValue primjoinclause = xfunc_primary_join(path);
@@ -854,7 +854,7 @@ xfunc_find_references(LispValue clause)
** min rank pathclause
*/
LispValue
-xfunc_primary_join(NestPath pathnode)
+xfunc_primary_join(JoinPath pathnode)
{
LispValue joinclauselist = get_pathrestrictinfo(pathnode);
RestrictInfo mincinfo;
@@ -947,13 +947,13 @@ xfunc_get_path_cost(Query *queryInfo, Path pathnode)
* * Now add in any node-specific expensive function costs. * Again,
* we must ensure that the clauses are sorted by rank.
*/
- if (IsA(pathnode, NestPath))
+ if (IsA(pathnode, JoinPath))
{
if (XfuncMode != XFUNC_OFF)
- set_pathrestrictinfo((NestPath) pathnode, lisp_qsort
- (get_pathrestrictinfo((NestPath) pathnode),
+ set_pathrestrictinfo((JoinPath) pathnode, lisp_qsort
+ (get_pathrestrictinfo((JoinPath) pathnode),
xfunc_cinfo_compare));
- for (tmplist = get_pathrestrictinfo((NestPath) pathnode), selec = 1.0;
+ for (tmplist = get_pathrestrictinfo((JoinPath) pathnode), selec = 1.0;
tmplist != LispNil;
tmplist = lnext(tmplist))
{
@@ -1006,14 +1006,14 @@ xfunc_get_path_cost(Query *queryInfo, Path pathnode)
** 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 NestPaths.
+ ** parent. Thus we should only be calling this function on JoinPaths.
*/
Cost
-xfunc_total_path_cost(NestPath pathnode)
+xfunc_total_path_cost(JoinPath pathnode)
{
Cost cost = xfunc_get_path_cost((Path) pathnode);
- Assert(IsA(pathnode, NestPath));
+ Assert(IsA(pathnode, JoinPath));
if (IsA(pathnode, MergePath))
{
MergePath mrgnode = (MergePath) pathnode;
@@ -1089,7 +1089,7 @@ xfunc_total_path_cost(NestPath pathnode)
*/
Cost
-xfunc_expense_per_tuple(NestPath joinnode, int whichchild)
+xfunc_expense_per_tuple(JoinPath joinnode, int whichchild)
{
RelOptInfo outerrel = get_parent((Path) get_outerjoinpath(joinnode));
RelOptInfo innerrel = get_parent((Path) get_innerjoinpath(joinnode));
@@ -1118,7 +1118,7 @@ xfunc_expense_per_tuple(NestPath joinnode, int whichchild)
else
/* nestloop */
{
- Assert(IsA(joinnode, NestPath));
+ Assert(IsA(joinnode, JoinPath));
return _CPU_PAGE_WEIGHT_;
}
}
@@ -1375,7 +1375,7 @@ xfunc_tuple_width(Relation rd)
** Find the number of join clauses associated with this join path
*/
int
-xfunc_num_join_clauses(NestPath path)
+xfunc_num_join_clauses(JoinPath path)
{
int num = length(get_pathrestrictinfo(path));