*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.72 1999/02/15 05:21:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.73 1999/02/18 00:49:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Node_Copy(from, newnode, restrictinfo);
Node_Copy(from, newnode, joininfo);
Node_Copy(from, newnode, innerjoin);
- Node_Copy(from, newnode, superrels);
return newnode;
}
* copy remainder of node
* ----------------
*/
- newnode->unjoined_rels = listCopy(from->unjoined_rels);
+ newnode->unjoined_relids = listCopy(from->unjoined_relids);
Node_Copy(from, newnode, jinfo_restrictinfo);
newnode->mergejoinable = from->mergejoinable;
newnode->hashjoinable = from->hashjoinable;
- newnode->bushy_inactive = from->bushy_inactive;
return newnode;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.34 1999/02/15 05:21:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.35 1999/02/18 00:49:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Assert(IsA(a, JoinInfo));
Assert(IsA(b, JoinInfo));
- if (!equal(a->unjoined_rels, b->unjoined_rels))
+ if (!equal(a->unjoined_relids, b->unjoined_relids))
return false;
if (!equal(a->jinfo_restrictinfo, b->jinfo_restrictinfo))
return false;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.12 1999/02/15 05:21:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.13 1999/02/18 00:49:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
freeObject(node->restrictinfo);
freeObject(node->joininfo);
freeObject(node->innerjoin);
- freeObject(node->superrels);
pfree(node);
}
* free remainder of node
* ----------------
*/
- freeList(node->unjoined_rels);
+ freeList(node->unjoined_relids);
freeObject(node->jinfo_restrictinfo);
pfree(node);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.74 1999/02/15 05:21:02 momjian Exp $
+ * $Id: outfuncs.c,v 1.75 1999/02/18 00:49:14 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
appendStringInfo(str, "(");
foreach(l, list)
{
- appendStringInfo(str, " %d ", (int) lfirst(l));
+ appendStringInfo(str, " %d ", lfirsti(l));
}
appendStringInfo(str, ")");
}
static void
_outJoinInfo(StringInfo str, JoinInfo *node)
{
- appendStringInfo(str, " JINFO :unjoined_rels ");
- _outIntList(str, node->unjoined_rels);
+ appendStringInfo(str, " JINFO :unjoined_relids ");
+ _outIntList(str, node->unjoined_relids);
appendStringInfo(str, " :jinfo_restrictinfo ");
_outNode(str, node->jinfo_restrictinfo);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.58 1999/02/15 05:21:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.59 1999/02/18 00:49:15 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
local_node = makeNode(JoinInfo);
- token = lsptok(NULL, &length); /* get :unjoined_rels */
- local_node->unjoined_rels = toIntList(nodeRead(true)); /* now read it */
+ token = lsptok(NULL, &length); /* get :unjoined_relids */
+ local_node->unjoined_relids = toIntList(nodeRead(true)); /* now read it */
token = lsptok(NULL, &length); /* get :jinfo_restrictinfo */
local_node->jinfo_restrictinfo = nodeRead(true); /* now read it */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.28 1999/02/13 23:16:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/_deadcode/Attic/xfunc.c,v 1.1 1999/02/18 00:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* local funcs */
static int xfunc_card_unreferenced(Query *queryInfo,
- Expr *clause, Relid referenced);
+ Expr *clause, Relids referenced);
*/
}
else if (IsA(clause, Param))
{
- if (typeidTypeRelid(get_paramtype((Param) clause)))
+ if (typeidTypeRelids(get_paramtype((Param) clause)))
{
/* Param node returns a tuple. Find its width */
- rd = heap_open(typeidTypeRelid(get_paramtype((Param) clause)));
+ rd = heap_open(typeidTypeRelids(get_paramtype((Param) clause)));
retval = xfunc_tuple_width(rd);
heap_close(rd);
}
*/
static Count
xfunc_card_unreferenced(Query *queryInfo,
- LispValue clause, Relid referenced)
+ LispValue clause, Relids referenced)
{
- Relid unreferenced,
+ Relids unreferenced,
allrelids = LispNil;
LispValue temp;
** multiple together cardinalities of a list relations.
*/
Count
-xfunc_card_product(Query *queryInfo, Relid relids)
+xfunc_card_product(Query *queryInfo, Relids relids)
{
LispValue cinfonode;
LispValue temp;
proc = (Form_pg_proc) GETSTRUCT(tupl);
/* if function returns a tuple, get the width of that */
- if (typeidTypeRelid(proc->prorettype))
+ if (typeidTypeRelids(proc->prorettype))
{
- rd = heap_open(typeidTypeRelid(proc->prorettype));
+ rd = heap_open(typeidTypeRelids(proc->prorettype));
retval = xfunc_tuple_width(rd);
heap_close(rd);
goto exit;
Node_Copy(from, newnode, alloc, restrictinfo);
Node_Copy(from, newnode, alloc, joininfo);
Node_Copy(from, newnode, alloc, innerjoin);
- Node_Copy(from, newnode, alloc, superrels);
(*to) = newnode;
return true;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.40 1999/02/16 00:40:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.41 1999/02/18 00:49:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
merge_rels_with_same_relids(joined_rels);
+ root->join_rel_list = rels = joined_rels;
+
#if 0
/*
* * for each expensive predicate in each path in each distinct
rels_set_cheapest(joined_rels);
- if (BushyPlanFlag)
- {
- /*
- * In case of bushy trees if there is still a join between a
- * join relation and another relation, add a new joininfo that
- * involves the join relation to the joininfo list of the
- * other relation
- */
- add_rel_to_rel_joininfos(root, joined_rels, rels);
- }
-
foreach(x, joined_rels)
{
rel = (RelOptInfo *) lfirst(x);
#endif
}
- if (BushyPlanFlag)
- {
- /*
- * prune rels that have been completely incorporated into new
- * join rels
- */
- joined_rels = del_rels_all_bushy_inactive(rels);
-
- /*
- * merge join rels if then contain the same list of base rels
- */
- merge_rels_with_same_relids(joined_rels);
- }
- root->join_rel_list = rels = joined_rels;
}
Assert(BushyPlanFlag || length(rels) == 1);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.50 1999/02/15 05:50:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.51 1999/02/18 00:49:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
List *clauses = lfirst(clausegroups);
- ((RestrictInfo *) lfirst(clauses))->restrictinfojoinid = joininfo->unjoined_rels;
+ ((RestrictInfo *) lfirst(clauses))->restrictinfojoinid = joininfo->unjoined_relids;
}
cg_list = nconc(cg_list, clausegroups);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.27 1999/02/15 03:22:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.28 1999/02/18 00:49:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
foreach(j, joinrels)
{
RelOptInfo *joinrel = (RelOptInfo *) lfirst(j);
- List *innerrelids;
- List *outerrelids;
+ Relids innerrelids;
+ Relids outerrelids;
RelOptInfo *innerrel;
RelOptInfo *outerrel;
Path *bestinnerjoin;
* Returns the pathnode of the selected path.
*/
static Path *
-best_innerjoin(List *join_paths, List *outer_relids)
+best_innerjoin(List *join_paths, Relids outer_relids)
{
Path *cheapest = (Path *) NULL;
List *join_path;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.26 1999/02/16 00:41:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.27 1999/02/18 00:49:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
-static List *new_joininfo_list(List *joininfo_list, List *join_relids);
-static void add_superrels(RelOptInfo *rel, RelOptInfo *super_rel);
-static bool nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2);
+static List *new_joininfo_list(List *joininfo_list, Relids join_relids);
static bool nonoverlap_sets(List *s1, List *s2);
-static void set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel,
- JoinInfo *jinfo);
+static bool is_subset(List *s1, List *s2);
+static void set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel, JoinInfo *jinfo);
/*
* make_rels_by_joins
*/
List *
make_rels_by_clause_joins(Query *root, RelOptInfo *outer_rel,
- List *joininfo_list, List *only_relids)
+ List *joininfo_list, Relids only_relids)
{
List *join_list = NIL;
List *i = NIL;
foreach(i, joininfo_list)
- {
+ {
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
RelOptInfo *rel;
+ Relids unjoined_relids = joininfo->unjoined_relids;
- if (!joininfo->bushy_inactive)
+ if (unjoined_relids != NIL)
{
- List *unjoined_rels = joininfo->unjoined_rels;
-
- if (unjoined_rels != NIL)
+ if (length(unjoined_relids) == 1 &&
+ (only_relids == NIL ||
+ /* geqo only wants certain relids to make new rels */
+ intMember(lfirsti(unjoined_relids), only_relids)))
{
- if (length(unjoined_rels) == 1 &&
- (only_relids == NIL ||
- /* geqo only wants certain relids to make new rels */
- same(joininfo->unjoined_rels, only_relids)))
+ rel = make_join_rel(outer_rel,
+ get_base_rel(root, lfirsti(unjoined_relids)),
+ joininfo);
+ join_list = lappend(join_list, rel);
+
+ /* Right-sided plan */
+ if (_use_right_sided_plans_ &&
+ length(outer_rel->relids) > 1)
{
- rel = make_join_rel(outer_rel,
- get_base_rel(root, lfirsti(unjoined_rels)),
+ rel = make_join_rel(
+ get_base_rel(root, lfirsti(unjoined_relids)),
+ outer_rel,
joininfo);
- /* how about right-sided plan ? */
- if (_use_right_sided_plans_ &&
- length(outer_rel->relids) > 1)
+ join_list = lappend(join_list, rel);
+ }
+ }
+
+ if (BushyPlanFlag && only_relids == NIL) /* no bushy from geqo */
+ {
+ List *r;
+
+ foreach(r, root->join_rel_list)
+ {
+ RelOptInfo *join_rel = lfirst(r);
+
+ Assert(length(join_rel->relids) > 1);
+ if (is_subset(unjoined_relids, join_rel->relids) &&
+ nonoverlap_sets(outer_rel->relids, join_rel->relids))
{
- if (rel != NULL)
+ rel = make_join_rel(outer_rel,
+ join_rel,
+ joininfo);
+ join_list = lappend(join_list, rel);
+
+ /* Right-sided plan */
+ if (_use_right_sided_plans_ &&
+ length(outer_rel->relids) > 1)
+ {
+ rel = make_join_rel(join_rel,
+ outer_rel,
+ joininfo);
join_list = lappend(join_list, rel);
- rel = make_join_rel(get_base_rel(root,
- lfirsti(unjoined_rels)),
- outer_rel,
- joininfo);
+ }
}
}
- else if (BushyPlanFlag)
- {
- rel = make_join_rel(outer_rel,
- get_join_rel(root, unjoined_rels),
- joininfo);
- }
- else
- rel = NULL;
-
- if (rel != NULL)
- join_list = lappend(join_list, rel);
}
}
}
foreach(i, inner_rels)
{
inner_rel = (RelOptInfo *) lfirst(i);
- if (nonoverlap_rels(inner_rel, outer_rel))
+ if (nonoverlap_sets(inner_rel->relids, outer_rel->relids))
{
t_list = lappend(t_list,
make_join_rel(outer_rel,
joinrel->restrictinfo = NIL;
joinrel->joininfo = NULL;
joinrel->innerjoin = NIL;
- joinrel->superrels = NIL;
/*
* This function uses a trick to pass inner/outer rels as
- * different lists, and then flattens it out later.
+ * different lists, and then flattens it out later. bjm
*/
joinrel->relids = lcons(outer_rel->relids, lcons(inner_rel->relids, NIL));
joinrel->targetlist = new_outer_tlist;
if (joininfo)
- {
joinrel->restrictinfo = joininfo->jinfo_restrictinfo;
- if (BushyPlanFlag)
- joininfo->bushy_inactive = true;
- }
- joinrel_joininfo_list = new_joininfo_list(append(outer_rel->joininfo, inner_rel->joininfo),
+ joinrel_joininfo_list = new_joininfo_list(append(outer_rel->joininfo,
+ inner_rel->joininfo),
intAppend(outer_rel->relids, inner_rel->relids));
joinrel->joininfo = joinrel_joininfo_list;
*/
List *
new_join_tlist(List *tlist,
- List *other_relids,
+ Relids other_relids,
int first_resdomno)
{
int resdomno = first_resdomno - 1;
if (in_final_tlist)
{
resdomno += 1;
- t_list = lappend(t_list,
- create_tl_element(get_expr(xtl), resdomno));
+ t_list = lappend(t_list,create_tl_element(get_expr(xtl), resdomno));
}
}
* Returns a list of joininfo nodes, new and old.
*/
static List *
-new_joininfo_list(List *joininfo_list, List *join_relids)
+new_joininfo_list(List *joininfo_list, Relids join_relids)
{
List *current_joininfo_list = NIL;
- List *new_unjoined_rels = NIL;
+ Relids new_unjoined_relids = NIL;
JoinInfo *other_joininfo = (JoinInfo *) NULL;
List *xjoininfo = NIL;
List *or;
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
- new_unjoined_rels = joininfo->unjoined_rels;
- foreach(or, new_unjoined_rels)
+ new_unjoined_relids = joininfo->unjoined_relids;
+ foreach(or, new_unjoined_relids)
{
if (intMember(lfirsti(or), join_relids))
- new_unjoined_rels = lremove((void *) lfirst(or), new_unjoined_rels);
+ new_unjoined_relids = lremove((void *) lfirst(or), new_unjoined_relids);
}
- joininfo->unjoined_rels = new_unjoined_rels;
- if (new_unjoined_rels != NIL)
+ joininfo->unjoined_relids = new_unjoined_relids;
+ if (new_unjoined_relids != NIL)
{
- other_joininfo = joininfo_member(new_unjoined_rels,
+ other_joininfo = joininfo_member(new_unjoined_relids,
current_joininfo_list);
if (other_joininfo)
{
- other_joininfo->jinfo_restrictinfo = (List *) LispUnion(joininfo->jinfo_restrictinfo,
- other_joininfo->jinfo_restrictinfo);
+ other_joininfo->jinfo_restrictinfo = (List *)
+ LispUnion(joininfo->jinfo_restrictinfo,
+ other_joininfo->jinfo_restrictinfo);
}
else
{
other_joininfo = makeNode(JoinInfo);
- other_joininfo->unjoined_rels = joininfo->unjoined_rels;
+ other_joininfo->unjoined_relids = joininfo->unjoined_relids;
other_joininfo->jinfo_restrictinfo = joininfo->jinfo_restrictinfo;
other_joininfo->mergejoinable = joininfo->mergejoinable;
other_joininfo->hashjoinable = joininfo->hashjoinable;
- other_joininfo->bushy_inactive = false;
current_joininfo_list = lcons(other_joininfo,
current_joininfo_list);
return current_joininfo_list;
}
-/*
- * add_rel_to_rel_joininfos
- * For each new join relation, create new joininfos that
- * use the join relation as inner relation, and add
- * the new joininfos to those rel nodes that still
- * have joins with the join relation.
- *
- * 'joinrels' is a list of join relations.
- *
- * Modifies the joininfo field of appropriate rel nodes.
- */
-void
-add_rel_to_rel_joininfos(Query *root, List *joinrels, List *outerrels)
-{
- List *xjoinrel = NIL;
- List *xrelid = NIL;
- List *xrel = NIL;
- List *xjoininfo = NIL;
-
- foreach(xjoinrel, joinrels)
- {
- RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
-
- foreach(xrelid, joinrel->relids)
- {
- Relid relid = (Relid) lfirst(xrelid);
- RelOptInfo *rel = get_join_rel(root, relid);
-
- add_superrels(rel, joinrel);
- }
- }
- foreach(xjoinrel, joinrels)
- {
- RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
-
- foreach(xjoininfo, joinrel->joininfo)
- {
- JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
- List *unjoined_rels = joininfo->unjoined_rels;
- List *restrict_info = joininfo->jinfo_restrictinfo;
- bool mergejoinable = joininfo->mergejoinable;
- bool hashjoinable = joininfo->hashjoinable;
-
- foreach(xrelid, unjoined_rels)
- {
- Relid relid = (Relid) lfirst(xrelid);
- RelOptInfo *rel = get_join_rel(root, relid);
- List *super_rels = rel->superrels;
- List *xsuper_rel = NIL;
- JoinInfo *new_joininfo = makeNode(JoinInfo);
-
- new_joininfo->unjoined_rels = joinrel->relids;
- new_joininfo->jinfo_restrictinfo = restrict_info;
- new_joininfo->mergejoinable = mergejoinable;
- new_joininfo->hashjoinable = hashjoinable;
- new_joininfo->bushy_inactive = false;
- rel->joininfo = lappend(rel->joininfo, new_joininfo);
-
- foreach(xsuper_rel, super_rels)
- {
- RelOptInfo *super_rel = (RelOptInfo *) lfirst(xsuper_rel);
-
- if (nonoverlap_rels(super_rel, joinrel))
- {
- List *new_relids = super_rel->relids;
- JoinInfo *other_joininfo = joininfo_member(new_relids,
- joinrel->joininfo);
-
- if (other_joininfo)
- {
- other_joininfo->jinfo_restrictinfo = (List *) LispUnion(restrict_info,
- other_joininfo->jinfo_restrictinfo);
- }
- else
- {
- JoinInfo *new_joininfo = makeNode(JoinInfo);
-
- new_joininfo->unjoined_rels = new_relids;
- new_joininfo->jinfo_restrictinfo = restrict_info;
- new_joininfo->mergejoinable = mergejoinable;
- new_joininfo->hashjoinable = hashjoinable;
- new_joininfo->bushy_inactive = false;
- joinrel->joininfo = lappend(joinrel->joininfo,
- new_joininfo);
- }
- }
- }
- }
- }
- }
-
- foreach(xrel, outerrels)
- {
- RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
-
- rel->superrels = NIL;
- }
-}
-
/*
* get_cheapest_complete_rel
* Find the join relation that includes all the original
RelOptInfo *final_rel = NULL;
/*
- * find the relations that has no further joins, i.e., its joininfos
- * all have unjoined_rels nil.
+ * find the relations that have no further joins, i.e., its joininfos
+ * all have unjoined_relids nil.
*/
foreach(xrel, join_rel_list)
{
{
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
- if (joininfo->unjoined_rels != NIL)
+ if (joininfo->unjoined_relids != NIL)
{
final = false;
break;
return final_rel;
}
-/*
- * add_superrels
- * add rel to the temporary property list superrels.
- *
- * 'rel' a rel node
- * 'super_rel' rel node of a join relation that includes rel
- *
- * Modifies the superrels field of rel
- */
-static void
-add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
-{
- rel->superrels = lappend(rel->superrels, super_rel);
-}
-
-/*
- * nonoverlap_rels
- * test if two join relations overlap, i.e., includes the same
- * relation.
- *
- * 'rel1' and 'rel2' are two join relations
- *
- * Returns non-nil if rel1 and rel2 do not overlap.
- */
static bool
-nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2)
+nonoverlap_sets(List *s1, List *s2)
{
- return nonoverlap_sets(rel1->relids, rel2->relids);
+ List *x = NIL;
+
+ foreach(x, s1)
+ {
+ int e = lfirsti(x);
+
+ if (intMember(e, s2))
+ return false;
+ }
+ return true;
}
static bool
-nonoverlap_sets(List *s1, List *s2)
+is_subset(List *s1, List *s2)
{
List *x = NIL;
{
int e = lfirsti(x);
- if (intMember(e, s2))
+ if (!intMember(e, s2))
return false;
}
return true;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.36 1999/02/16 00:41:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.37 1999/02/18 00:49:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/elog.h"
-static List *merge_rel_with_same_relids(RelOptInfo *rel, List *unjoined_rels);
+static List *merge_rel_with_same_relids(RelOptInfo *rel, Relids unjoined_relids);
/*
* merge_rels_with_same_relids
/*
* merge_rel_with_same_relids
- * Prunes those relations from 'unjoined_rels' that are redundant with
+ * Prunes those relations from 'unjoined_relids' that are redundant with
* 'rel'. A relation is redundant if it is built up of the same
* relations as 'rel'. Paths for the redundant relation are merged into
* the pathlist of 'rel'.
*
*/
static List *
-merge_rel_with_same_relids(RelOptInfo *rel, List *unjoined_rels)
+merge_rel_with_same_relids(RelOptInfo *rel, Relids unjoined_relids)
{
List *i = NIL;
List *result = NIL;
- foreach(i, unjoined_rels)
+ foreach(i, unjoined_relids)
{
RelOptInfo *unjoined_rel = (RelOptInfo *) lfirst(i);
elog(ERROR, "non JoinPath called");
}
}
-
-/*
- * del_rels_all_bushy_inactive
- * If all the joininfo's in a rel node are bushy_inactive,
- * that means that this node has been joined into
- * other nodes in all possible ways, therefore
- * this node can be discarded. If not, it will cause
- * extra complexity of the optimizer.
- *
- * old_rels is a list of rel nodes
- *
- * Returns a new list of rel nodes
- */
-List *
-del_rels_all_bushy_inactive(List *old_rels)
-{
- RelOptInfo *rel;
- List *joininfo_list,
- *xjoininfo,
- *i,
- *temp_list = NIL;
-
- foreach(i, old_rels)
- {
- rel = (RelOptInfo *) lfirst(i);
- joininfo_list = rel->joininfo;
-
- if (joininfo_list == NIL)
- temp_list = lcons(rel, temp_list);
- else
- {
- foreach(xjoininfo, joininfo_list)
- {
- JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
-
- if (!joininfo->bushy_inactive)
- {
- temp_list = lcons(rel, temp_list);
- break;
- }
- }
- }
- }
- return temp_list;
-}
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.27 1999/02/15 05:21:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.28 1999/02/18 00:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void add_restrict_and_join_to_rel(Query *root, List *clause);
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);
+ Relids join_relids);
+static void add_vars_to_targetlist(Query *root, List *vars, Relids join_relids);
static MergeOrder *mergejoinop(Expr *clause);
static Oid hashjoinop(Expr *clause);
foreach(l, root->rtable)
{
RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
- List *relids;
+ Relids relids;
RelOptInfo *result;
Var *var;
static void
add_restrict_and_join_to_rel(Query *root, List *clause)
{
- List *relids;
+ Relids relids;
List *vars;
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
* '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, RestrictInfo *restrictinfo, List *join_relids)
+add_join_info_to_rels(Query *root, RestrictInfo *restrictinfo,
+ Relids join_relids)
{
List *join_relid;
+ /* For every relid, find the rel, and add the proper join entries */
foreach(join_relid, join_relids)
{
JoinInfo *joininfo;
- List *unjoined_rels = NIL;
- List *rel;
+ Relids unjoined_relids = NIL;
+ List *rel;
+ /* Get the relids not equal to the current relid */
foreach(rel, join_relids)
{
if (lfirsti(rel) != lfirsti(join_relid))
- unjoined_rels = lappendi(unjoined_rels, lfirsti(rel));
+ unjoined_relids = lappendi(unjoined_relids, lfirsti(rel));
}
joininfo = find_joininfo_node(get_base_rel(root, lfirsti(join_relid)),
- unjoined_rels);
+ unjoined_relids);
joininfo->jinfo_restrictinfo = lcons(copyObject((void *) restrictinfo),
joininfo->jinfo_restrictinfo);
-
}
}
* Returns nothing.
*/
static void
-add_vars_to_targetlist(Query *root, List *vars, List *join_relids)
+add_vars_to_targetlist(Query *root, List *vars, Relids join_relids)
{
Var *var;
List *temp = NIL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.29 1999/02/13 23:16:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.30 1999/02/18 00:49:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/planner.h"
#include "optimizer/planmain.h"
-static List *plan_inherit_query(List *relids, Index rt_index,
+static List *plan_inherit_query(Relids relids, Index rt_index,
RangeTblEntry *rt_entry, Query *parse,
List **union_rtentriesPtr);
static RangeTblEntry *new_rangetable_entry(Oid new_relid,
* in union_rtentries.
*/
static List *
-plan_inherit_query(List *relids,
+plan_inherit_query(Relids relids,
Index rt_index,
RangeTblEntry *rt_entry,
Query *root,
* lists.
*/
List *
-find_all_inheritors(List *unexamined_relids,
- List *examined_relids)
+find_all_inheritors(Relids unexamined_relids,
+ Relids examined_relids)
{
List *new_inheritors = NIL;
List *new_examined_relids = NIL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.30 1999/02/14 22:24:25 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.31 1999/02/18 00:49:37 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*
*/
void
-clause_get_relids_vars(Node *clause, List **relids, List **vars)
+clause_get_relids_vars(Node *clause, Relids *relids, List **vars)
{
List *clvars = pull_var_clause(clause);
List *var_list = NIL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.17 1999/02/15 05:21:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.18 1999/02/18 00:49:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
JoinInfo *
joininfo_member(List *join_relids, List *joininfo_list)
{
- List *i = NIL;
- List *other_rels = NIL;
+ List *i;
foreach(i, joininfo_list)
{
- other_rels = lfirst(i);
- if (same(join_relids, ((JoinInfo *) other_rels)->unjoined_rels))
- return (JoinInfo *) other_rels;
+ JoinInfo *joininfo = (JoinInfo *)lfirst(i);
+
+ if (same(join_relids, joininfo->unjoined_relids))
+ return joininfo;
}
- return (JoinInfo *) NULL;
+ return NULL;
}
*
*/
JoinInfo *
-find_joininfo_node(RelOptInfo *this_rel, List *join_relids)
+find_joininfo_node(RelOptInfo *this_rel, Relids join_relids)
{
JoinInfo *joininfo = joininfo_member(join_relids,
this_rel->joininfo);
if (joininfo == NULL)
{
joininfo = makeNode(JoinInfo);
- joininfo->unjoined_rels = join_relids;
+ joininfo->unjoined_relids = join_relids;
joininfo->jinfo_restrictinfo = NIL;
joininfo->mergejoinable = false;
joininfo->hashjoinable = false;
- joininfo->bushy_inactive = false;
this_rel->joininfo = lcons(joininfo, this_rel->joininfo);
}
return joininfo;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.36 1999/02/15 03:22:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.37 1999/02/18 00:49:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
pathnode->jpath.path.pathorder->ordtype = SORTOP_ORDER;
pathnode->jpath.path.pathorder->ord.sortop = NULL;
pathnode->jpath.path.outerjoincost = (Cost) 0.0;
- pathnode->jpath.path.joinid = (Relid) NULL;
+ pathnode->jpath.path.joinid = (Relids) NULL;
/* pathnode->hashjoinoperator = operator; */
pathnode->path_hashclauses = hashclauses;
pathnode->outerhashkeys = outerkeys;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.14 1999/02/15 03:22:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.15 1999/02/18 00:49:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
RelOptInfo *
get_base_rel(Query *root, int relid)
{
- List *relids;
+ Relids relids;
RelOptInfo *rel;
relids = lconsi(relid, NIL);
rel->restrictinfo = NIL;
rel->joininfo = NIL;
rel->innerjoin = NIL;
- rel->superrels = NIL;
root->base_rel_list = lcons(rel, root->base_rel_list);
bool hasindex;
int pages,
tuples;
-
/*
* Otherwise, retrieve relation characteristics from the
* system catalogs.
/*
* get_join_rel
* Returns relation entry corresponding to 'relid' (a list of relids),
- * creating a new one if necessary. This is for join relations.
- *
+ * or NULL.
*/
RelOptInfo *
-get_join_rel(Query *root, List *relid)
+get_join_rel(Query *root, Relids relid)
{
return rel_member(relid, root->join_rel_list);
}
*
*/
RelOptInfo *
-rel_member(List *relid, List *rels)
+rel_member(Relids relids, List *rels)
{
List *temp = NIL;
List *temprelid = NIL;
- if (relid != NIL && rels != NIL)
+ if (relids != NIL && rels != NIL)
{
foreach(temp, rels)
{
temprelid = ((RelOptInfo *) lfirst(temp))->relids;
- if (same(temprelid, relid))
+ if (same(temprelid, relids))
return (RelOptInfo *) (lfirst(temp));
}
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.25 1999/02/15 05:21:12 momjian Exp $
+ * $Id: relation.h,v 1.26 1999/02/18 00:49:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include <nodes/primnodes.h>
/*
- * Relid
+ * Relids
* List of relation identifiers (indexes into the rangetable).
*/
-typedef List *Relid;
+typedef List *Relids;
/*
* RelOptInfo
NodeTag type;
/* all relations: */
- Relid relids;
+ Relids relids; /* integer list of base relids involved */
/* catalog statistics information */
bool indexed;
/* materialization information */
List *targetlist;
List *pathlist; /* Path structures */
- struct Path *cheapestpath;
+ struct Path *cheapestpath;
bool pruneable;
/* used solely by indices: */
List *restrictinfo; /* RestrictInfo structures */
List *joininfo; /* JoinInfo structures */
List *innerjoin;
- List *superrels;
} RelOptInfo;
extern Var *get_expr(TargetEntry *foo);
* indexes.
*/
Cost outerjoincost;
- Relid joinid;
+ Relids joinid;
List *loc_restrictinfo;
} Path;
/* hashjoin only */
Oid hashjoinoperator;
- Relid restrictinfojoinid;
+ Relids restrictinfojoinid;
} RestrictInfo;
typedef struct JoinMethod
typedef struct JoinInfo
{
NodeTag type;
- List *unjoined_rels;
+ Relids unjoined_relids;
List *jinfo_restrictinfo;
bool mergejoinable;
bool hashjoinable;
- bool bushy_inactive;
} JoinInfo;
typedef struct Iter
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauses.h,v 1.15 1999/02/13 23:21:42 momjian Exp $
+ * $Id: clauses.h,v 1.16 1999/02/18 00:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define CLAUSES_H
#include <nodes/primnodes.h>
+#include <nodes/relation.h>
extern Expr *make_clause(int type, Node *oper, List *args);
extern bool is_opclause(Node *clause);
extern bool case_clause(Node *clause);
extern List *pull_constant_clauses(List *quals, List **constantQual);
-extern void clause_get_relids_vars(Node *clause, List **relids, List **vars);
+extern void clause_get_relids_vars(Node *clause, Relids *relids, List **vars);
extern int NumRelids(Node *clause);
extern bool contains_not(Node *clause);
extern bool is_joinable(Node *clause);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pathnode.h,v 1.14 1999/02/13 23:21:49 momjian Exp $
+ * $Id: pathnode.h,v 1.15 1999/02/18 00:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for rel.c
*/
-extern RelOptInfo *rel_member(List *relid, List *rels);
+extern RelOptInfo *rel_member(Relids relid, List *rels);
extern RelOptInfo *get_base_rel(Query *root, int relid);
-extern RelOptInfo *get_join_rel(Query *root, List *relid);
+extern RelOptInfo *get_join_rel(Query *root, Relids relid);
/*
* prototypes for indexnode.h
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: paths.h,v 1.20 1999/02/16 00:41:03 momjian Exp $
+ * $Id: paths.h,v 1.21 1999/02/18 00:49:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* routines to determine which relations to join
*/
extern List *make_rels_by_joins(Query *root, List *outer_rels);
-extern void add_rel_to_rel_joininfos(Query *root, List *joinrels, List *outerrels);
extern List *make_rels_by_clause_joins(Query *root, RelOptInfo *outer_rel,
- List *joininfo_list, List *only_relids);
+ List *joininfo_list, Relids only_relids);
extern List *make_rels_by_clauseless_joins(RelOptInfo *outer_rel,
List *inner_rels);
extern RelOptInfo *make_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xfunc.h,v 1.15 1999/02/13 23:21:54 momjian Exp $
+ * $Id: xfunc.h,v 1.16 1999/02/18 00:49:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int xfunc_width(Expr *clause);
/* static, moved to xfunc.c */
-/* extern int xfunc_card_unreferenced(Expr *clause, Relid referenced); */
-extern int xfunc_card_product(Relid relids);
+/* extern int xfunc_card_unreferenced(Expr *clause, Relids referenced); */
+extern int xfunc_card_product(Relids relids);
extern List *xfunc_find_references(List *clause);
extern List *xfunc_primary_join(JoinPath *pathnode);
extern Cost xfunc_get_path_cost(Path *pathnode);
projects / postgresql / commitdiff