Final optimizer cleanups.
This commit is contained in:
Bruce Momjian
parent
47dd11bdd0
commit
1ed5cbbfd8
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.17 1999/02/13 23:15:57 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.18 1999/02/22 05:26:18 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* XXX a few of the following functions are duplicated to handle
|
||||
|
|
@ -109,6 +109,7 @@ nconc(List *l1, List *l2)
|
|||
}
|
||||
|
||||
|
||||
#ifdef NOT_USED
|
||||
List *
|
||||
nreverse(List *list)
|
||||
{
|
||||
|
|
@ -128,6 +129,7 @@ nreverse(List *list)
|
|||
lnext(list) = lnext(rlist);
|
||||
return list;
|
||||
}
|
||||
#endif
|
||||
|
||||
Value *
|
||||
makeInteger(long i)
|
||||
|
|
@ -245,6 +247,7 @@ append(List *l1, List *l2)
|
|||
return newlist;
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
/*
|
||||
* below are for backwards compatibility
|
||||
*/
|
||||
|
|
@ -266,6 +269,7 @@ intAppend(List *l1, List *l2)
|
|||
lnext(p) = newlist2;
|
||||
return newlist;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* same
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.43 1999/02/21 03:48:41 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.44 1999/02/22 05:26:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -126,7 +126,7 @@ set_base_rel_pathlist(Query *root, List *rels)
|
|||
|
||||
rel->pathlist = add_pathlist(rel,
|
||||
sequential_scan_list,
|
||||
append(rel_index_scan_list,
|
||||
nconc(rel_index_scan_list,
|
||||
or_index_scan_list));
|
||||
|
||||
set_cheapest(rel, rel->pathlist);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.13 1999/02/13 23:16:16 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.14 1999/02/22 05:26:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -83,9 +83,7 @@ group_clauses_by_hashop(List *restrictinfo_list,
|
|||
xhashinfo->jmethod.jmkeys = NIL;
|
||||
xhashinfo->jmethod.clauses = NIL;
|
||||
|
||||
/* XXX was push */
|
||||
hashinfo_list = lappend(hashinfo_list, xhashinfo);
|
||||
hashinfo_list = nreverse(hashinfo_list);
|
||||
hashinfo_list = lcons(xhashinfo, hashinfo_list);
|
||||
}
|
||||
|
||||
xhashinfo->jmethod.clauses = lcons(clause, xhashinfo->jmethod.clauses);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.52 1999/02/21 03:48:44 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.53 1999/02/22 05:26:19 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -1384,7 +1384,7 @@ create_index_path_group(Query *root,
|
|||
static List *
|
||||
add_index_paths(List *indexpaths, List *new_indexpaths)
|
||||
{
|
||||
return append(indexpaths, new_indexpaths);
|
||||
return nconc(indexpaths, new_indexpaths);
|
||||
}
|
||||
|
||||
static bool
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.31 1999/02/21 01:55:02 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.32 1999/02/22 05:26:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -104,7 +104,8 @@ update_rels_pathlist_for_joins(Query *root, List *joinrels)
|
|||
lfirsti(innerrel->relids));
|
||||
|
||||
/* need to flatten the relids list */
|
||||
joinrel->relids = intAppend(outerrelids, innerrelids);
|
||||
joinrel->relids = nconc(listCopy(outerrelids),
|
||||
listCopy(innerrelids));
|
||||
|
||||
/*
|
||||
* 1. Consider mergejoin paths where both relations must be
|
||||
|
|
@ -213,11 +214,11 @@ sort_inner_and_outer(RelOptInfo *joinrel,
|
|||
{
|
||||
xmergeinfo = (MergeInfo *) lfirst(i);
|
||||
|
||||
outerkeys = extract_path_keys(xmergeinfo->jmethod.jmkeys,
|
||||
outerkeys = make_pathkeys_from_joinkeys(xmergeinfo->jmethod.jmkeys,
|
||||
outerrel->targetlist,
|
||||
OUTER);
|
||||
|
||||
innerkeys = extract_path_keys(xmergeinfo->jmethod.jmkeys,
|
||||
innerkeys = make_pathkeys_from_joinkeys(xmergeinfo->jmethod.jmkeys,
|
||||
innerrel->targetlist,
|
||||
INNER);
|
||||
|
||||
|
|
@ -352,7 +353,7 @@ match_unsorted_outer(RelOptInfo *joinrel,
|
|||
innerrel->width, false))));
|
||||
if (!path_is_cheaper_than_sort)
|
||||
{
|
||||
varkeys = extract_path_keys(matchedJoinKeys,
|
||||
varkeys = make_pathkeys_from_joinkeys(matchedJoinKeys,
|
||||
innerrel->targetlist,
|
||||
INNER);
|
||||
}
|
||||
|
|
@ -473,7 +474,7 @@ match_unsorted_inner(RelOptInfo *joinrel,
|
|||
|
||||
if (temp2)
|
||||
{
|
||||
List *outerkeys = extract_path_keys(matchedJoinKeys,
|
||||
List *outerkeys = make_pathkeys_from_joinkeys(matchedJoinKeys,
|
||||
outerrel->targetlist,
|
||||
OUTER);
|
||||
List *merge_pathkeys = new_join_pathkeys(outerkeys,
|
||||
|
|
@ -551,10 +552,12 @@ hash_inner_and_outer(RelOptInfo *joinrel,
|
|||
foreach(i, hashinfo_list)
|
||||
{
|
||||
xhashinfo = (HashInfo *) lfirst(i);
|
||||
outerkeys = extract_path_keys(((JoinMethod *) xhashinfo)->jmkeys,
|
||||
outerkeys = make_pathkeys_from_joinkeys(
|
||||
((JoinMethod *) xhashinfo)->jmkeys,
|
||||
outerrel->targetlist,
|
||||
OUTER);
|
||||
innerkeys = extract_path_keys(((JoinMethod *) xhashinfo)->jmkeys,
|
||||
innerkeys = make_pathkeys_from_joinkeys(
|
||||
((JoinMethod *) xhashinfo)->jmkeys,
|
||||
innerrel->targetlist,
|
||||
INNER);
|
||||
hash_pathkeys = new_join_pathkeys(outerkeys,
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.30 1999/02/18 06:00:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.31 1999/02/22 05:26:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -62,7 +62,7 @@ make_rels_by_joins(Query *root, List *old_rels)
|
|||
joined_rels = make_rels_by_clauseless_joins(old_rel,
|
||||
root->base_rel_list);
|
||||
joined_rels = append(joined_rels,
|
||||
make_rels_by_clauseless_joins(old_rel,
|
||||
make_rels_by_clauseless_joins(old_rel,
|
||||
old_rels));
|
||||
}
|
||||
|
||||
|
|
@ -235,9 +235,11 @@ make_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
|||
if (joininfo)
|
||||
joinrel->restrictinfo = joininfo->jinfo_restrictinfo;
|
||||
|
||||
joinrel_joininfo_list = new_joininfo_list(append(outer_rel->joininfo,
|
||||
inner_rel->joininfo),
|
||||
intAppend(outer_rel->relids, inner_rel->relids));
|
||||
joinrel_joininfo_list = new_joininfo_list(
|
||||
append(outer_rel->joininfo,
|
||||
inner_rel->joininfo),
|
||||
nconc(listCopy(outer_rel->relids),
|
||||
listCopy(inner_rel->relids)));
|
||||
|
||||
joinrel->joininfo = joinrel_joininfo_list;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.6 1999/02/21 01:55:02 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.7 1999/02/22 05:26:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -27,9 +27,9 @@
|
|||
|
||||
static int match_pathkey_joinkeys(List *pathkey, List *joinkeys,
|
||||
int outer_or_inner);
|
||||
static List *new_join_pathkey(List *subkeys, List *considered_subkeys,
|
||||
List *join_rel_tlist, List *joinclauses);
|
||||
static List *new_matching_subkeys(Var *subkey, List *considered_subkeys,
|
||||
static List *new_join_pathkey(List *pathkeys, List *join_rel_tlist,
|
||||
List *joinclauses);
|
||||
static List *get_joinvars_for_var(Var *pathkey, List **considered_pathkeys,
|
||||
List *join_rel_tlist, List *joinclauses);
|
||||
|
||||
|
||||
|
|
@ -86,7 +86,7 @@ static List *new_matching_subkeys(Var *subkey, List *considered_subkeys,
|
|||
* ( (outer inner) (outer inner) ... )
|
||||
* 'joinclauses' is a list of clauses corresponding to the join keys in
|
||||
* 'joinkeys'
|
||||
* 'outer_or_inner' is a flag that selects the desired subkey of a join key
|
||||
* 'outer_or_inner' is a flag that selects the desired pathkey of a join key
|
||||
* in 'joinkeys'
|
||||
*
|
||||
* Returns the join keys and corresponding join clauses in a list if all
|
||||
|
|
@ -133,10 +133,11 @@ order_joinkeys_by_pathkeys(List *pathkeys,
|
|||
matched_joinkeys = lappend(matched_joinkeys, joinkey);
|
||||
}
|
||||
|
||||
if (matchedJoinClausesPtr && joinclauses)
|
||||
if (matchedJoinClausesPtr)
|
||||
{
|
||||
Expr *joinclause = nth(matched_joinkey_index,
|
||||
joinclauses);
|
||||
Assert(joinclauses);
|
||||
matched_joinclauses = lappend(matched_joinclauses, joinclause);
|
||||
}
|
||||
}
|
||||
|
|
@ -169,7 +170,7 @@ order_joinkeys_by_pathkeys(List *pathkeys,
|
|||
/*
|
||||
* match_pathkey_joinkeys
|
||||
* Returns the 0-based index into 'joinkeys' of the first joinkey whose
|
||||
* outer or inner subkey matches any subkey of 'pathkey'.
|
||||
* outer or inner pathkey matches any subkey of 'pathkey'.
|
||||
*
|
||||
* All these keys are equivalent, so any of them can match. See above.
|
||||
*/
|
||||
|
|
@ -178,19 +179,19 @@ match_pathkey_joinkeys(List *pathkey,
|
|||
List *joinkeys,
|
||||
int outer_or_inner)
|
||||
{
|
||||
Var *path_subkey;
|
||||
Var *key;
|
||||
int pos;
|
||||
List *i, *x;
|
||||
JoinKey *jk;
|
||||
|
||||
foreach(i, pathkey)
|
||||
{
|
||||
path_subkey = (Var *) lfirst(i);
|
||||
key = (Var *) lfirst(i);
|
||||
pos = 0;
|
||||
foreach(x, joinkeys)
|
||||
{
|
||||
jk = (JoinKey *) lfirst(x);
|
||||
if (var_equal(path_subkey, extract_join_key(jk, outer_or_inner)))
|
||||
if (equal(key, extract_join_key(jk, outer_or_inner)))
|
||||
return pos;
|
||||
pos++;
|
||||
}
|
||||
|
|
@ -204,9 +205,9 @@ match_pathkey_joinkeys(List *pathkey,
|
|||
* Attempts to find a path in 'paths' whose keys match a set of join
|
||||
* keys 'joinkeys'. To match,
|
||||
* 1. the path node ordering must equal 'ordering'.
|
||||
* 2. each subkey of a given path must match(i.e., be(var_equal) to) the
|
||||
* appropriate subkey of the corresponding join key in 'joinkeys',
|
||||
* i.e., the Nth path key must match its subkeys against the subkey of
|
||||
* 2. each pathkey of a given path must match(i.e., be(equal) to) the
|
||||
* appropriate pathkey of the corresponding join key in 'joinkeys',
|
||||
* i.e., the Nth path key must match its pathkeys against the pathkey of
|
||||
* the Nth join key in 'joinkeys'.
|
||||
*
|
||||
* 'joinkeys' is the list of key pairs to which the path keys must be
|
||||
|
|
@ -215,7 +216,7 @@ match_pathkey_joinkeys(List *pathkey,
|
|||
* must correspond
|
||||
* 'paths' is a list of(inner) paths which are to be matched against
|
||||
* each join key in 'joinkeys'
|
||||
* 'outer_or_inner' is a flag that selects the desired subkey of a join key
|
||||
* 'outer_or_inner' is a flag that selects the desired pathkey of a join key
|
||||
* in 'joinkeys'
|
||||
*
|
||||
* Find the cheapest path that matches the join keys
|
||||
|
|
@ -232,7 +233,7 @@ get_cheapest_path_for_joinkeys(List *joinkeys,
|
|||
foreach(i, paths)
|
||||
{
|
||||
Path *path = (Path *) lfirst(i);
|
||||
int better_sort, better_key;
|
||||
int better_sort;
|
||||
|
||||
if (order_joinkeys_by_pathkeys(path->pathkeys, joinkeys, NIL,
|
||||
outer_or_inner, NULL, NULL) &&
|
||||
|
|
@ -251,23 +252,23 @@ get_cheapest_path_for_joinkeys(List *joinkeys,
|
|||
|
||||
|
||||
/*
|
||||
* extract_path_keys
|
||||
* Builds a subkey list for a path by pulling one of the subkeys from
|
||||
* make_pathkeys_from_joinkeys
|
||||
* Builds a pathkey list for a path by pulling one of the pathkeys from
|
||||
* a list of join keys 'joinkeys' and then finding the var node in the
|
||||
* target list 'tlist' that corresponds to that subkey.
|
||||
* target list 'tlist' that corresponds to that pathkey.
|
||||
*
|
||||
* 'joinkeys' is a list of join key pairs
|
||||
* 'tlist' is a relation target list
|
||||
* 'outer_or_inner' is a flag that selects the desired subkey of a join key
|
||||
* 'outer_or_inner' is a flag that selects the desired pathkey of a join key
|
||||
* in 'joinkeys'
|
||||
*
|
||||
* Returns a list of pathkeys: ((tlvar1)(tlvar2)...(tlvarN)).
|
||||
* It is a list of lists because of multi-key indexes.
|
||||
*/
|
||||
List *
|
||||
extract_path_keys(List *joinkeys,
|
||||
List *tlist,
|
||||
int outer_or_inner)
|
||||
make_pathkeys_from_joinkeys(List *joinkeys,
|
||||
List *tlist,
|
||||
int outer_or_inner)
|
||||
{
|
||||
List *pathkeys = NIL;
|
||||
List *jk;
|
||||
|
|
@ -275,30 +276,38 @@ extract_path_keys(List *joinkeys,
|
|||
foreach(jk, joinkeys)
|
||||
{
|
||||
JoinKey *jkey = (JoinKey *) lfirst(jk);
|
||||
Var *var,
|
||||
*key;
|
||||
List *p;
|
||||
Var *key;
|
||||
List *p, *p2;
|
||||
bool found = false;
|
||||
|
||||
/*
|
||||
* find the right Var in the target list for this key
|
||||
*/
|
||||
var = (Var *) extract_join_key(jkey, outer_or_inner);
|
||||
key = (Var *) matching_tlist_var(var, tlist);
|
||||
key = (Var *) extract_join_key(jkey, outer_or_inner);
|
||||
|
||||
/*
|
||||
* Include it in the pathkeys list if we haven't already done so
|
||||
*/
|
||||
foreach(p, pathkeys)
|
||||
/* check to see if it is in the target list */
|
||||
if (matching_tlist_var(key, tlist))
|
||||
{
|
||||
Var *pkey = lfirst((List *) lfirst(p)); /* XXX fix me */
|
||||
|
||||
if (key == pkey)
|
||||
break;
|
||||
/*
|
||||
* Include it in the pathkeys list if we haven't already done so
|
||||
*/
|
||||
foreach(p, pathkeys)
|
||||
{
|
||||
List *pathkey = lfirst(p);
|
||||
|
||||
foreach(p2, pathkey)
|
||||
{
|
||||
Var *pkey = lfirst(p2);
|
||||
|
||||
if (equal(key, pkey))
|
||||
{
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found)
|
||||
break;
|
||||
}
|
||||
if (!found)
|
||||
pathkeys = lappend(pathkeys, lcons(key, NIL));
|
||||
}
|
||||
if (p != NIL)
|
||||
continue; /* key already in pathkeys */
|
||||
|
||||
pathkeys = lappend(pathkeys, lcons(key, NIL));
|
||||
}
|
||||
return pathkeys;
|
||||
}
|
||||
|
|
@ -331,99 +340,100 @@ new_join_pathkeys(List *outer_pathkeys,
|
|||
List *joinclauses)
|
||||
{
|
||||
List *outer_pathkey = NIL;
|
||||
List *t_list = NIL;
|
||||
List *x;
|
||||
List *final_pathkeys = NIL;
|
||||
List *new_pathkey;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, outer_pathkeys)
|
||||
{
|
||||
outer_pathkey = lfirst(i);
|
||||
x = new_join_pathkey(outer_pathkey, NIL, join_rel_tlist, joinclauses);
|
||||
if (x != NIL)
|
||||
t_list = lappend(t_list, x);
|
||||
new_pathkey = new_join_pathkey(outer_pathkey, join_rel_tlist,
|
||||
joinclauses);
|
||||
if (new_pathkey != NIL)
|
||||
final_pathkeys = lappend(final_pathkeys, new_pathkey);
|
||||
}
|
||||
return t_list;
|
||||
return final_pathkeys;
|
||||
}
|
||||
|
||||
/*
|
||||
* new_join_pathkey
|
||||
* Finds new vars that become subkeys due to qualification clauses that
|
||||
* contain any previously considered subkeys. These new subkeys plus the
|
||||
* subkeys from 'subkeys' form a new pathkey for the join relation.
|
||||
* Finds new vars that become pathkeys due to qualification clauses that
|
||||
* contain any previously considered pathkeys. These new pathkeys plus the
|
||||
* pathkeys from 'pathkeys' form a new pathkey for the join relation.
|
||||
*
|
||||
* Note that each returned subkey is the var node found in
|
||||
* Note that each returned pathkey is the var node found in
|
||||
* 'join_rel_tlist' rather than the joinclause var node.
|
||||
*
|
||||
* 'subkeys' is a list of subkeys for which matching subkeys are to be
|
||||
* 'pathkeys' is a list of pathkeys for which matching pathkeys are to be
|
||||
* found
|
||||
* 'considered_subkeys' is the current list of all subkeys corresponding
|
||||
* 'considered_pathkeys' is the current list of all pathkeys corresponding
|
||||
* to a given pathkey
|
||||
*
|
||||
* Returns a new pathkey(list of subkeys).
|
||||
* Returns a new pathkey(list of pathkeys).
|
||||
*
|
||||
*/
|
||||
static List *
|
||||
new_join_pathkey(List *subkeys,
|
||||
List *considered_subkeys,
|
||||
new_join_pathkey(List *pathkey,
|
||||
List *join_rel_tlist,
|
||||
List *joinclauses)
|
||||
{
|
||||
List *t_list = NIL;
|
||||
Var *subkey;
|
||||
List *final_pathkey = NIL;
|
||||
List *i = NIL;
|
||||
List *matched_subkeys = NIL;
|
||||
Expr *tlist_key = (Expr *) NULL;
|
||||
List *newly_considered_subkeys = NIL;
|
||||
List *considered_pathkeys = NIL;
|
||||
|
||||
foreach(i, subkeys)
|
||||
foreach(i, pathkey)
|
||||
{
|
||||
subkey = (Var *) lfirst(i);
|
||||
if (subkey == NULL)
|
||||
break; /* XXX something is wrong */
|
||||
matched_subkeys = new_matching_subkeys(subkey, considered_subkeys,
|
||||
join_rel_tlist, joinclauses);
|
||||
tlist_key = matching_tlist_var(subkey, join_rel_tlist);
|
||||
newly_considered_subkeys = NIL;
|
||||
Var *key = (Var *) lfirst(i);
|
||||
List *joined_keys;
|
||||
Expr *tlist_key;
|
||||
|
||||
if (tlist_key)
|
||||
Assert(key);
|
||||
joined_keys = get_joinvars_for_var(key, &considered_pathkeys,
|
||||
join_rel_tlist, joinclauses);
|
||||
if (joined_keys)
|
||||
{
|
||||
if (!member(tlist_key, matched_subkeys))
|
||||
newly_considered_subkeys = lcons(tlist_key, matched_subkeys);
|
||||
considered_pathkeys = nconc(considered_pathkeys, joined_keys);
|
||||
final_pathkey = nconc(final_pathkey, joined_keys);
|
||||
}
|
||||
|
||||
tlist_key = matching_tlist_var(key, join_rel_tlist);
|
||||
if (tlist_key && !member(tlist_key, considered_pathkeys))
|
||||
{
|
||||
/*
|
||||
* If pathkey is in the target list, and not considered,
|
||||
* add it
|
||||
*/
|
||||
considered_pathkeys = lcons(tlist_key, considered_pathkeys);
|
||||
final_pathkey = lcons(tlist_key, final_pathkey);
|
||||
}
|
||||
else
|
||||
newly_considered_subkeys = matched_subkeys;
|
||||
|
||||
considered_subkeys = append(considered_subkeys, newly_considered_subkeys);
|
||||
|
||||
t_list = nconc(t_list, newly_considered_subkeys);
|
||||
}
|
||||
return t_list;
|
||||
return copyObject(final_pathkey);
|
||||
}
|
||||
|
||||
/*
|
||||
* new_matching_subkeys
|
||||
* Returns a list of new subkeys:
|
||||
* (1) which are not listed in 'considered_subkeys'
|
||||
* get_joinvars_for_var
|
||||
* Returns a list of new pathkeys:
|
||||
* (1) which are not listed in 'considered_pathkeys'
|
||||
* (2) for which the "other" variable in some clause in 'joinclauses' is
|
||||
* 'subkey'
|
||||
* 'pathkey'
|
||||
* (3) which are mentioned in 'join_rel_tlist'
|
||||
*
|
||||
* Note that each returned subkey is the var node found in
|
||||
* Note that each returned pathkey is the var node found in
|
||||
* 'join_rel_tlist' rather than the joinclause var node.
|
||||
*
|
||||
* 'subkey' is the var node for which we are trying to find matching
|
||||
* 'pathkey' is the var node for which we are trying to find matching
|
||||
* clauses
|
||||
*
|
||||
* Returns a list of new subkeys.
|
||||
* Returns a list of new pathkeys.
|
||||
*
|
||||
*/
|
||||
static List *
|
||||
new_matching_subkeys(Var *subkey,
|
||||
List *considered_subkeys,
|
||||
get_joinvars_for_var(Var *key,
|
||||
List **considered_pathkeys,
|
||||
List *join_rel_tlist,
|
||||
List *joinclauses)
|
||||
{
|
||||
List *t_list = NIL;
|
||||
List *final_pathkey = NIL;
|
||||
Expr *joinclause;
|
||||
List *i;
|
||||
Expr *tlist_other_var;
|
||||
|
|
@ -431,25 +441,20 @@ new_matching_subkeys(Var *subkey,
|
|||
foreach(i, joinclauses)
|
||||
{
|
||||
joinclause = lfirst(i);
|
||||
|
||||
tlist_other_var = matching_tlist_var(
|
||||
other_join_clause_var(subkey, joinclause),
|
||||
join_rel_tlist);
|
||||
|
||||
other_join_clause_var(key, joinclause),
|
||||
join_rel_tlist);
|
||||
if (tlist_other_var &&
|
||||
!(member(tlist_other_var, considered_subkeys)))
|
||||
!member(tlist_other_var, *considered_pathkeys))
|
||||
{
|
||||
|
||||
/* XXX was "push" function */
|
||||
considered_subkeys = lappend(considered_subkeys,
|
||||
tlist_other_var);
|
||||
|
||||
/*
|
||||
* considered_subkeys = nreverse(considered_subkeys); XXX -- I
|
||||
* am not sure of this.
|
||||
* The key has a join variable that is in the target list,
|
||||
* and has not been considered.
|
||||
*/
|
||||
|
||||
t_list = lappend(t_list, tlist_other_var);
|
||||
*considered_pathkeys = lcons(tlist_other_var, *considered_pathkeys);
|
||||
final_pathkey = lcons(tlist_other_var, final_pathkey);
|
||||
}
|
||||
}
|
||||
return t_list;
|
||||
return final_pathkey;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.28 1999/02/18 00:49:26 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.29 1999/02/22 05:26:21 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -72,7 +72,7 @@ make_var_only_tlist(Query *root, List *tlist)
|
|||
{
|
||||
TargetEntry *entry = (TargetEntry *) lfirst(l);
|
||||
|
||||
tlist_vars = append(tlist_vars, pull_var_clause(entry->expr));
|
||||
tlist_vars = nconc(tlist_vars, pull_var_clause(entry->expr));
|
||||
}
|
||||
|
||||
/* now, the target list only contains Var nodes */
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.18 1999/02/18 00:49:37 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.19 1999/02/22 05:26:26 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -101,9 +101,9 @@ other_join_clause_var(Var *var, Expr *clause)
|
|||
l = (Var *) get_leftop(clause);
|
||||
r = (Var *) get_rightop(clause);
|
||||
|
||||
if (var_equal(var, l))
|
||||
if (equal(var, l))
|
||||
retval = r;
|
||||
else if (var_equal(var, r))
|
||||
else if (equal(var, r))
|
||||
retval = l;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.16 1999/02/13 23:16:50 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.17 1999/02/22 05:26:27 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -235,6 +235,9 @@ pull_var_clause(Node *clause)
|
|||
/*
|
||||
* var_equal
|
||||
*
|
||||
* The only difference between this an equal() is that this does not
|
||||
* test varnoold and varoattno.
|
||||
*
|
||||
* Returns t iff two var nodes correspond to the same attribute.
|
||||
*/
|
||||
bool
|
||||
|
|
|
|||
|
|
@ -242,7 +242,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.73 1999/02/14 05:14:09 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.74 1999/02/22 05:26:33 momjian Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
|
|
@ -11574,7 +11574,7 @@ makeRowExpr(char *opr, List *largs, List *rargs)
|
|||
elog(ERROR,"Operator '%s' not implemented for row expressions",opr);
|
||||
}
|
||||
|
||||
#if FALSE
|
||||
#ifdef NOT_USED
|
||||
while ((largs != NIL) && (rargs != NIL))
|
||||
{
|
||||
larg = lfirst(largs);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.36 1999/02/21 03:49:18 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.37 1999/02/22 05:26:46 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -97,7 +97,7 @@ gatherRewriteMeta(Query *parsetree,
|
|||
info->current_varno = rt_index;
|
||||
info->rt = parsetree->rtable;
|
||||
rt_length = length(info->rt);
|
||||
info->rt = append(info->rt, info->rule_action->rtable);
|
||||
info->rt = nconc(info->rt, copyObject(info->rule_action->rtable));
|
||||
|
||||
info->new_varno = PRS2_NEW_VARNO + rt_length;
|
||||
OffsetVarNodes(info->rule_action->qual, rt_length, 0);
|
||||
|
|
@ -2206,7 +2206,7 @@ CopyAndAddQual(Query *parsetree,
|
|||
|
||||
rtable = new_tree->rtable;
|
||||
rt_length = length(rtable);
|
||||
rtable = append(rtable, listCopy(rule_action->rtable));
|
||||
rtable = nconc(rtable, copyObject(rule_action->rtable));
|
||||
new_tree->rtable = rtable;
|
||||
OffsetVarNodes(new_qual, rt_length, 0);
|
||||
ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: pg_list.h,v 1.10 1999/02/13 23:21:39 momjian Exp $
|
||||
* $Id: pg_list.h,v 1.11 1999/02/22 05:26:47 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -82,7 +82,6 @@ typedef struct List
|
|||
* function prototypes in nodes/list.c
|
||||
*/
|
||||
extern int length(List *list);
|
||||
extern List *append(List *list1, List *list2);
|
||||
extern List *nconc(List *list1, List *list2);
|
||||
extern List *lcons(void *datum, List *list);
|
||||
extern bool member(void *foo, List *bar);
|
||||
|
|
@ -101,11 +100,9 @@ extern void set_nth(List *l, int n, void *elem);
|
|||
List *lconsi(int datum, List *list);
|
||||
List *lappendi(List *list, int datum);
|
||||
extern bool intMember(int, List *);
|
||||
extern List *intAppend(List *list1, List *list2);
|
||||
|
||||
extern int nthi(int n, List *l);
|
||||
|
||||
extern List *nreverse(List *);
|
||||
extern List *set_difference(List *, List *);
|
||||
extern List *set_differencei(List *, List *);
|
||||
extern List *LispUnion(List *foo, List *bar);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: paths.h,v 1.25 1999/02/21 01:55:03 momjian Exp $
|
||||
* $Id: paths.h,v 1.26 1999/02/22 05:26:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -58,8 +58,8 @@ extern bool order_joinkeys_by_pathkeys(List *pathkeys,
|
|||
List *joinkeys, List *joinclauses, int outer_or_inner,
|
||||
List **matchedJoinKeysPtr,
|
||||
List **matchedJoinClausesPtr);
|
||||
extern List *extract_path_keys(List *joinkeys, List *tlist,
|
||||
int outer_or_inner);
|
||||
extern List *make_pathkeys_from_joinkeys(List *joinkeys, List *tlist,
|
||||
int outer_or_inner);
|
||||
extern Path *get_cheapest_path_for_joinkeys(List *joinkeys,
|
||||
PathOrder *ordering, List *paths, int outer_or_inner);
|
||||
extern List *new_join_pathkeys(List *outer_pathkeys,
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.22 1998/09/20 04:51:12 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.23 1999/02/22 05:26:53 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -438,8 +438,8 @@ tryAgain2:
|
|||
definitelyFailed:
|
||||
sprintf(conn->errorMessage,
|
||||
"pqReadData() -- backend closed the channel unexpectedly.\n"
|
||||
"\tThis probably means the backend terminated abnormally"
|
||||
" before or while processing the request.\n");
|
||||
"\tThis probably means the backend terminated abnormally\n"
|
||||
"\tbefore or while processing the request.\n");
|
||||
conn->status = CONNECTION_BAD; /* No more connection to backend */
|
||||
#ifdef WIN32
|
||||
closesocket(conn->sock);
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
.\" This is -*-nroff-*-
|
||||
.\" XXX standard disclaimer belongs here....
|
||||
.\" $Header: /cvsroot/pgsql/src/man/Attic/postmaster.1,v 1.14 1999/02/21 03:17:31 tgl Exp $
|
||||
.\" $Header: /cvsroot/pgsql/src/man/Attic/postmaster.1,v 1.15 1999/02/22 05:26:58 momjian Exp $
|
||||
.TH POSTMASTER UNIX 02/20/99 PostgreSQL PostgreSQL
|
||||
.SH "NAME"
|
||||
postmaster - run the Postgres postmaster
|
||||
|
|
@ -13,17 +13,17 @@ n_buffers]
|
|||
.BR "-D"
|
||||
data_dir]
|
||||
[\c
|
||||
.BR "-N"
|
||||
n_backends]
|
||||
.br
|
||||
.in +5n
|
||||
[\c
|
||||
.BR "-S" \c
|
||||
]
|
||||
[\c
|
||||
.BR "-a"
|
||||
system]
|
||||
[\c
|
||||
.BR "-N"
|
||||
n_backends]
|
||||
.br
|
||||
.in +5n
|
||||
[\c
|
||||
.BR "-b"
|
||||
backend_pathname]
|
||||
[\c
|
||||
|
|
@ -35,7 +35,6 @@ backend_pathname]
|
|||
[\c
|
||||
.BR "-n" \c
|
||||
]
|
||||
.br
|
||||
[\c
|
||||
.BR "-o"
|
||||
backend_options]
|
||||
|
|
@ -81,6 +80,14 @@ is not set, then the directory used is
|
|||
option is not specified, the default directory that was
|
||||
set at compile-time is used.
|
||||
.TP
|
||||
.BR "-N" " n_backends"
|
||||
.IR "n_backends"
|
||||
is the maximum number of backend server processes that this postmaster
|
||||
is allowed to start. In the stock configuration, this value defaults
|
||||
to 64, and can be set as high as 1024 if your system will support that
|
||||
many processes. Both the default and upper limit values can be altered
|
||||
when building Postgres.
|
||||
.TP
|
||||
.BR "-S"
|
||||
Specifies that the
|
||||
.IR "postmaster"
|
||||
|
|
@ -108,14 +115,6 @@ connections, use
|
|||
.BR "-a nounauth .
|
||||
This option no longer has any effect.
|
||||
.TP
|
||||
.BR "-N" " n_backends"
|
||||
.IR "n_backends"
|
||||
is the maximum number of backend server processes that this postmaster
|
||||
is allowed to start. In the stock configuration, this value defaults
|
||||
to 64, and can be set as high as 1024 if your system will support that
|
||||
many processes. Both the default and upper limit values can be altered
|
||||
when building Postgres.
|
||||
.TP
|
||||
.BR "-b" " backend_pathname"
|
||||
.IR "backend_pathname"
|
||||
is the full pathname of the Postgres backend server executable file that
|
||||
|
|
|
|||
Loading…
Reference in New Issue