*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.31 1999/02/02 03:44:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.32 1999/02/03 20:15:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include <access/heapam.h>
#include <utils/builtins.h>
#include <utils/syscache.h>
+#include <catalog/heap.h>
#include <catalog/index.h>
#include <catalog/pg_index.h>
#include <catalog/pg_proc.h>
- /*-------------------------------------------------------------------------
+/*-------------------------------------------------------------------------
*
* copyfuncs.c--
* Copy functions for Postgres tree nodes.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.57 1999/02/02 03:44:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.58 1999/02/03 20:15:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
newnode->ordering[len] = 0;
}
- Node_Copy(from, newnode, clauseinfo);
+ Node_Copy(from, newnode, restrictinfo);
Node_Copy(from, newnode, joininfo);
Node_Copy(from, newnode, innerjoin);
Node_Copy(from, newnode, superrels);
newnode->outerjoincost = from->outerjoincost;
newnode->joinid = listCopy(from->joinid);
- Node_Copy(from, newnode, locclauseinfo);
+ Node_Copy(from, newnode, loc_restrictinfo);
}
/* ----------------
static void
CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
{
- Node_Copy(from, newnode, pathclauseinfo);
+ Node_Copy(from, newnode, pathinfo);
Node_Copy(from, newnode, outerjoinpath);
Node_Copy(from, newnode, innerjoinpath);
}
}
/* ----------------
- * _copyClauseInfo
+ * _copyRestrictInfo
* ----------------
*/
-static ClauseInfo *
-_copyClauseInfo(ClauseInfo * from)
+static RestrictInfo *
+_copyRestrictInfo(RestrictInfo * from)
{
- ClauseInfo *newnode = makeNode(ClauseInfo);
+ RestrictInfo *newnode = makeNode(RestrictInfo);
/* ----------------
* copy remainder of node
* ----------------
*/
newnode->otherrels = listCopy(from->otherrels);
- Node_Copy(from, newnode, jinfoclauseinfo);
+ Node_Copy(from, newnode, jinfo_restrictinfo);
newnode->mergejoinable = from->mergejoinable;
newnode->hashjoinable = from->hashjoinable;
case T_MergeOrder:
retval = _copyMergeOrder(from);
break;
- case T_ClauseInfo:
- retval = _copyClauseInfo(from);
+ case T_RestrictInfo:
+ retval = _copyRestrictInfo(from);
break;
case T_JoinMethod:
retval = _copyJoinMethod(from);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.21 1999/02/02 23:53:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.22 1999/02/03 20:15:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/*
- * ClauseInfo is a subclass of Node.
+ * RestrictInfo is a subclass of Node.
*/
static bool
-_equalClauseInfo(ClauseInfo * a, ClauseInfo * b)
+_equalRestrictInfo(RestrictInfo * a, RestrictInfo * b)
{
- Assert(IsA(a, ClauseInfo));
- Assert(IsA(b, ClauseInfo));
+ Assert(IsA(a, RestrictInfo));
+ Assert(IsA(b, RestrictInfo));
if (!equal(a->clause, b->clause))
return false;
#endif
if (a->hashjoinoperator != b->hashjoinoperator)
return false;
- return (equal((a->indexids),
- (b->indexids)));
+ return equal(a->indexids, b->indexids);
}
/*
Assert(IsA(a, RelOptInfo));
Assert(IsA(b, RelOptInfo));
- return (equal((a->relids),
- (b->relids)));
+ return equal(a->relids, b->relids);
}
static bool
Assert(IsA(a, JoinMethod));
Assert(IsA(b, JoinMethod));
- if (!equal((a->jmkeys),
- (b->jmkeys)))
+ if (!equal(a->jmkeys, b->jmkeys))
return false;
- if (!equal((a->clauses),
- (b->clauses)))
+ if (!equal(a->clauses, b->clauses))
return false;
return true;
}
}
else
{
- if (!equal((a->p_ordering.ord.merge),
- (b->p_ordering.ord.merge)))
+ if (!equal(a->p_ordering.ord.merge, b->p_ordering.ord.merge))
return false;
}
- if (!equal((a->keys),
- (b->keys)))
+ if (!equal(a->keys, b->keys))
return false;
/*
* if (a->outerjoincost != b->outerjoincost) return(false);
*/
- if (!equali((a->joinid),
- (b->joinid)))
+ if (!equali(a->joinid, b->joinid))
return false;
return true;
}
{
if (!_equalPath((Path *) a, (Path *) b))
return false;
- if (!equali((a->indexid), (b->indexid)))
+ if (!equali(a->indexid, b->indexid))
return false;
- if (!equal((a->indexqual), (b->indexqual)))
+ if (!equal(a->indexqual, b->indexqual))
return false;
return true;
}
if (!_equalPath((Path *) a, (Path *) b))
return false;
- if (!equal((a->pathclauseinfo), (b->pathclauseinfo)))
+ if (!equal(a->pathinfo, b->pathinfo))
return false;
- if (!equal((a->outerjoinpath), (b->outerjoinpath)))
+ if (!equal(a->outerjoinpath, b->outerjoinpath))
return false;
- if (!equal((a->innerjoinpath), (b->innerjoinpath)))
+ if (!equal(a->innerjoinpath, b->innerjoinpath))
return false;
return true;
}
Assert(IsA(a, JoinKey));
Assert(IsA(b, JoinKey));
- if (!equal((a->outer), (b->outer)))
+ if (!equal(a->outer, b->outer))
return false;
- if (!equal((a->inner), (b->inner)))
+ if (!equal(a->inner, b->inner))
return false;
return true;
}
* if(a->scan.plan.cost != b->scan.plan.cost) return(false);
*/
- if (!equal((a->indxqual), (b->indxqual)))
+ if (!equal(a->indxqual, b->indxqual))
return false;
if (a->scan.scanrelid != b->scan.scanrelid)
return false;
- if (!equali((a->indxid), (b->indxid)))
+ if (!equali(a->indxid, b->indxid))
return false;
return true;
}
if (a->plan_id != b->plan_id)
return false;
- if (!equal((a->sublink->oper), (b->sublink->oper)))
+ if (!equal(a->sublink->oper, b->sublink->oper))
return false;
return true;
{
Assert(IsA(a, JoinInfo));
Assert(IsA(b, JoinInfo));
- if (!equal((a->otherrels), (b->otherrels)))
+ if (!equal(a->otherrels, b->otherrels))
return false;
- if (!equal((a->jinfoclauseinfo), (b->jinfoclauseinfo)))
+ if (!equal(a->jinfo_restrictinfo, b->jinfo_restrictinfo))
return false;
if (a->mergejoinable != b->mergejoinable)
return false;
case T_Func:
retval = _equalFunc(a, b);
break;
- case T_ClauseInfo:
- retval = _equalClauseInfo(a, b);
+ case T_RestrictInfo:
+ retval = _equalRestrictInfo(a, b);
break;
case T_RelOptInfo:
retval = _equalRelOptInfo(a, b);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.62 1999/02/02 03:44:26 momjian Exp $
+ * $Id: outfuncs.c,v 1.63 1999/02/03 20:15:22 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
*/
appendStringInfo(str,
- " :unorderedpath @ 0x%x :cheapestpath @ 0x%x :pruneable %s :clauseinfo ",
+ " :unorderedpath @ 0x%x :cheapestpath @ 0x%x :pruneable %s :restrictinfo ",
(int) node->unorderedpath,
(int) node->cheapestpath,
node->pruneable ? "true" : "false");
- _outNode(str, node->clauseinfo);
+ _outNode(str, node->restrictinfo);
appendStringInfo(str, " :joininfo ");
_outNode(str, node->joininfo);
node->path.path_cost);
_outNode(str, node->path.keys);
- appendStringInfo(str, " :pathclauseinfo ");
- _outNode(str, node->pathclauseinfo);
+ appendStringInfo(str, " :pathinfo ");
+ _outNode(str, node->pathinfo);
/*
* Not sure if these are nodes; they're declared as "struct path *".
node->jpath.path.path_cost);
_outNode(str, node->jpath.path.keys);
- appendStringInfo(str, " :pathclauseinfo ");
- _outNode(str, node->jpath.pathclauseinfo);
+ appendStringInfo(str, " :pathinfo ");
+ _outNode(str, node->jpath.pathinfo);
/*
* Not sure if these are nodes; they're declared as "struct path *".
node->jpath.path.path_cost);
_outNode(str, node->jpath.path.keys);
- appendStringInfo(str, " :pathclauseinfo ");
- _outNode(str, node->jpath.pathclauseinfo);
+ appendStringInfo(str, " :pathinfo ");
+ _outNode(str, node->jpath.pathinfo);
/*
* Not sure if these are nodes; they're declared as "struct path *".
}
/*
- * ClauseInfo is a subclass of Node.
+ * RestrictInfo is a subclass of Node.
*/
static void
-_outClauseInfo(StringInfo str, ClauseInfo * node)
+_outRestrictInfo(StringInfo str, RestrictInfo * node)
{
appendStringInfo(str, " CINFO :clause ");
_outNode(str, node->clause);
appendStringInfo(str, " JINFO :otherrels ");
_outIntList(str, node->otherrels);
- appendStringInfo(str, " :jinfoclauseinfo ");
- _outNode(str, node->jinfoclauseinfo);
+ appendStringInfo(str, " :jinfo_restrictinfo ");
+ _outNode(str, node->jinfo_restrictinfo);
appendStringInfo(str, " :mergejoinable %s :hashjoinable %s ",
node->mergejoinable ? "true" : "false",
case T_MergeOrder:
_outMergeOrder(str, obj);
break;
- case T_ClauseInfo:
- _outClauseInfo(str, obj);
+ case T_RestrictInfo:
+ _outRestrictInfo(str, obj);
break;
case T_JoinMethod:
_outJoinMethod(str, obj);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.44 1999/02/02 03:44:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.45 1999/02/03 20:15:22 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
sscanf(token, "%x", (unsigned int *) &local_node->cheapestpath);
- token = lsptok(NULL, &length); /* get :clauseinfo */
- local_node->clauseinfo = nodeRead(true); /* now read it */
+ token = lsptok(NULL, &length); /* get :restrictinfo */
+ local_node->restrictinfo = nodeRead(true); /* now read it */
token = lsptok(NULL, &length); /* get :joininfo */
local_node->joininfo = nodeRead(true); /* now read it */
token = lsptok(NULL, &length); /* get :keys */
local_node->path.keys = nodeRead(true); /* now read it */
- token = lsptok(NULL, &length); /* get :pathclauseinfo */
- local_node->pathclauseinfo = nodeRead(true); /* now read it */
+ token = lsptok(NULL, &length); /* get :pathinfo */
+ local_node->pathinfo = nodeRead(true); /* now read it */
/*
* Not sure if these are nodes; they're declared as "struct path *".
token = lsptok(NULL, &length); /* get :keys */
local_node->jpath.path.keys = nodeRead(true); /* now read it */
- token = lsptok(NULL, &length); /* get :pathclauseinfo */
- local_node->jpath.pathclauseinfo = nodeRead(true); /* now read it */
+ token = lsptok(NULL, &length); /* get :pathinfo */
+ local_node->jpath.pathinfo = nodeRead(true); /* now read it */
/*
* Not sure if these are nodes; they're declared as "struct path *".
token = lsptok(NULL, &length); /* get :keys */
local_node->jpath.path.keys = nodeRead(true); /* now read it */
- token = lsptok(NULL, &length); /* get :pathclauseinfo */
- local_node->jpath.pathclauseinfo = nodeRead(true); /* now read it */
+ token = lsptok(NULL, &length); /* get :pathinfo */
+ local_node->jpath.pathinfo = nodeRead(true); /* now read it */
/*
* Not sure if these are nodes; they're declared as "struct path *".
}
/* ----------------
- * _readClauseInfo
+ * _readRestrictInfo
*
- * ClauseInfo is a subclass of Node.
+ * RestrictInfo is a subclass of Node.
* ----------------
*/
-static ClauseInfo *
-_readClauseInfo()
+static RestrictInfo *
+_readRestrictInfo()
{
- ClauseInfo *local_node;
+ RestrictInfo *local_node;
char *token;
int length;
- local_node = makeNode(ClauseInfo);
+ local_node = makeNode(RestrictInfo);
token = lsptok(NULL, &length); /* get :clause */
local_node->clause = nodeRead(true); /* now read it */
local_node->otherrels =
toIntList(nodeRead(true)); /* now read it */
- token = lsptok(NULL, &length); /* get :jinfoclauseinfo */
- local_node->jinfoclauseinfo = nodeRead(true); /* now read it */
+ token = lsptok(NULL, &length); /* get :jinfo_restrictinfo */
+ local_node->jinfo_restrictinfo = nodeRead(true); /* now read it */
token = lsptok(NULL, &length); /* get :mergejoinable */
else if (!strncmp(token, "MERGEORDER", length))
return_value = _readMergeOrder();
else if (!strncmp(token, "CLAUSEINFO", length))
- return_value = _readClauseInfo();
+ return_value = _readRestrictInfo();
else if (!strncmp(token, "JOINMETHOD", length))
return_value = _readJoinMethod();
else if (!strncmp(token, "JOININFO", length))
-Thse directories take the Query structure returned by the parser, and
+These directories take the Query structure returned by the parser, and
generate a plan used by the executor. The /plan directory generates the
plan, the /path generates all possible ways to join the tables, and
/prep handles special cases like inheritance. /utils is utility stuff.
remove from the join list the relation we just added to each join
prune_rel_paths()
set cheapest and perhaps remove unordered path, recompute table sizes
- if we have not done all the tables, go to "again"
+ if we have not done all the tables, go to again:
do group(GROUP)
do aggregate
put back constants
re-flatten target list
make unique(DISTINCT)
make sort(ORDER BY)
+
+
+
+Optimizer Structures
+--------------------
+Path - info about every way to access a relation(sequential, index)
+ PathOrder - info about every ordering (sort, merge of relations)
+RelOptInfo - info about every relation
+ JoinInfo - info about join combinations
+RestrictInfo - info about restrictions
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_eval.c,v 1.24 1998/09/01 04:29:16 momjian Exp $
+ * $Id: geqo_eval.c,v 1.25 1999/02/03 20:15:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
joinrel->classlist = NULL;
joinrel->relam = InvalidOid;
joinrel->ordering = NULL;
- joinrel->clauseinfo = NIL;
+ joinrel->restrictinfo = NIL;
joinrel->joininfo = NULL;
joinrel->innerjoin = NIL;
joinrel->superrels = NIL;
if (joininfo)
{
- joinrel->clauseinfo = joininfo->jinfoclauseinfo;
+ joinrel->restrictinfo = joininfo->jinfo_restrictinfo;
if (BushyPlanFlag)
joininfo->inactive = true;
}
current_joininfo_list);
if (other_joininfo)
{
- other_joininfo->jinfoclauseinfo =
- (List *) LispUnion(joininfo->jinfoclauseinfo,
- other_joininfo->jinfoclauseinfo);
+ other_joininfo->jinfo_restrictinfo =
+ (List *) LispUnion(joininfo->jinfo_restrictinfo,
+ other_joininfo->jinfo_restrictinfo);
}
else
{
other_joininfo = makeNode(JoinInfo);
- other_joininfo->otherrels =
- joininfo->otherrels;
- other_joininfo->jinfoclauseinfo =
- joininfo->jinfoclauseinfo;
- other_joininfo->mergejoinable =
- joininfo->mergejoinable;
- other_joininfo->hashjoinable =
- joininfo->hashjoinable;
+ other_joininfo->otherrels = joininfo->otherrels;
+ other_joininfo->jinfo_restrictinfo = joininfo->jinfo_restrictinfo;
+ other_joininfo->mergejoinable = joininfo->mergejoinable;
+ other_joininfo->hashjoinable = joininfo->hashjoinable;
other_joininfo->inactive = false;
current_joininfo_list = lcons(other_joininfo,
{
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
List *other_rels = joininfo->otherrels;
- List *clause_info = joininfo->jinfoclauseinfo;
+ List *restrict_info = joininfo->jinfo_restrictinfo;
bool mergejoinable = joininfo->mergejoinable;
bool hashjoinable = joininfo->hashjoinable;
new_joininfo = makeNode(JoinInfo);
new_joininfo->otherrels = joinrel->relids;
- new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->jinfo_restrictinfo = restrict_info;
new_joininfo->mergejoinable = mergejoinable;
new_joininfo->hashjoinable = hashjoinable;
new_joininfo->inactive = false;
if (other_joininfo)
{
- other_joininfo->jinfoclauseinfo =
- (List *) LispUnion(clause_info,
- other_joininfo->jinfoclauseinfo);
+ other_joininfo->jinfo_restrictinfo =
+ (List *) LispUnion(restrict_info,
+ other_joininfo->jinfo_restrictinfo);
}
else
{
JoinInfo *new_joininfo = makeNode(JoinInfo);
new_joininfo->otherrels = new_relids;
- new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->jinfo_restrictinfo = restrict_info;
new_joininfo->mergejoinable = mergejoinable;
new_joininfo->hashjoinable = hashjoinable;
new_joininfo->inactive = false;
temp = (Cost) inner_rel->tuples * (Cost) outer_rel->tuples; /* cartesian product */
- if (joinrel->clauseinfo)
- temp = temp * product_selec(joinrel->clauseinfo);
+ if (joinrel->restrictinfo)
+ temp = temp * product_selec(joinrel->restrictinfo);
if (temp >= (MAXINT - 1))
ntuples = ceil(geqo_log((double) temp, (double) GEQO_LOG_BASE));
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_misc.c,v 1.11 1998/09/01 04:29:19 momjian Exp $
+ * $Id: geqo_misc.c,v 1.12 1999/02/03 20:15:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
foreach(l, clauses)
{
- ClauseInfo *c = lfirst(l);
+ RestrictInfo *c = lfirst(l);
print_expr((Node *) c->clause, root->rtable);
if (lnext(l))
printf("\t");
printf(" clauses=(");
geqo_print_joinclauses(root,
- ((JoinPath *) path)->pathclauseinfo);
+ ((JoinPath *) path)->pathinfo);
printf(")\n");
if (nodeTag(path) == T_MergePath)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.24 1999/02/02 20:30:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.25 1999/02/03 20:15:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
rel_index_scan_list = find_index_paths(root,
rel,
find_relation_indices(root, rel),
- rel->clauseinfo,
+ rel->restrictinfo,
rel->joininfo);
- or_index_scan_list = create_or_index_paths(root, rel, rel->clauseinfo);
+ or_index_scan_list = create_or_index_paths(root, rel, rel->restrictinfo);
rel->pathlist = add_pathlist(rel,
sequential_scan_list,
* if there is a qualification of sequential scan the selec. value
* is not set -- so set it explicitly -- Sunita
*/
- set_rest_selec(root, rel->clauseinfo);
+ set_rest_selec(root, rel->restrictinfo);
rel->size = compute_rel_size(rel);
rel->width = compute_rel_width(rel);
}
foreach(l, clauses)
{
- ClauseInfo *c = lfirst(l);
+ RestrictInfo *c = lfirst(l);
print_expr((Node *) c->clause, root->rtable);
if (lnext(l))
for (i = 0; i < indent + 1; i++)
printf("\t");
printf(" clauses=(");
- print_joinclauses(root,
- ((JoinPath *) path)->pathclauseinfo);
+ print_joinclauses(root, ((JoinPath *) path)->pathinfo);
printf(")\n");
if (nodeTag(path) == T_MergePath)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.14 1998/11/09 02:49:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.15 1999/02/03 20:15:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/primnodes.h"
#include "nodes/relation.h"
#include "optimizer/clauses.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/cost.h"
#include "optimizer/internal.h"
#include "optimizer/plancat.h"
/*
* set_clause_selectivities -
- * Sets the selectivity field for each of clause in 'clauseinfo-list'
+ * Sets the selectivity field for each of clause in 'restrictinfo-list'
* to 'new-selectivity'. If the selectivity has already been set, reset
* it only if the new one is better.
*
*
*/
void
-set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity)
+set_clause_selectivities(List *restrictinfo_list, Cost new_selectivity)
{
List *temp;
- ClauseInfo *clausenode;
+ RestrictInfo *clausenode;
Cost cost_clause;
- foreach(temp, clauseinfo_list)
+ foreach(temp, restrictinfo_list)
{
- clausenode = (ClauseInfo *) lfirst(temp);
+ clausenode = (RestrictInfo *) lfirst(temp);
cost_clause = clausenode->selectivity;
if (FLOAT_IS_ZERO(cost_clause) || new_selectivity < cost_clause)
clausenode->selectivity = new_selectivity;
/*
* product_selec -
- * Multiplies the selectivities of each clause in 'clauseinfo-list'.
+ * Multiplies the selectivities of each clause in 'restrictinfo-list'.
*
- * Returns a flonum corresponding to the selectivity of 'clauseinfo-list'.
+ * Returns a flonum corresponding to the selectivity of 'restrictinfo-list'.
*/
Cost
-product_selec(List *clauseinfo_list)
+product_selec(List *restrictinfo_list)
{
Cost result = 1.0;
- if (clauseinfo_list != NIL)
+ if (restrictinfo_list != NIL)
{
List *xclausenode = NIL;
Cost temp;
- foreach(xclausenode, clauseinfo_list)
+ foreach(xclausenode, restrictinfo_list)
{
- temp = ((ClauseInfo *) lfirst(xclausenode))->selectivity;
+ temp = ((RestrictInfo *) lfirst(xclausenode))->selectivity;
result = result * temp;
}
}
* those clauses that haven't been assigned a selectivity by an index.
*
* Returns nothing of interest.
- * MODIFIES: selectivities of the various rel's clauseinfo
+ * MODIFIES: selectivities of the various rel's restrictinfo
* slots.
*/
void
foreach(x, rel_list)
{
rel = (RelOptInfo *) lfirst(x);
- set_rest_selec(root, rel->clauseinfo);
+ set_rest_selec(root, rel->restrictinfo);
}
}
/*
* set_rest_selec -
* Sets the selectivity fields for those clauses within a single
- * relation's 'clauseinfo-list' that haven't already been set.
+ * relation's 'restrictinfo-list' that haven't already been set.
*
* Returns nothing of interest.
*
*/
void
-set_rest_selec(Query *root, List *clauseinfo_list)
+set_rest_selec(Query *root, List *restrictinfo_list)
{
List *temp = NIL;
- ClauseInfo *clausenode = (ClauseInfo *) NULL;
+ RestrictInfo *clausenode = (RestrictInfo *) NULL;
Cost cost_clause;
- foreach(temp, clauseinfo_list)
+ foreach(temp, restrictinfo_list)
{
- clausenode = (ClauseInfo *) lfirst(temp);
+ clausenode = (RestrictInfo *) lfirst(temp);
cost_clause = clausenode->selectivity;
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.25 1998/09/01 04:29:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.26 1999/02/03 20:15:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Cost temp;
int temp1;
- temp = rel->tuples * product_selec(rel->clauseinfo);
+ temp = rel->tuples * product_selec(rel->restrictinfo);
Assert(temp >= 0);
if (temp >= (MAXINT - 1))
temp1 = MAXINT;
temp *= ((Path *) joinpath->outerjoinpath)->parent->size;
temp *= ((Path *) joinpath->innerjoinpath)->parent->size;
- temp = temp * product_selec(joinpath->pathclauseinfo);
+ temp = temp * product_selec(joinpath->pathinfo);
if (temp >= (MAXINT - 1))
temp1 = MAXINT;
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.7 1998/09/01 04:29:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.8 1999/02/03 20:15:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* group-clauses-by-hashop--
- * If a join clause node in 'clauseinfo-list' is hashjoinable, store
+ * If a join clause node in 'restrictinfo-list' is hashjoinable, store
* it within a hashinfo node containing other clause nodes with the same
* hash operator.
*
- * 'clauseinfo-list' is the list of clauseinfo nodes
+ * 'restrictinfo-list' is the list of restrictinfo nodes
* 'inner-relid' is the relid of the inner join relation
*
* Returns the new list of hashinfo nodes.
*
*/
List *
-group_clauses_by_hashop(List *clauseinfo_list,
+group_clauses_by_hashop(List *restrictinfo_list,
int inner_relid)
{
List *hashinfo_list = NIL;
- ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
+ RestrictInfo *restrictinfo = (RestrictInfo *) NULL;
List *i = NIL;
Oid hashjoinop = 0;
- foreach(i, clauseinfo_list)
+ foreach(i, restrictinfo_list)
{
- clauseinfo = (ClauseInfo *) lfirst(i);
- hashjoinop = clauseinfo->hashjoinoperator;
+ restrictinfo = (RestrictInfo *) lfirst(i);
+ hashjoinop = restrictinfo->hashjoinoperator;
/*
* Create a new hashinfo node and add it to 'hashinfo-list' if one
if (hashjoinop)
{
HInfo *xhashinfo = (HInfo *) NULL;
- Expr *clause = clauseinfo->clause;
+ Expr *clause = restrictinfo->clause;
Var *leftop = get_leftop(clause);
Var *rightop = get_rightop(clause);
JoinKey *keys = (JoinKey *) NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.35 1998/09/21 15:41:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.36 1999/02/03 20:15:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/pg_list.h"
#include "nodes/relation.h"
#include "optimizer/clauses.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/cost.h"
#include "optimizer/internal.h"
#include "optimizer/keys.h"
static void match_index_orclauses(RelOptInfo * rel, RelOptInfo * index, int indexkey,
- int xclass, List *clauseinfo_list);
+ int xclass, List *restrictinfo_list);
static bool match_index_to_operand(int indexkey, Expr *operand,
RelOptInfo * rel, RelOptInfo * index);
static List *match_index_orclause(RelOptInfo * rel, RelOptInfo * index, int indexkey,
int xclass, List *or_clauses, List *other_matching_indices);
static List *group_clauses_by_indexkey(RelOptInfo * rel, RelOptInfo * index,
- int *indexkeys, Oid *classes, List *clauseinfo_list);
+ int *indexkeys, Oid *classes, List *restrictinfo_list);
static List *group_clauses_by_ikey_for_joins(RelOptInfo * rel, RelOptInfo * index,
int *indexkeys, Oid *classes, List *join_cinfo_list, List *restr_cinfo_list);
-static ClauseInfo *match_clause_to_indexkey(RelOptInfo * rel, RelOptInfo * index, int indexkey,
- int xclass, ClauseInfo * clauseInfo, bool join);
-static bool pred_test(List *predicate_list, List *clauseinfo_list,
+static RestrictInfo *match_clause_to_indexkey(RelOptInfo * rel, RelOptInfo * index, int indexkey,
+ int xclass, RestrictInfo * clauseInfo, bool join);
+static bool pred_test(List *predicate_list, List *restrictinfo_list,
List *joininfo_list);
-static bool one_pred_test(Expr *predicate, List *clauseinfo_list);
+static bool one_pred_test(Expr *predicate, List *restrictinfo_list);
static bool one_pred_clause_expr_test(Expr *predicate, Node *clause);
static bool one_pred_clause_test(Expr *predicate, Node *clause);
static bool clause_pred_clause_test(Expr *predicate, Node *clause);
static List *indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
- List *joininfo_list, List *clauseinfo_list);
+ List *joininfo_list, List *restrictinfo_list);
static List *index_innerjoin(Query *root, RelOptInfo * rel,
List *clausegroup_list, RelOptInfo * index);
static List *create_index_paths(Query *root, RelOptInfo * rel, RelOptInfo * index,
*
* 'rel' is the relation entry to which these index paths correspond
* 'indices' is a list of possible index paths
- * 'clauseinfo-list' is a list of restriction clauseinfo nodes for 'rel'
+ * 'restrictinfo-list' is a list of restriction restrictinfo nodes for 'rel'
* 'joininfo-list' is a list of joininfo nodes for 'rel'
* 'sortkeys' is a node describing the result sort order (from
* (find_sortkeys))
find_index_paths(Query *root,
RelOptInfo * rel,
List *indices,
- List *clauseinfo_list,
+ List *restrictinfo_list,
List *joininfo_list)
{
List *scanclausegroups = NIL;
* test
*/
if (index->indpred != NIL)
- if (!pred_test(index->indpred, clauseinfo_list, joininfo_list))
+ if (!pred_test(index->indpred, restrictinfo_list, joininfo_list))
continue;
/*
* 1. Try matching the index against subclauses of an 'or' clause.
- * The fields of the clauseinfo nodes are marked with lists of the
+ * The fields of the restrictinfo nodes are marked with lists of the
* matching indices. No path are actually created. We currently
* only look to match the first key. We don't find multi-key
* index cases where an AND matches the first key, and the OR
index,
index->indexkeys[0],
index->classlist[0],
- clauseinfo_list);
+ restrictinfo_list);
/*
* 2. If the keys of this index match any of the available
index,
index->indexkeys,
index->classlist,
- clauseinfo_list);
+ restrictinfo_list);
scanpaths = NIL;
if (scanclausegroups != NIL)
* mergejoin, or if the index can possibly be used for scanning
* the inner relation of a nestloop join.
*/
- joinclausegroups = indexable_joinclauses(rel, index, joininfo_list, clauseinfo_list);
+ joinclausegroups = indexable_joinclauses(rel, index, joininfo_list, restrictinfo_list);
joinpaths = NIL;
if (joinclausegroups != NIL)
* about the index.
*
* Essentially, this adds 'index' to the list of indices in the
- * ClauseInfo field of each of the clauses which it matches.
+ * RestrictInfo field of each of the clauses which it matches.
*
* 'rel' is the node of the relation on which the index is defined.
* 'index' is the index node.
* 'indexkey' is the (single) key of the index
* 'class' is the class of the operator corresponding to 'indexkey'.
- * 'clauseinfo-list' is the list of available restriction clauses.
+ * 'restrictinfo-list' is the list of available restriction clauses.
*
* Returns nothing.
*
RelOptInfo * index,
int indexkey,
int xclass,
- List *clauseinfo_list)
+ List *restrictinfo_list)
{
- ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
+ RestrictInfo *restrictinfo = (RestrictInfo *) NULL;
List *i = NIL;
- foreach(i, clauseinfo_list)
+ foreach(i, restrictinfo_list)
{
- clauseinfo = (ClauseInfo *) lfirst(i);
- if (valid_or_clause(clauseinfo))
+ restrictinfo = (RestrictInfo *) lfirst(i);
+ if (valid_or_clause(restrictinfo))
{
/*
* each of its subclauses. The list is generated by adding
* 'index' to the existing list where appropriate.
*/
- clauseinfo->indexids =
+ restrictinfo->indexids =
match_index_orclause(rel, index, indexkey,
xclass,
- clauseinfo->clause->args,
- clauseinfo->indexids);
+ restrictinfo->clause->args,
+ restrictinfo->indexids);
}
}
}
RelOptInfo * index,
int *indexkeys,
Oid *classes,
- List *clauseinfo_list)
+ List *restrictinfo_list)
{
List *curCinfo = NIL;
- ClauseInfo *matched_clause = (ClauseInfo *) NULL;
+ RestrictInfo *matched_clause = (RestrictInfo *) NULL;
List *clausegroup = NIL;
int curIndxKey;
Oid curClass;
- if (clauseinfo_list == NIL || indexkeys[0] == 0)
+ if (restrictinfo_list == NIL || indexkeys[0] == 0)
return NIL;
do
curIndxKey = indexkeys[0];
curClass = classes[0];
- foreach(curCinfo, clauseinfo_list)
+ foreach(curCinfo, restrictinfo_list)
{
- ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
+ RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
matched_clause = match_clause_to_indexkey(rel,
index,
List *restr_cinfo_list)
{
List *curCinfo = NIL;
- ClauseInfo *matched_clause = (ClauseInfo *) NULL;
+ RestrictInfo *matched_clause = (RestrictInfo *) NULL;
List *clausegroup = NIL;
int curIndxKey;
Oid curClass;
foreach(curCinfo, join_cinfo_list)
{
- ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
+ RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
matched_clause = match_clause_to_indexkey(rel,
index,
}
foreach(curCinfo, restr_cinfo_list)
{
- ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
+ RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
matched_clause = match_clause_to_indexkey(rel,
index,
*
* If the clause being matched is a join clause, then 'join' is t.
*
- * Returns a single clauseinfo node corresponding to the matching
+ * Returns a single restrictinfo node corresponding to the matching
* clause.
*
* NOTE: returns nil if clause is an or_clause.
*
*/
-static ClauseInfo *
+static RestrictInfo *
match_clause_to_indexkey(RelOptInfo * rel,
RelOptInfo * index,
int indexkey,
int xclass,
- ClauseInfo * clauseInfo,
+ RestrictInfo * clauseInfo,
bool join)
{
Expr *clause = clauseInfo->clause;
if (or_clause((Node *) clause) ||
not_clause((Node *) clause) || single_node((Node *) clause))
- return (ClauseInfo *) NULL;
+ return (RestrictInfo *) NULL;
leftop = get_leftop(clause);
rightop = get_rightop(clause);
* pred_test--
* Does the "predicate inclusion test" for partial indexes.
*
- * Recursively checks whether the clauses in clauseinfo_list imply
+ * Recursively checks whether the clauses in restrictinfo_list imply
* that the given predicate is true.
*
* This routine (together with the routines it calls) iterates over
* successfully cnfify()-ed). --Nels, Jan '93
*/
static bool
-pred_test(List *predicate_list, List *clauseinfo_list, List *joininfo_list)
+pred_test(List *predicate_list, List *restrictinfo_list, List *joininfo_list)
{
List *pred,
*items,
* an index on c.d), then we could use that equivalence class info
* here with joininfo_list to do more complete tests for the usability
* of a partial index. For now, the test only uses restriction
- * clauses (those in clauseinfo_list). --Nels, Dec '92
+ * clauses (those in restrictinfo_list). --Nels, Dec '92
*/
if (predicate_list == NULL)
return true; /* no predicate: the index is usable */
- if (clauseinfo_list == NULL)
+ if (restrictinfo_list == NULL)
return false; /* no restriction clauses: the test must
* fail */
items = ((Expr *) lfirst(pred))->args;
foreach(item, items)
{
- if (!one_pred_test(lfirst(item), clauseinfo_list))
+ if (!one_pred_test(lfirst(item), restrictinfo_list))
return false;
}
}
- else if (!one_pred_test(lfirst(pred), clauseinfo_list))
+ else if (!one_pred_test(lfirst(pred), restrictinfo_list))
return false;
}
return true;
* expression.
*/
static bool
-one_pred_test(Expr *predicate, List *clauseinfo_list)
+one_pred_test(Expr *predicate, List *restrictinfo_list)
{
- ClauseInfo *clauseinfo;
+ RestrictInfo *restrictinfo;
List *item;
Assert(predicate != NULL);
- foreach(item, clauseinfo_list)
+ foreach(item, restrictinfo_list)
{
- clauseinfo = (ClauseInfo *) lfirst(item);
+ restrictinfo = (RestrictInfo *) lfirst(item);
/* if any clause implies the predicate, return true */
- if (one_pred_clause_expr_test(predicate, (Node *) clauseinfo->clause))
+ if (one_pred_clause_expr_test(predicate, (Node *) restrictinfo->clause))
return true;
}
return false;
*
* Returns a list of these clause groups.
*
- * Added: clauseinfo_list - list of restriction ClauseInfos. It's to
+ * Added: restrictinfo_list - list of restriction RestrictInfos. It's to
* support multi-column indices in joins and for cases
* when a key is in both join & restriction clauses. - vadim 03/18/97
*
*/
static List *
indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
- List *joininfo_list, List *clauseinfo_list)
+ List *joininfo_list, List *restrictinfo_list)
{
JoinInfo *joininfo = (JoinInfo *) NULL;
List *cg_list = NIL;
{
joininfo = (JoinInfo *) lfirst(i);
- if (joininfo->jinfoclauseinfo == NIL)
+ if (joininfo->jinfo_restrictinfo == NIL)
continue;
clausegroups =
group_clauses_by_ikey_for_joins(rel,
index,
index->indexkeys,
index->classlist,
- joininfo->jinfoclauseinfo,
- clauseinfo_list);
+ joininfo->jinfo_restrictinfo,
+ restrictinfo_list);
if (clausegroups != NIL)
{
List *clauses = lfirst(clausegroups);
- ((ClauseInfo *) lfirst(clauses))->cinfojoinid =
+ ((RestrictInfo *) lfirst(clauses))->cinfojoinid =
joininfo->otherrels;
}
cg_list = nconc(cg_list, clausegroups);
foreach(l, clausegroup)
{
- ClauseInfo *cinfo = lfirst(l);
+ RestrictInfo *cinfo = lfirst(l);
if (!is_joinable((Node *) cinfo->clause))
restrict_cls = lappend(restrict_cls, cinfo);
* Creates index path nodes corresponding to paths to be used as inner
* relations in nestloop joins.
*
- * 'clausegroup-list' is a list of list of clauseinfo nodes which can use
+ * 'clausegroup-list' is a list of list of restrictinfo nodes which can use
* 'index' on their inner relation.
*
* Returns a list of index pathnodes.
pathnode->indexkeys = index->indexkeys;
pathnode->indexqual = clausegroup;
- pathnode->path.joinid = ((ClauseInfo *) lfirst(clausegroup))->cinfojoinid;
+ pathnode->path.joinid = ((RestrictInfo *) lfirst(clausegroup))->cinfojoinid;
pathnode->path.path_cost =
cost_index((Oid) lfirsti(index->relids),
true);
/*
- * copy clauseinfo list into path for expensive function
+ * copy restrictinfo list into path for expensive function
* processing -- JMH, 7/7/92
*/
- pathnode->path.locclauseinfo =
- set_difference(copyObject((Node *) rel->clauseinfo),
+ pathnode->path.loc_restrictinfo =
+ set_difference(copyObject((Node *) rel->restrictinfo),
clausegroup);
#if 0 /* fix xfunc */
* (restriction or join) that can be used in conjunction with an index.
*
* 'rel' is the relation for which 'index' is defined
- * 'clausegroup-list' is the list of clause groups (lists of clauseinfo
+ * 'clausegroup-list' is the list of clause groups (lists of restrictinfo
* nodes) grouped by mergejoinorder
* 'join' is a flag indicating whether or not the clauses are join
* clauses
foreach(i, clausegroup_list)
{
- ClauseInfo *clauseinfo;
+ RestrictInfo *restrictinfo;
List *temp_node = NIL;
bool temp = true;
foreach(j, clausegroup)
{
- clauseinfo = (ClauseInfo *) lfirst(j);
- if (!(is_joinable((Node *) clauseinfo->clause) &&
+ restrictinfo = (RestrictInfo *) lfirst(j);
+ if (!(is_joinable((Node *) restrictinfo->clause) &&
equal_path_merge_ordering(index->ordering,
- clauseinfo->mergejoinorder)))
+ restrictinfo->mergejoinorder)))
temp = false;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.10 1998/09/01 04:29:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.11 1999/02/03 20:15:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (_enable_mergejoin_)
{
mergeinfo_list =
- group_clauses_by_order(joinrel->clauseinfo,
+ group_clauses_by_order(joinrel->restrictinfo,
lfirsti(innerrel->relids));
}
if (_enable_hashjoin_)
{
hashinfo_list =
- group_clauses_by_hashop(joinrel->clauseinfo,
+ group_clauses_by_hashop(joinrel->restrictinfo,
lfirsti(innerrel->relids));
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.15 1998/09/01 04:29:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.16 1999/02/03 20:15:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
joinrel->classlist = NULL;
joinrel->relam = InvalidOid;
joinrel->ordering = NULL;
- joinrel->clauseinfo = NIL;
+ joinrel->restrictinfo = NIL;
joinrel->joininfo = NULL;
joinrel->innerjoin = NIL;
joinrel->superrels = NIL;
if (joininfo)
{
- joinrel->clauseinfo = joininfo->jinfoclauseinfo;
+ joinrel->restrictinfo = joininfo->jinfo_restrictinfo;
if (BushyPlanFlag)
joininfo->inactive = true;
}
current_joininfo_list);
if (other_joininfo)
{
- other_joininfo->jinfoclauseinfo =
- (List *) LispUnion(joininfo->jinfoclauseinfo,
- other_joininfo->jinfoclauseinfo);
+ other_joininfo->jinfo_restrictinfo =
+ (List *) LispUnion(joininfo->jinfo_restrictinfo,
+ other_joininfo->jinfo_restrictinfo);
}
else
{
other_joininfo = makeNode(JoinInfo);
- other_joininfo->otherrels =
- joininfo->otherrels;
- other_joininfo->jinfoclauseinfo =
- joininfo->jinfoclauseinfo;
- other_joininfo->mergejoinable =
- joininfo->mergejoinable;
- other_joininfo->hashjoinable =
- joininfo->hashjoinable;
+ other_joininfo->otherrels = joininfo->otherrels;
+ other_joininfo->jinfo_restrictinfo = joininfo->jinfo_restrictinfo;
+ other_joininfo->mergejoinable = joininfo->mergejoinable;
+ other_joininfo->hashjoinable = joininfo->hashjoinable;
other_joininfo->inactive = false;
current_joininfo_list = lcons(other_joininfo,
{
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
List *other_rels = joininfo->otherrels;
- List *clause_info = joininfo->jinfoclauseinfo;
+ List *restrict_info = joininfo->jinfo_restrictinfo;
bool mergejoinable = joininfo->mergejoinable;
bool hashjoinable = joininfo->hashjoinable;
JoinInfo *new_joininfo = makeNode(JoinInfo);
new_joininfo->otherrels = joinrel->relids;
- new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->jinfo_restrictinfo = restrict_info;
new_joininfo->mergejoinable = mergejoinable;
new_joininfo->hashjoinable = hashjoinable;
new_joininfo->inactive = false;
if (other_joininfo)
{
- other_joininfo->jinfoclauseinfo =
- (List *) LispUnion(clause_info,
- other_joininfo->jinfoclauseinfo);
+ other_joininfo->jinfo_restrictinfo =
+ (List *) LispUnion(restrict_info,
+ other_joininfo->jinfo_restrictinfo);
}
else
{
JoinInfo *new_joininfo = makeNode(JoinInfo);
new_joininfo->otherrels = new_relids;
- new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->jinfo_restrictinfo = restrict_info;
new_joininfo->mergejoinable = mergejoinable;
new_joininfo->hashjoinable = hashjoinable;
new_joininfo->inactive = false;
}
else
{
- selec = product_selec(jinfo->jinfoclauseinfo);
+ selec = product_selec(jinfo->jinfo_restrictinfo);
/* ntuples = Min(outer_rel->tuples,inner_rel->tuples) * selec; */
ntuples = outer_rel->tuples * inner_rel->tuples * selec;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.9 1998/09/01 04:29:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.10 1999/02/03 20:15:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* group-clauses-by-order--
- * If a join clause node in 'clauseinfo-list' is mergejoinable, store
+ * If a join clause node in 'restrictinfo-list' is mergejoinable, store
* it within a mergeinfo node containing other clause nodes with the same
* mergejoin ordering.
*
- * 'clauseinfo-list' is the list of clauseinfo nodes
+ * 'restrictinfo-list' is the list of restrictinfo nodes
* 'inner-relid' is the relid of the inner join relation
*
* Returns the new list of mergeinfo nodes.
*
*/
List *
-group_clauses_by_order(List *clauseinfo_list,
+group_clauses_by_order(List *restrictinfo_list,
int inner_relid)
{
List *mergeinfo_list = NIL;
- List *xclauseinfo = NIL;
+ List *xrestrictinfo = NIL;
- foreach(xclauseinfo, clauseinfo_list)
+ foreach(xrestrictinfo, restrictinfo_list)
{
- ClauseInfo *clauseinfo = (ClauseInfo *) lfirst(xclauseinfo);
- MergeOrder *merge_ordering = clauseinfo->mergejoinorder;
+ RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(xrestrictinfo);
+ MergeOrder *merge_ordering = restrictinfo->mergejoinorder;
if (merge_ordering)
{
*/
PathOrder p_ordering;
MInfo *xmergeinfo;
- Expr *clause = clauseinfo->clause;
+ Expr *clause = restrictinfo->clause;
Var *leftop = get_leftop(clause);
Var *rightop = get_rightop(clause);
JoinKey *keys;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.12 1998/09/21 15:41:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.13 1999/02/03 20:15:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
#include "optimizer/clauses.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/paths.h"
#include "optimizer/cost.h"
#include "optimizer/plancat.h"
foreach(clist, clauses)
{
- ClauseInfo *clausenode = (ClauseInfo *) (lfirst(clist));
+ RestrictInfo *clausenode = (RestrictInfo *) (lfirst(clist));
/*
* Check to see if this clause is an 'or' clause, and, if so,
pathnode->path.path_cost = cost;
/*
- * copy clauseinfo list into path for expensive function
+ * copy restrictinfo list into path for expensive function
* processing -- JMH, 7/7/92
*/
- pathnode->path.locclauseinfo =
- set_difference(copyObject((Node *) rel->clauseinfo),
+ pathnode->path.loc_restrictinfo =
+ set_difference(copyObject((Node *) rel->restrictinfo),
lcons(clausenode, NIL));
#if 0 /* fix xfunc */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.13 1998/09/01 04:29:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.14 1999/02/03 20:15:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void xfunc_free_stream(Stream root);
static Stream xfunc_add_clauses(Stream current);
static void xfunc_setup_group(Stream node, Stream bottom);
-static Stream xfunc_streaminsert(ClauseInfo clauseinfo, Stream current,
+static Stream xfunc_streaminsert(RestrictInfo restrictinfo, Stream current,
int clausetype);
static int xfunc_num_relids(Stream node);
static StreamPtr xfunc_get_downjoin(Stream node);
set_downstream(laststream, (StreamPtr) newstream);
set_downstream(newstream, (StreamPtr) NULL);
set_pathptr(newstream, (pathPtr) pathnode);
- set_cinfo(newstream, (ClauseInfo) NULL);
+ set_cinfo(newstream, (RestrictInfo) NULL);
set_clausetype(newstream, XFUNC_UNKNOWN);
/* base case: we're at a leaf, call xfunc_series_llel */
static bool
xfunc_prdmig_pullup(Stream origstream, Stream pullme, JoinPath joinpath)
{
- ClauseInfo clauseinfo = get_cinfo(pullme);
+ RestrictInfo restrictinfo = get_cinfo(pullme);
bool progress = false;
Stream upjoin,
orignode,
/* find node in origstream that contains clause */
for (orignode = origstream;
orignode != (Stream) NULL
- && get_cinfo(orignode) != clauseinfo;
+ && get_cinfo(orignode) != restrictinfo;
orignode = (Stream) get_downstream(orignode))
/* empty body in for loop */ ;
if (!orignode)
whichchild = OUTER;
else
whichchild = INNER;
- clauseinfo = xfunc_pullup((Path) get_pathptr((Stream) get_downstream(upjoin)),
+ restrictinfo = xfunc_pullup((Path) get_pathptr((Stream) get_downstream(upjoin)),
(JoinPath) get_pathptr(upjoin),
- clauseinfo,
+ restrictinfo,
whichchild,
get_clausetype(orignode));
set_pathptr(pullme, get_pathptr(upjoin));
- /* pullme has been moved into locclauseinfo */
+ /* pullme has been moved into locrestrictinfo */
set_clausetype(pullme, XFUNC_LOCPRD);
/*
LispValue primjoin;
/* first add in the local clauses */
- foreach(temp, get_locclauseinfo((Path) get_pathptr(current)))
+ foreach(temp, get_loc_restrictinfo((Path) get_pathptr(current)))
{
topnode =
- xfunc_streaminsert((ClauseInfo) lfirst(temp), topnode,
+ xfunc_streaminsert((RestrictInfo) lfirst(temp), topnode,
XFUNC_LOCPRD);
}
if (IsA(get_pathptr(current), JoinPath))
{
primjoin = xfunc_primary_join((JoinPath) get_pathptr(current));
- foreach(temp, get_pathclauseinfo((JoinPath) get_pathptr(current)))
+ foreach(temp, get_pathrestrictinfo((JoinPath) get_pathptr(current)))
{
- if (!equal(get_clause((ClauseInfo) lfirst(temp)), primjoin))
+ if (!equal(get_clause((RestrictInfo) lfirst(temp)), primjoin))
topnode =
- xfunc_streaminsert((ClauseInfo) lfirst(temp), topnode,
+ xfunc_streaminsert((RestrictInfo) lfirst(temp), topnode,
XFUNC_JOINPRD);
}
}
** Return new node.
*/
static Stream
-xfunc_streaminsert(ClauseInfo clauseinfo,
+xfunc_streaminsert(RestrictInfo restrictinfo,
Stream current,
int clausetype) /* XFUNC_LOCPRD or XFUNC_JOINPRD */
{
set_upstream(current, (StreamPtr) newstream);
set_downstream(newstream, (StreamPtr) current);
set_pathptr(newstream, get_pathptr(current));
- set_cinfo(newstream, clauseinfo);
+ set_cinfo(newstream, restrictinfo);
set_clausetype(newstream, clausetype);
return newstream;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.22 1998/09/01 04:29:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.23 1999/02/03 20:15:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
xfunc_trypullup(RelOptInfo rel)
{
LispValue y; /* list ptr */
- ClauseInfo maxcinfo; /* The ClauseInfo to pull up, as
+ RestrictInfo maxcinfo; /* The RestrictInfo to pull up, as
* calculated by xfunc_shouldpull() */
JoinPath curpath; /* current path in list */
int progress; /* has progress been made this time
** xfunc_shouldpull --
** find clause with highest rank, and decide whether to pull it up
** from child to parent. Currently we only pullup secondary join clauses
- ** that are in the pathclauseinfo. Secondary hash and sort clauses are
+ ** that are in the pathrestrictinfo. Secondary hash and sort clauses are
** left where they are.
** If we find an expensive function but decide *not* to pull it up,
** we'd better set the unpruneable flag. -- JMH, 11/11/92
Path childpath,
JoinPath parentpath,
int whichchild,
- ClauseInfo * maxcinfopt) /* Out: pointer to clause
+ RestrictInfo * maxcinfopt) /* Out: pointer to clause
* to pullup */
{
LispValue clauselist,
tmplist; /* lists of clauses */
- ClauseInfo maxcinfo; /* clause to pullup */
+ RestrictInfo maxcinfo; /* clause to pullup */
LispValue primjoinclause /* primary join clause */
= xfunc_primary_join(parentpath);
Cost tmprank,
Cost joincost = 0; /* join cost + primjoinclause cost */
int retval = XFUNC_LOCPRD;
- clauselist = get_locclauseinfo(childpath);
+ clauselist = get_loc_restrictinfo(childpath);
if (clauselist != LispNil)
{
/* find local predicate with maximum rank */
for (tmplist = clauselist,
- maxcinfo = (ClauseInfo) lfirst(tmplist),
+ maxcinfo = (RestrictInfo) lfirst(tmplist),
maxrank = xfunc_rank(get_clause(maxcinfo));
tmplist != LispNil;
tmplist = lnext(tmplist))
{
- if ((tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
+ if ((tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
> maxrank)
{
- maxcinfo = (ClauseInfo) lfirst(tmplist);
+ maxcinfo = (RestrictInfo) lfirst(tmplist);
maxrank = tmprank;
}
}
* local predicate
*/
if (is_join(childpath) && xfunc_num_join_clauses((JoinPath) childpath) > 1)
- for (tmplist = get_pathclauseinfo((JoinPath) childpath);
+ for (tmplist = get_pathrestrictinfo((JoinPath) childpath);
tmplist != LispNil;
tmplist = lnext(tmplist))
{
if (tmplist != LispNil &&
- (tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
+ (tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
> maxrank)
{
- maxcinfo = (ClauseInfo) lfirst(tmplist);
+ maxcinfo = (RestrictInfo) lfirst(tmplist);
maxrank = tmprank;
retval = XFUNC_JOINPRD;
}
** in the query; it's merely a parent for the new childpath.
** We also have to fix up the path costs of the child and parent.
**
- ** Now returns a pointer to the new pulled-up ClauseInfo. -- JMH, 11/18/92
+ ** Now returns a pointer to the new pulled-up RestrictInfo. -- JMH, 11/18/92
*/
-ClauseInfo
+RestrictInfo
xfunc_pullup(Query *queryInfo,
Path childpath,
JoinPath parentpath,
- ClauseInfo cinfo, /* clause to pull up */
+ 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 */
{
RelOptInfo newrel;
Cost pulled_selec;
Cost cost;
- ClauseInfo newinfo;
+ RestrictInfo newinfo;
/* remove clause from childpath */
newkid = (Path) copyObject((Node) childpath);
if (clausetype == XFUNC_LOCPRD)
{
- set_locclauseinfo(newkid,
+ set_locrestrictinfo(newkid,
xfunc_LispRemove((LispValue) cinfo,
- (List) get_locclauseinfo(newkid)));
+ (List) get_loc_restrictinfo(newkid)));
}
else
{
- set_pathclauseinfo
+ set_pathrestrictinfo
((JoinPath) newkid,
xfunc_LispRemove((LispValue) cinfo,
- (List) get_pathclauseinfo((JoinPath) newkid)));
+ (List) get_pathrestrictinfo((JoinPath) newkid)));
}
/*
* * We copy the cinfo, since it may appear in other plans, and we're
* going * to munge it. -- JMH, 7/22/92
*/
- newinfo = (ClauseInfo) copyObject((Node) cinfo);
+ newinfo = (RestrictInfo) copyObject((Node) cinfo);
/*
* * Fix all vars in the clause * to point to the right varno and
xfunc_fixvars(get_clause(newinfo), newrel, whichchild);
/* add clause to parentpath, and fix up its cost. */
- set_locclauseinfo(parentpath,
+ set_locrestrictinfo(parentpath,
lispCons((LispValue) newinfo,
- (LispValue) get_locclauseinfo(parentpath)));
+ (LispValue) get_loc_restrictinfo(parentpath)));
/* put new childpath into the path tree */
if (whichchild == INNER)
set_innerjoinpath(parentpath, (pathPtr) newkid);
if (tuples)
{ /* not of cardinality 0 */
/* factor in the selectivity of all zero-cost clauses */
- foreach(cinfonode, get_clauseinfo(currel))
+ foreach(cinfonode, get_restrictinfo(currel))
{
- if (!xfunc_expense(queryInfo, get_clause((ClauseInfo) lfirst(cinfonode))))
+ if (!xfunc_expense(queryInfo, get_clause((RestrictInfo) lfirst(cinfonode))))
tuples *=
compute_clause_selec(queryInfo,
- get_clause((ClauseInfo) lfirst(cinfonode)),
+ get_clause((RestrictInfo) lfirst(cinfonode)),
LispNil);
}
LispValue
xfunc_primary_join(JoinPath pathnode)
{
- LispValue joinclauselist = get_pathclauseinfo(pathnode);
- ClauseInfo mincinfo;
+ LispValue joinclauselist = get_pathrestrictinfo(pathnode);
+ RestrictInfo mincinfo;
LispValue tmplist;
LispValue minclause = LispNil;
Cost minrank,
if (joinclauselist == LispNil)
return LispNil;
- for (tmplist = joinclauselist, mincinfo = (ClauseInfo) lfirst(joinclauselist),
- minrank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist)));
+ for (tmplist = joinclauselist, mincinfo = (RestrictInfo) lfirst(joinclauselist),
+ minrank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist)));
tmplist != LispNil;
tmplist = lnext(tmplist))
- if ((tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
+ if ((tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
< minrank)
{
minrank = tmprank;
- mincinfo = (ClauseInfo) lfirst(tmplist);
+ mincinfo = (RestrictInfo) lfirst(tmplist);
}
return (LispValue) get_clause(mincinfo);
}
* functions, we don't sort.
*/
if (XfuncMode != XFUNC_OFF)
- set_locclauseinfo(pathnode, lisp_qsort(get_locclauseinfo(pathnode),
+ set_locrestrictinfo(pathnode, lisp_qsort(get_loc_restrictinfo(pathnode),
xfunc_cinfo_compare));
- for (tmplist = get_locclauseinfo(pathnode), selec = 1.0;
+ for (tmplist = get_loc_restrictinfo(pathnode), selec = 1.0;
tmplist != LispNil;
tmplist = lnext(tmplist))
{
- cost += (Cost) (xfunc_local_expense(get_clause((ClauseInfo) lfirst(tmplist)))
+ cost += (Cost) (xfunc_local_expense(get_clause((RestrictInfo) lfirst(tmplist)))
* (Cost) get_tuples(get_parent(pathnode)) * selec);
selec *= compute_clause_selec(queryInfo,
- get_clause((ClauseInfo) lfirst(tmplist)),
+ get_clause((RestrictInfo) lfirst(tmplist)),
LispNil);
}
if (IsA(pathnode, JoinPath))
{
if (XfuncMode != XFUNC_OFF)
- set_pathclauseinfo((JoinPath) pathnode, lisp_qsort
- (get_pathclauseinfo((JoinPath) pathnode),
+ set_pathrestrictinfo((JoinPath) pathnode, lisp_qsort
+ (get_pathrestrictinfo((JoinPath) pathnode),
xfunc_cinfo_compare));
- for (tmplist = get_pathclauseinfo((JoinPath) pathnode), selec = 1.0;
+ for (tmplist = get_pathrestrictinfo((JoinPath) pathnode), selec = 1.0;
tmplist != LispNil;
tmplist = lnext(tmplist))
{
- cost += (Cost) (xfunc_local_expense(get_clause((ClauseInfo) lfirst(tmplist)))
+ cost += (Cost) (xfunc_local_expense(get_clause((RestrictInfo) lfirst(tmplist)))
* (Cost) get_tuples(get_parent(pathnode)) * selec);
selec *= compute_clause_selec(queryInfo,
- get_clause((ClauseInfo) lfirst(tmplist)),
+ get_clause((RestrictInfo) lfirst(tmplist)),
LispNil);
}
}
/*
- ** Comparison function for lisp_qsort() on a list of ClauseInfo's.
- ** arg1 and arg2 should really be of type (ClauseInfo *).
+ ** Comparison function for lisp_qsort() on a list of RestrictInfo's.
+ ** arg1 and arg2 should really be of type (RestrictInfo *).
*/
int
xfunc_cinfo_compare(void *arg1, void *arg2)
{
- ClauseInfo info1 = *(ClauseInfo *) arg1;
- ClauseInfo info2 = *(ClauseInfo *) arg2;
+ RestrictInfo info1 = *(RestrictInfo *) arg1;
+ RestrictInfo info2 = *(RestrictInfo *) arg2;
LispValue clause1 = (LispValue) get_clause(info1),
clause2 = (LispValue) get_clause(info2);
int
xfunc_num_join_clauses(JoinPath path)
{
- int num = length(get_pathclauseinfo(path));
+ int num = length(get_pathrestrictinfo(path));
if (IsA(path, MergePath))
return num + length(get_path_mergeclauses((MergePath) path));
Node_Copy(from, newnode, alloc, indexkeys);
Node_Copy(from, newnode, alloc, ordering);
#endif
- Node_Copy(from, newnode, alloc, clauseinfo);
+ Node_Copy(from, newnode, alloc, restrictinfo);
Node_Copy(from, newnode, alloc, joininfo);
Node_Copy(from, newnode, alloc, innerjoin);
Node_Copy(from, newnode, alloc, superrels);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.34 1998/12/04 15:34:05 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.35 1999/02/03 20:15:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/palloc.h"
#include "utils/builtins.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/clauses.h"
#include "optimizer/planmain.h"
#include "optimizer/tlist.h"
* xfunc_trypullup(), we get the relevant clauses from the path
* itself, not its parent relation. --- JMH, 6/15/92
*/
- scan_clauses = fix_opids(get_actual_clauses(best_path->locclauseinfo));
+ scan_clauses = fix_opids(get_actual_clauses(best_path->loc_restrictinfo));
switch (best_path->pathtype)
{
inner_node = create_plan((Path *) best_path->innerjoinpath);
inner_tlist = inner_node->targetlist;
- clauses = get_actual_clauses(best_path->pathclauseinfo);
+ clauses = get_actual_clauses(best_path->pathinfo);
switch (best_path->path.pathtype)
{
* into this path node. Put them in the qpqual of the plan node. * --
* JMH, 6/15/92
*/
- if (get_locclauseinfo(best_path) != NIL)
+ if (get_loc_restrictinfo(best_path) != NIL)
set_qpqual((Plan) retval,
nconc(get_qpqual((Plan) retval),
fix_opids(get_actual_clauses
- (get_locclauseinfo(best_path)))));
+ (get_loc_restrictinfo(best_path)))));
#endif
return retval;
if (new_subclauses)
{
return (Node *)
- make_clause(expr->opType, expr->oper, new_subclauses);
+ make_clause(expr->opType, expr->oper, new_subclauses);
}
else
return clause;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.20 1998/09/01 04:29:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.21 1999/02/03 20:15:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int Quiet;
static void add_clause_to_rels(Query *root, List *clause);
-static void add_join_info_to_rels(Query *root, ClauseInfo * clauseinfo,
+static void add_join_info_to_rels(Query *root, RestrictInfo * restrictinfo,
List *join_relids);
static void add_vars_to_targetlist(Query *root, List *vars, List *join_relids);
/*
* init-base-rels-qual--
- * Initializes ClauseInfo and JoinInfo fields of relation entries for all
+ * Initializes RestrictInfo and JoinInfo fields of relation entries for all
* relations appearing within clauses. Creates new relation entries if
* necessary, adding them to *query-relation-list*.
*
/*
* add-clause-to-rels--
- * Add clause information to either the 'ClauseInfo' or 'JoinInfo' field
+ * Add clause information to either the 'RestrictInfo' or 'JoinInfo' field
* of a relation entry(depending on whether or not the clause is a join)
- * by creating a new ClauseInfo node and setting appropriate fields
+ * by creating a new RestrictInfo node and setting appropriate fields
* within the nodes.
*
* Returns nothing of interest.
{
List *relids;
List *vars;
- ClauseInfo *clauseinfo = makeNode(ClauseInfo);
+ RestrictInfo *restrictinfo = makeNode(RestrictInfo);
/*
* Retrieve all relids and vars contained within the clause.
*/
clause_get_relids_vars((Node *) clause, &relids, &vars);
- clauseinfo->clause = (Expr *) clause;
- clauseinfo->notclause = contains_not((Node *) clause);
- clauseinfo->selectivity = 0;
- clauseinfo->indexids = NIL;
- clauseinfo->mergejoinorder = (MergeOrder *) NULL;
- clauseinfo->hashjoinoperator = (Oid) 0;
+ restrictinfo->clause = (Expr *) clause;
+ restrictinfo->notclause = contains_not((Node *) clause);
+ restrictinfo->selectivity = 0;
+ restrictinfo->indexids = NIL;
+ restrictinfo->mergejoinorder = (MergeOrder *) NULL;
+ restrictinfo->hashjoinoperator = (Oid) 0;
if (length(relids) == 1)
{
* XXX If we have a func clause set selectivity to 1/3, really
* need a true selectivity function.
*/
- clauseinfo->selectivity = (Cost) 0.3333333;
+ restrictinfo->selectivity = (Cost) 0.3333333;
}
else
{
- clauseinfo->selectivity =
+ restrictinfo->selectivity =
compute_clause_selec(root, (Node *) clause, NIL);
}
- rel->clauseinfo = lcons(clauseinfo, rel->clauseinfo);
+ rel->restrictinfo = lcons(restrictinfo, rel->restrictinfo);
}
else
{
* XXX If we have a func clause set selectivity to 1/3, really
* need a true selectivity function.
*/
- clauseinfo->selectivity = (Cost) 0.3333333;
+ restrictinfo->selectivity = (Cost) 0.3333333;
}
else
{
- clauseinfo->selectivity =
+ restrictinfo->selectivity =
compute_clause_selec(root, (Node *) clause, NIL);
}
- add_join_info_to_rels(root, clauseinfo, relids);
+ add_join_info_to_rels(root, restrictinfo, relids);
/* we are going to be doing a join, so add var to targetlist */
add_vars_to_targetlist(root, vars, relids);
}
/*
* add-join-info-to-rels--
- * For every relation participating in a join clause, add 'clauseinfo' to
+ * For every relation participating in a join clause, add 'restrictinfo' to
* the appropriate joininfo node(creating a new one and adding it to the
* appropriate rel node if necessary).
*
- * 'clauseinfo' describes the join clause
+ * 'restrictinfo' describes the join clause
* 'join-relids' is the list of relations participating in the join clause
*
* Returns nothing.
*
*/
static void
-add_join_info_to_rels(Query *root, ClauseInfo * clauseinfo, List *join_relids)
+add_join_info_to_rels(Query *root, RestrictInfo * restrictinfo, List *join_relids)
{
List *join_relid;
joininfo = find_joininfo_node(get_base_rel(root, lfirsti(join_relid)),
other_rels);
- joininfo->jinfoclauseinfo =
- lcons(copyObject((void *) clauseinfo), joininfo->jinfoclauseinfo);
+ joininfo->jinfo_restrictinfo =
+ lcons(copyObject((void *) restrictinfo), joininfo->jinfo_restrictinfo);
}
}
* init-join-info--
* Set the MergeJoinable or HashJoinable field for every joininfo node
* (within a rel node) and the MergeJoinOrder or HashJoinOp field for
- * each clauseinfo node(within a joininfo node) for all relations in a
+ * each restrictinfo node(within a joininfo node) for all relations in a
* query.
*
* Returns nothing.
*z;
RelOptInfo *rel;
JoinInfo *joininfo;
- ClauseInfo *clauseinfo;
+ RestrictInfo *restrictinfo;
Expr *clause;
foreach(x, rel_list)
foreach(y, rel->joininfo)
{
joininfo = (JoinInfo *) lfirst(y);
- foreach(z, joininfo->jinfoclauseinfo)
+ foreach(z, joininfo->jinfo_restrictinfo)
{
- clauseinfo = (ClauseInfo *) lfirst(z);
- clause = clauseinfo->clause;
+ restrictinfo = (RestrictInfo *) lfirst(z);
+ clause = restrictinfo->clause;
if (is_joinable((Node *) clause))
{
MergeOrder *sortop = (MergeOrder *) NULL;
if (sortop)
{
- clauseinfo->mergejoinorder = sortop;
+ restrictinfo->mergejoinorder = sortop;
joininfo->mergejoinable = true;
}
if (hashop)
{
- clauseinfo->hashjoinoperator = hashop;
+ restrictinfo->hashjoinoperator = hashop;
joininfo->hashjoinable = true;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.40 1999/02/03 19:31:24 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.41 1999/02/03 20:15:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* DATA STRUCTURE CREATION/MANIPULATION ROUTINES */
#include "nodes/relation.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/joininfo.h"
#include "optimizer/keys.h"
#include "optimizer/ordering.h"
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.35 1999/02/02 17:46:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.36 1999/02/03 20:15:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
#include "optimizer/clauses.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/keys.h"
#include "optimizer/planmain.h"
#include "optimizer/tlist.h"
/*-------------------------------------------------------------------------
*
- * clauseinfo.c--
- * ClauseInfo node manipulation routines.
+ * restrictinfo.c--
+ * RestrictInfo node manipulation routines.
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/clauseinfo.c,v 1.9 1998/09/01 04:30:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/clauseinfo.c,v 1.10 1999/02/03 20:15:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
#include "optimizer/clauses.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
/*
* valid-or-clause--
*
- * Returns t iff the clauseinfo node contains a 'normal' 'or' clause.
+ * Returns t iff the restrictinfo node contains a 'normal' 'or' clause.
*
*/
bool
-valid_or_clause(ClauseInfo * clauseinfo)
+valid_or_clause(RestrictInfo * restrictinfo)
{
- if (clauseinfo != NULL &&
- !single_node((Node *) clauseinfo->clause) &&
- !clauseinfo->notclause &&
- or_clause((Node *) clauseinfo->clause))
+ if (restrictinfo != NULL &&
+ !single_node((Node *) restrictinfo->clause) &&
+ !restrictinfo->notclause &&
+ or_clause((Node *) restrictinfo->clause))
return true;
else
return false;
/*
* get-actual-clauses--
*
- * Returns a list containing the clauses from 'clauseinfo-list'.
+ * Returns a list containing the clauses from 'restrictinfo-list'.
*
*/
List *
-get_actual_clauses(List *clauseinfo_list)
+get_actual_clauses(List *restrictinfo_list)
{
List *temp = NIL;
List *result = NIL;
- ClauseInfo *clause = (ClauseInfo *) NULL;
+ RestrictInfo *clause = (RestrictInfo *) NULL;
- foreach(temp, clauseinfo_list)
+ foreach(temp, restrictinfo_list)
{
- clause = (ClauseInfo *) lfirst(temp);
+ clause = (RestrictInfo *) lfirst(temp);
result = lappend(result, clause->clause);
}
return result;
/*
* get_relattvals--
- * For each member of a list of clauseinfo nodes to be used with an
+ * For each member of a list of restrictinfo nodes to be used with an
* index, create a vectori-long specifying:
* the attnos,
* the values of the clause constants, and
* flag indicating whether the constant is on the left or right should
* always be *SELEC-CONSTANT-RIGHT*.
*
- * 'clauseinfo-list' is a list of clauseinfo nodes
+ * 'restrictinfo-list' is a list of restrictinfo nodes
*
* Returns a list of vectori-longs.
*
*/
void
-get_relattvals(List *clauseinfo_list,
+get_relattvals(List *restrictinfo_list,
List **attnos,
List **values,
List **flags)
List *result1 = NIL;
List *result2 = NIL;
List *result3 = NIL;
- ClauseInfo *temp = (ClauseInfo *) NULL;
+ RestrictInfo *temp = (RestrictInfo *) NULL;
List *i = NIL;
- foreach(i, clauseinfo_list)
+ foreach(i, restrictinfo_list)
{
int dummy;
AttrNumber attno;
Datum constval;
int flag;
- temp = (ClauseInfo *) lfirst(i);
+ temp = (RestrictInfo *) lfirst(i);
get_relattval((Node *) temp->clause, &dummy, &attno, &constval, &flag);
result1 = lappendi(result1, (int) attno);
result2 = lappendi(result2, constval);
/*
* get_joinvars --
- * Given a list of join clauseinfo nodes to be used with the index
+ * Given a list of join restrictinfo nodes to be used with the index
* of an inner join relation, return three lists consisting of:
* the attributes corresponding to the inner join relation
* the value of the inner var clause (always "")
* the operator.
*
* 'relid' is the inner join relation
- * 'clauseinfo-list' is a list of qualification clauses to be used with
+ * 'restrictinfo-list' is a list of qualification clauses to be used with
* 'rel'
*
*/
void
get_joinvars(Oid relid,
- List *clauseinfo_list,
+ List *restrictinfo_list,
List **attnos,
List **values,
List **flags)
List *result3 = NIL;
List *temp;
- foreach(temp, clauseinfo_list)
+ foreach(temp, restrictinfo_list)
{
- ClauseInfo *clauseinfo = lfirst(temp);
- Expr *clause = clauseinfo->clause;
+ RestrictInfo *restrictinfo = lfirst(temp);
+ Expr *clause = restrictinfo->clause;
if (IsA(get_leftop(clause), Var) &&
(relid == (get_leftop(clause))->varno))
/*
* get_opnos--
* Create and return a list containing the clause operators of each member
- * of a list of clauseinfo nodes to be used with an index.
+ * of a list of restrictinfo nodes to be used with an index.
*
*/
List *
-get_opnos(List *clauseinfo_list)
+get_opnos(List *restrictinfo_list)
{
- ClauseInfo *temp = (ClauseInfo *) NULL;
+ RestrictInfo *temp = (RestrictInfo *) NULL;
List *result = NIL;
List *i = NIL;
- foreach(i, clauseinfo_list)
+ foreach(i, restrictinfo_list)
{
- temp = (ClauseInfo *) lfirst(i);
+ temp = (RestrictInfo *) lfirst(i);
result =
lappendi(result,
(((Oper *) temp->clause->oper)->opno));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.10 1998/09/01 04:30:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.11 1999/02/03 20:15:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
indexnode->unorderedpath = NULL;
indexnode->cheapestpath = NULL;
indexnode->pruneable = true;
- indexnode->clauseinfo = NIL;
+ indexnode->restrictinfo = NIL;
indexnode->joininfo = NIL;
indexnode->innerjoin = NIL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.12 1998/09/01 04:30:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.13 1999/02/03 20:15:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
joininfo = makeNode(JoinInfo);
joininfo->otherrels = join_relids;
- joininfo->jinfoclauseinfo = NIL;
+ joininfo->jinfo_restrictinfo = NIL;
joininfo->mergejoinable = false;
joininfo->hashjoinable = false;
joininfo->inactive = false;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.14 1999/02/02 23:53:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.15 1999/02/03 20:15:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
#include "optimizer/pathnode.h"
-#include "optimizer/clauseinfo.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/plancat.h"
#include "optimizer/cost.h"
#include "optimizer/keys.h"
pathnode->keys = NIL;
/*
- * copy clauseinfo list into path for expensive function processing --
+ * copy restrictinfo list into path for expensive function processing --
* JMH, 7/7/92
*/
- pathnode->locclauseinfo =
- (List *) copyObject((Node *) rel->clauseinfo);
+ pathnode->loc_restrictinfo =
+ (List *) copyObject((Node *) rel->restrictinfo);
if (rel->relids != NULL)
relid = lfirsti(rel->relids);
pathnode->indexqual = NIL;
/*
- * copy clauseinfo list into path for expensive function processing --
+ * copy restrictinfo list into path for expensive function processing --
* JMH, 7/7/92
*/
- pathnode->path.locclauseinfo =
- set_difference((List *) copyObject((Node *) rel->clauseinfo),
+ pathnode->path.loc_restrictinfo =
+ set_difference((List *) copyObject((Node *) rel->restrictinfo),
(List *) restriction_clauses);
/*
pathnode->path.parent = joinrel;
pathnode->outerjoinpath = outer_path;
pathnode->innerjoinpath = inner_path;
- pathnode->pathclauseinfo = joinrel->clauseinfo;
+ pathnode->pathinfo = joinrel->restrictinfo;
pathnode->path.keys = keys;
pathnode->path.joinid = NIL;
pathnode->path.outerjoincost = (Cost) 0.0;
- pathnode->path.locclauseinfo = NIL;
+ pathnode->path.loc_restrictinfo = NIL;
if (keys)
{
pathnode->jpath.path.parent = joinrel;
pathnode->jpath.outerjoinpath = outer_path;
pathnode->jpath.innerjoinpath = inner_path;
- pathnode->jpath.pathclauseinfo = joinrel->clauseinfo;
+ pathnode->jpath.pathinfo = joinrel->restrictinfo;
pathnode->jpath.path.keys = keys;
pathnode->jpath.path.p_ordering.ordtype = MERGE_ORDER;
pathnode->jpath.path.p_ordering.ord.merge = order;
pathnode->path_mergeclauses = mergeclauses;
- pathnode->jpath.path.locclauseinfo = NIL;
+ pathnode->jpath.path.loc_restrictinfo = NIL;
pathnode->outersortkeys = outersortkeys;
pathnode->innersortkeys = innersortkeys;
pathnode->jpath.path.path_cost =
pathnode->jpath.path.parent = joinrel;
pathnode->jpath.outerjoinpath = outer_path;
pathnode->jpath.innerjoinpath = inner_path;
- pathnode->jpath.pathclauseinfo = joinrel->clauseinfo;
- pathnode->jpath.path.locclauseinfo = NIL;
+ pathnode->jpath.pathinfo = joinrel->restrictinfo;
+ pathnode->jpath.path.loc_restrictinfo = NIL;
pathnode->jpath.path.keys = keys;
pathnode->jpath.path.p_ordering.ordtype = SORTOP_ORDER;
pathnode->jpath.path.p_ordering.ord.sortop = NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.9 1998/09/01 04:30:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.10 1999/02/03 20:15:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
rel->classlist = NULL;
rel->ordering = NULL;
rel->relam = InvalidOid;
- rel->clauseinfo = NIL;
+ rel->restrictinfo = NIL;
rel->joininfo = NIL;
rel->innerjoin = NIL;
rel->superrels = NIL;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.35 1999/01/24 00:28:33 momjian Exp $
+ * $Id: nodes.h,v 1.36 1999/02/03 20:15:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
T_OrderKey,
T_JoinKey,
T_MergeOrder,
- T_ClauseInfo,
+ T_RestrictInfo,
T_JoinMethod,
T_HInfo,
T_MInfo,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.11 1998/09/01 04:36:51 momjian Exp $
+ * $Id: relation.h,v 1.12 1999/02/03 20:15:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* * The presence of the remaining fields depends on the restrictions
* and joins which the relation participates in:
*
- * clauseinfo - List of ClauseInfo nodes, containing info about each
+ * restrictinfo - List of RestrictInfo nodes, containing info about each
* qualification clause in which this relation participates
* joininfo - List of JoinInfo nodes, containing info about each join
* clause in which this relation participates
/* used by various scans and joins: */
Oid *ordering; /* OID of operators in sort order */
- List *clauseinfo; /* restriction clauses */
+ List *restrictinfo; /* restriction clauses */
List *joininfo; /* join clauses */
List *innerjoin;
List *superrels;
List *keys;
Cost outerjoincost;
Relid joinid;
- List *locclauseinfo;
+ List *loc_restrictinfo;
} Path;
typedef struct IndexPath
typedef struct JoinPath
{
Path path;
- List *pathclauseinfo;
+ List *pathinfo;
Path *outerjoinpath;
Path *innerjoinpath;
} JoinPath;
* clause info
*******/
-typedef struct ClauseInfo
+typedef struct RestrictInfo
{
NodeTag type;
Expr *clause; /* should be an OP clause */
/* hashjoin only */
Oid hashjoinoperator;
Relid cinfojoinid;
-} ClauseInfo;
+} RestrictInfo;
typedef struct JoinMethod
{
{
NodeTag type;
List *otherrels;
- List *jinfoclauseinfo;
+ List *jinfo_restrictinfo;
bool mergejoinable;
bool hashjoinable;
bool inactive;
** pathptr -- pointer to the current path node
** cinfo -- if NULL, this stream node referes to the path node.
** Otherwise this is a pointer to the current clause.
-** clausetype -- whether cinfo is in locclauseinfo or pathclauseinfo in the
+** clausetype -- whether cinfo is in loc_restrictinfo or pathinfo in the
** path node
** upstream -- linked list pointer upwards
** downstream -- ditto, downwards
{
NodeTag type;
Path *pathptr;
- ClauseInfo *cinfo;
+ RestrictInfo *cinfo;
int *clausetype;
struct Stream *upstream;
struct Stream *downstream;
+++ /dev/null
-/*-------------------------------------------------------------------------
- *
- * clauseinfo.h--
- * prototypes for clauseinfo.c.
- *
- *
- * Copyright (c) 1994, Regents of the University of California
- *
- * $Id: clauseinfo.h,v 1.9 1998/09/01 04:36:52 momjian Exp $
- *
- *-------------------------------------------------------------------------
- */
-#ifndef CLAUSEINFO_H
-#define CLAUSEINFO_H
-
-#include "nodes/pg_list.h"
-#include "nodes/relation.h"
-
-extern bool valid_or_clause(ClauseInfo * clauseinfo);
-extern List *get_actual_clauses(List *clauseinfo_list);
-extern void get_relattvals(List *clauseinfo_list, List **attnos,
- List **values, List **flags);
-extern void get_joinvars(Oid relid, List *clauseinfo_list,
- List **attnos, List **values, List **flags);
-extern List *get_opnos(List *clauseinfo_list);
-
-#endif /* CLAUSEINFO_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: cost.h,v 1.11 1998/09/01 04:36:54 momjian Exp $
+ * $Id: cost.h,v 1.12 1999/02/03 20:15:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* prototypes for fuctions in clausesel.h--
* routines to compute clause selectivities
*/
-extern void set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity);
-extern Cost product_selec(List *clauseinfo_list);
+extern void set_clause_selectivities(List *restrictinfo_list, Cost new_selectivity);
+extern Cost product_selec(List *restrictinfo_list);
extern void set_rest_relselec(Query *root, List *rel_list);
-extern void set_rest_selec(Query *root, List *clauseinfo_list);
+extern void set_rest_selec(Query *root, List *restrictinfo_list);
extern Cost compute_clause_selec(Query *root,
Node *clause, List *or_selectivities);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: paths.h,v 1.10 1998/09/01 04:37:14 momjian Exp $
+ * $Id: paths.h,v 1.11 1999/02/03 20:15:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* routines to generate index paths
*/
extern List *find_index_paths(Query *root, RelOptInfo * rel, List *indices,
- List *clauseinfo_list,
+ List *restrictinfo_list,
List *joininfo_list);
/*
* hashutils.h
* routines to deal with hash keys and clauses
*/
-extern List *group_clauses_by_hashop(List *clauseinfo_list,
+extern List *group_clauses_by_hashop(List *restrictinfo_list,
int inner_relid);
/*
* mergeutils.h
* routines to deal with merge keys and clauses
*/
-extern List *group_clauses_by_order(List *clauseinfo_list,
+extern List *group_clauses_by_order(List *restrictinfo_list,
int inner_relid);
extern MInfo *match_order_mergeinfo(PathOrder *ordering,
List *mergeinfo_list);
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * restrictinfo.h--
+ * prototypes for restrictinfo.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: restrictinfo.h,v 1.1 1999/02/03 20:15:53 momjian Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RESTRICTINFO_H
+#define RESTRICTINFO_H
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+
+extern bool valid_or_clause(RestrictInfo * restrictinfo);
+extern List *get_actual_clauses(List *restrictinfo_list);
+extern void get_relattvals(List *restrictinfo_list, List **attnos,
+ List **values, List **flags);
+extern void get_joinvars(Oid relid, List *restrictinfo_list,
+ List **attnos, List **values, List **flags);
+extern List *get_opnos(List *restrictinfo_list);
+
+#endif /* RESTRICTINFO_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xfunc.h,v 1.10 1998/09/01 04:37:24 momjian Exp $
+ * $Id: xfunc.h,v 1.11 1999/02/03 20:15:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* function prototypes from planner/path/xfunc.c */
extern void xfunc_trypullup(RelOptInfo * rel);
extern int xfunc_shouldpull(Path *childpath, JoinPath *parentpath,
- int whichchild, ClauseInfo * maxcinfopt);
-extern ClauseInfo *xfunc_pullup(Path *childpath, JoinPath *parentpath, ClauseInfo * cinfo,
+ int whichchild, RestrictInfo * maxcinfopt);
+extern RestrictInfo *xfunc_pullup(Path *childpath, JoinPath *parentpath, RestrictInfo * cinfo,
int whichchild, int clausetype);
extern Cost xfunc_rank(Expr *clause);
extern Cost xfunc_expense(Query *queryInfo, Expr *clause);
projects / postgresql / commitdiff