Fix bushy plans. Cleanup.
This commit is contained in:
Bruce Momjian
parent
c82ca4c158
commit
31cce21fb0
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -1066,7 +1066,6 @@ _copyRelOptInfo(RelOptInfo * from)
|
|||
Node_Copy(from, newnode, restrictinfo);
|
||||
Node_Copy(from, newnode, joininfo);
|
||||
Node_Copy(from, newnode, innerjoin);
|
||||
Node_Copy(from, newnode, superrels);
|
||||
|
||||
return newnode;
|
||||
}
|
||||
|
|
@ -1428,12 +1427,11 @@ _copyJoinInfo(JoinInfo *from)
|
|||
* 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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -526,7 +526,7 @@ _equalJoinInfo(JoinInfo *a, JoinInfo *b)
|
|||
{
|
||||
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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -740,7 +740,6 @@ _freeRelOptInfo(RelOptInfo *node)
|
|||
freeObject(node->restrictinfo);
|
||||
freeObject(node->joininfo);
|
||||
freeObject(node->innerjoin);
|
||||
freeObject(node->superrels);
|
||||
|
||||
pfree(node);
|
||||
}
|
||||
|
|
@ -1024,7 +1023,7 @@ _freeJoinInfo(JoinInfo *node)
|
|||
* free remainder of node
|
||||
* ----------------
|
||||
*/
|
||||
freeList(node->unjoined_rels);
|
||||
freeList(node->unjoined_relids);
|
||||
freeObject(node->jinfo_restrictinfo);
|
||||
|
||||
pfree(node);
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
*
|
||||
* 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
|
||||
|
|
@ -61,7 +61,7 @@ _outIntList(StringInfo str, List *list)
|
|||
appendStringInfo(str, "(");
|
||||
foreach(l, list)
|
||||
{
|
||||
appendStringInfo(str, " %d ", (int) lfirst(l));
|
||||
appendStringInfo(str, " %d ", lfirsti(l));
|
||||
}
|
||||
appendStringInfo(str, ")");
|
||||
}
|
||||
|
|
@ -1198,8 +1198,8 @@ _outHashInfo(StringInfo str, HashInfo *node)
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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
|
||||
|
|
@ -1982,8 +1982,8 @@ _readJoinInfo()
|
|||
|
||||
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 */
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -44,7 +44,7 @@
|
|||
|
||||
/* local funcs */
|
||||
static int xfunc_card_unreferenced(Query *queryInfo,
|
||||
Expr *clause, Relid referenced);
|
||||
Expr *clause, Relids referenced);
|
||||
|
||||
*/
|
||||
|
||||
|
|
@ -631,10 +631,10 @@ xfunc_width(LispValue clause)
|
|||
}
|
||||
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);
|
||||
}
|
||||
|
|
@ -724,9 +724,9 @@ exit:
|
|||
*/
|
||||
static Count
|
||||
xfunc_card_unreferenced(Query *queryInfo,
|
||||
LispValue clause, Relid referenced)
|
||||
LispValue clause, Relids referenced)
|
||||
{
|
||||
Relid unreferenced,
|
||||
Relids unreferenced,
|
||||
allrelids = LispNil;
|
||||
LispValue temp;
|
||||
|
||||
|
|
@ -751,7 +751,7 @@ xfunc_card_unreferenced(Query *queryInfo,
|
|||
** 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;
|
||||
|
|
@ -1310,9 +1310,9 @@ xfunc_func_width(RegProcedure funcid, LispValue args)
|
|||
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;
|
||||
|
|
@ -1478,7 +1478,6 @@ xfunc_copyrel(RelOptInfo from, RelOptInfo *to)
|
|||
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;
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -191,6 +191,8 @@ make_one_rel_by_joins(Query *root, List *rels, int levels_needed)
|
|||
|
||||
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
|
||||
|
|
@ -203,17 +205,6 @@ make_one_rel_by_joins(Query *root, List *rels, int levels_needed)
|
|||
|
||||
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);
|
||||
|
|
@ -228,20 +219,6 @@ make_one_rel_by_joins(Query *root, List *rels, int levels_needed)
|
|||
#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);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -1208,7 +1208,7 @@ indexable_joinclauses(RelOptInfo *rel, RelOptInfo *index,
|
|||
{
|
||||
List *clauses = lfirst(clausegroups);
|
||||
|
||||
((RestrictInfo *) lfirst(clauses))->restrictinfojoinid = joininfo->unjoined_rels;
|
||||
((RestrictInfo *) lfirst(clauses))->restrictinfojoinid = joininfo->unjoined_relids;
|
||||
}
|
||||
cg_list = nconc(cg_list, clausegroups);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -71,8 +71,8 @@ update_rels_pathlist_for_joins(Query *root, List *joinrels)
|
|||
foreach(j, joinrels)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(j);
|
||||
List *innerrelids;
|
||||
List *outerrelids;
|
||||
Relids innerrelids;
|
||||
Relids outerrelids;
|
||||
RelOptInfo *innerrel;
|
||||
RelOptInfo *outerrel;
|
||||
Path *bestinnerjoin;
|
||||
|
|
@ -163,7 +163,7 @@ update_rels_pathlist_for_joins(Query *root, List *joinrels)
|
|||
* 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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -31,12 +31,11 @@ bool _use_right_sided_plans_ = false;
|
|||
|
||||
#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
|
||||
|
|
@ -100,53 +99,69 @@ make_rels_by_joins(Query *root, List *outer_rels)
|
|||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -172,7 +187,7 @@ make_rels_by_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels)
|
|||
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,
|
||||
|
|
@ -229,11 +244,10 @@ make_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
|||
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));
|
||||
|
||||
|
|
@ -241,13 +255,10 @@ make_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
|||
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;
|
||||
|
|
@ -275,7 +286,7 @@ make_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
|||
*/
|
||||
List *
|
||||
new_join_tlist(List *tlist,
|
||||
List *other_relids,
|
||||
Relids other_relids,
|
||||
int first_resdomno)
|
||||
{
|
||||
int resdomno = first_resdomno - 1;
|
||||
|
|
@ -293,8 +304,7 @@ new_join_tlist(List *tlist,
|
|||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -320,10 +330,10 @@ new_join_tlist(List *tlist,
|
|||
* 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;
|
||||
|
||||
|
|
@ -332,31 +342,31 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
|||
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);
|
||||
|
|
@ -367,105 +377,6 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
|||
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
|
||||
|
|
@ -482,8 +393,8 @@ get_cheapest_complete_rel(List *join_rel_list)
|
|||
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)
|
||||
{
|
||||
|
|
@ -495,7 +406,7 @@ get_cheapest_complete_rel(List *join_rel_list)
|
|||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (joininfo->unjoined_rels != NIL)
|
||||
if (joininfo->unjoined_relids != NIL)
|
||||
{
|
||||
final = false;
|
||||
break;
|
||||
|
|
@ -510,36 +421,6 @@ get_cheapest_complete_rel(List *join_rel_list)
|
|||
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)
|
||||
{
|
||||
return nonoverlap_sets(rel1->relids, rel2->relids);
|
||||
}
|
||||
|
||||
static bool
|
||||
nonoverlap_sets(List *s1, List *s2)
|
||||
{
|
||||
|
|
@ -555,6 +436,21 @@ nonoverlap_sets(List *s1, List *s2)
|
|||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
is_subset(List *s1, List *s2)
|
||||
{
|
||||
List *x = NIL;
|
||||
|
||||
foreach(x, s1)
|
||||
{
|
||||
int e = lfirsti(x);
|
||||
|
||||
if (!intMember(e, s2))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static void
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *jinfo)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -24,7 +24,7 @@
|
|||
#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
|
||||
|
|
@ -49,7 +49,7 @@ merge_rels_with_same_relids(List *rel_list)
|
|||
|
||||
/*
|
||||
* 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'.
|
||||
|
|
@ -59,12 +59,12 @@ merge_rels_with_same_relids(List *rel_list)
|
|||
*
|
||||
*/
|
||||
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);
|
||||
|
||||
|
|
@ -105,49 +105,3 @@ rels_set_cheapest(List *rel_list)
|
|||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -41,8 +41,8 @@ extern int Quiet;
|
|||
|
||||
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);
|
||||
|
|
@ -107,7 +107,7 @@ add_missing_vars_to_tlist(Query *root, List *tlist)
|
|||
foreach(l, root->rtable)
|
||||
{
|
||||
RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
|
||||
List *relids;
|
||||
Relids relids;
|
||||
RelOptInfo *result;
|
||||
Var *var;
|
||||
|
||||
|
|
@ -165,7 +165,7 @@ add_restrict_and_join_to_rels(Query *root, List *clauses)
|
|||
static void
|
||||
add_restrict_and_join_to_rel(Query *root, List *clause)
|
||||
{
|
||||
List *relids;
|
||||
Relids relids;
|
||||
List *vars;
|
||||
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
|
||||
|
||||
|
|
@ -235,31 +235,31 @@ add_restrict_and_join_to_rel(Query *root, List *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, 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);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -279,7 +279,7 @@ add_join_info_to_rels(Query *root, RestrictInfo *restrictinfo, List *join_relids
|
|||
* 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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -34,7 +34,7 @@
|
|||
#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,
|
||||
|
|
@ -248,7 +248,7 @@ plan_inherit_queries(Query *parse, Index rt_index)
|
|||
* in union_rtentries.
|
||||
*/
|
||||
static List *
|
||||
plan_inherit_query(List *relids,
|
||||
plan_inherit_query(Relids relids,
|
||||
Index rt_index,
|
||||
RangeTblEntry *rt_entry,
|
||||
Query *root,
|
||||
|
|
@ -301,8 +301,8 @@ plan_inherit_query(List *relids,
|
|||
* 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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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
|
||||
|
|
@ -369,7 +369,7 @@ pull_constant_clauses(List *quals, List **constantQual)
|
|||
*
|
||||
*/
|
||||
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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -38,16 +38,16 @@
|
|||
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;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ joininfo_member(List *join_relids, List *joininfo_list)
|
|||
*
|
||||
*/
|
||||
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);
|
||||
|
|
@ -70,11 +70,10 @@ find_joininfo_node(RelOptInfo *this_rel, List *join_relids)
|
|||
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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -633,7 +633,7 @@ create_hashjoin_path(RelOptInfo *joinrel,
|
|||
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;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -30,7 +30,7 @@
|
|||
RelOptInfo *
|
||||
get_base_rel(Query *root, int relid)
|
||||
{
|
||||
List *relids;
|
||||
Relids relids;
|
||||
RelOptInfo *rel;
|
||||
|
||||
relids = lconsi(relid, NIL);
|
||||
|
|
@ -53,7 +53,6 @@ get_base_rel(Query *root, int relid)
|
|||
rel->restrictinfo = NIL;
|
||||
rel->joininfo = NIL;
|
||||
rel->innerjoin = NIL;
|
||||
rel->superrels = NIL;
|
||||
|
||||
root->base_rel_list = lcons(rel, root->base_rel_list);
|
||||
|
||||
|
|
@ -76,7 +75,6 @@ get_base_rel(Query *root, int relid)
|
|||
bool hasindex;
|
||||
int pages,
|
||||
tuples;
|
||||
|
||||
/*
|
||||
* Otherwise, retrieve relation characteristics from the
|
||||
* system catalogs.
|
||||
|
|
@ -93,11 +91,10 @@ get_base_rel(Query *root, int relid)
|
|||
/*
|
||||
* 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);
|
||||
}
|
||||
|
|
@ -111,17 +108,17 @@ get_join_rel(Query *root, List *relid)
|
|||
*
|
||||
*/
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -17,11 +17,11 @@
|
|||
#include <nodes/primnodes.h>
|
||||
|
||||
/*
|
||||
* Relid
|
||||
* Relids
|
||||
* List of relation identifiers (indexes into the rangetable).
|
||||
*/
|
||||
|
||||
typedef List *Relid;
|
||||
typedef List *Relids;
|
||||
|
||||
/*
|
||||
* RelOptInfo
|
||||
|
|
@ -72,7 +72,7 @@ typedef struct RelOptInfo
|
|||
NodeTag type;
|
||||
|
||||
/* all relations: */
|
||||
Relid relids;
|
||||
Relids relids; /* integer list of base relids involved */
|
||||
|
||||
/* catalog statistics information */
|
||||
bool indexed;
|
||||
|
|
@ -84,7 +84,7 @@ typedef struct RelOptInfo
|
|||
/* materialization information */
|
||||
List *targetlist;
|
||||
List *pathlist; /* Path structures */
|
||||
struct Path *cheapestpath;
|
||||
struct Path *cheapestpath;
|
||||
bool pruneable;
|
||||
|
||||
/* used solely by indices: */
|
||||
|
|
@ -100,7 +100,6 @@ typedef struct RelOptInfo
|
|||
List *restrictinfo; /* RestrictInfo structures */
|
||||
List *joininfo; /* JoinInfo structures */
|
||||
List *innerjoin;
|
||||
List *superrels;
|
||||
} RelOptInfo;
|
||||
|
||||
extern Var *get_expr(TargetEntry *foo);
|
||||
|
|
@ -148,7 +147,7 @@ typedef struct Path
|
|||
* indexes.
|
||||
*/
|
||||
Cost outerjoincost;
|
||||
Relid joinid;
|
||||
Relids joinid;
|
||||
List *loc_restrictinfo;
|
||||
} Path;
|
||||
|
||||
|
|
@ -221,7 +220,7 @@ typedef struct RestrictInfo
|
|||
|
||||
/* hashjoin only */
|
||||
Oid hashjoinoperator;
|
||||
Relid restrictinfojoinid;
|
||||
Relids restrictinfojoinid;
|
||||
} RestrictInfo;
|
||||
|
||||
typedef struct JoinMethod
|
||||
|
|
@ -246,11 +245,10 @@ typedef struct MergeInfo
|
|||
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
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -14,6 +14,7 @@
|
|||
#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);
|
||||
|
|
@ -37,7 +38,7 @@ extern Expr *make_andclause(List *andclauses);
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -42,9 +42,9 @@ extern HashPath *create_hashjoin_path(RelOptInfo *joinrel, int outersize,
|
|||
/*
|
||||
* 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
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -78,9 +78,8 @@ extern MergeInfo *match_order_mergeinfo(PathOrder *ordering,
|
|||
* 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);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* 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 $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -62,8 +62,8 @@ extern Cost xfunc_func_expense(Expr *node, List *args);
|
|||
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);
|
||||
|
|
|
|||
Loading…
Reference in New Issue