From 67fd67f53af39b11a1f40e81ed0c4e7b2b69ffef Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Sat, 20 Feb 1999 15:27:42 +0000 Subject: another rename of optimizer --- src/backend/optimizer/path/Makefile | 4 +- src/backend/optimizer/path/pathkey.c | 432 ---------------------------------- src/backend/optimizer/path/pathkeys.c | 432 ++++++++++++++++++++++++++++++++++ 3 files changed, 434 insertions(+), 434 deletions(-) delete mode 100644 src/backend/optimizer/path/pathkey.c create mode 100644 src/backend/optimizer/path/pathkeys.c (limited to 'src') diff --git a/src/backend/optimizer/path/Makefile b/src/backend/optimizer/path/Makefile index 7bf1b6f3313..7db01b05aea 100644 --- a/src/backend/optimizer/path/Makefile +++ b/src/backend/optimizer/path/Makefile @@ -4,7 +4,7 @@ # Makefile for optimizer/path # # IDENTIFICATION -# $Header: /cvsroot/pgsql/src/backend/optimizer/path/Makefile,v 1.7 1999/02/18 19:58:51 momjian Exp $ +# $Header: /cvsroot/pgsql/src/backend/optimizer/path/Makefile,v 1.8 1999/02/20 15:27:42 momjian Exp $ # #------------------------------------------------------------------------- @@ -14,7 +14,7 @@ include ../../../Makefile.global CFLAGS += -I../.. OBJS = allpaths.o clausesel.o costsize.o hashutils.o indxpath.o \ - joinpath.o joinrels.o mergeutils.o orindxpath.o pathkey.o prune.o + joinpath.o joinrels.o mergeutils.o orindxpath.o pathkeys.o prune.o all: SUBSYS.o diff --git a/src/backend/optimizer/path/pathkey.c b/src/backend/optimizer/path/pathkey.c deleted file mode 100644 index 7d098db8850..00000000000 --- a/src/backend/optimizer/path/pathkey.c +++ /dev/null @@ -1,432 +0,0 @@ -/*------------------------------------------------------------------------- - * - * joinutils.c - * Utilities for matching and building join and path keys - * - * Copyright (c) 1994, Regents of the University of California - * - * - * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/pathkey.c,v 1.3 1999/02/19 05:18:05 momjian Exp $ - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "nodes/pg_list.h" -#include "nodes/relation.h" -#include "nodes/plannodes.h" - -#include "optimizer/internal.h" -#include "optimizer/paths.h" -#include "optimizer/var.h" -#include "optimizer/keys.h" -#include "optimizer/tlist.h" -#include "optimizer/joininfo.h" -#include "optimizer/ordering.h" - - -static int match_pathkey_joinkeys(List *pathkey, List *joinkeys, - int outer_or_inner); -static bool joinkeys_pathkeys_match(List *joinkeys, List *pathkey, - 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, - List *join_rel_tlist, List *joinclauses); - -/**************************************************************************** - * KEY COMPARISONS - ****************************************************************************/ - -/* - * order_joinkeys_by_pathkeys - * Attempts to match the keys of a path against the keys of join clauses. - * This is done by looking for a matching join key in 'joinkeys' for - * every path key in the list 'path.keys'. If there is a matching join key - * (not necessarily unique) for every path key, then the list of - * corresponding join keys and join clauses are returned in the order in - * which the keys matched the path keys. - * - * 'pathkeys' is a list of path keys: - * ( ( (var) (var) ... ) ( (var) ... ) ) - * 'joinkeys' is a list of join keys: - * ( (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 - * in 'joinkeys' - * - * Returns the join keys and corresponding join clauses in a list if all - * of the path keys were matched: - * ( - * ( (outerkey0 innerkey0) ... (outerkeyN innerkeyN) ) - * ( clause0 ... clauseN ) - * ) - * and nil otherwise. - * - * Returns a list of matched join keys and a list of matched join clauses - * in matchedJoinClausesPtr. - ay 11/94 - */ -List * -order_joinkeys_by_pathkeys(List *pathkeys, - List *joinkeys, - List *joinclauses, - int outer_or_inner, - List **matchedJoinClausesPtr) -{ - List *matched_joinkeys = NIL; - List *matched_joinclauses = NIL; - List *pathkey = NIL; - List *i = NIL; - int matched_joinkey_index = -1; - - foreach(i, pathkeys) - { - pathkey = lfirst(i); - matched_joinkey_index = match_pathkey_joinkeys(pathkey, joinkeys, - outer_or_inner); - - if (matched_joinkey_index != -1) - { - List *xjoinkey = nth(matched_joinkey_index, joinkeys); - List *joinclause = nth(matched_joinkey_index, joinclauses); - - matched_joinkeys = lappend(matched_joinkeys, xjoinkey); - matched_joinclauses = lappend(matched_joinclauses, joinclause); - } - else - { - *matchedJoinClausesPtr = NIL; - return NIL; - } - } - - *matchedJoinClausesPtr = matched_joinclauses; - return matched_joinkeys; -} - - -/* - * match_pathkey_joinkeys - * Returns the 0-based index into 'joinkeys' of the first joinkey whose - * outer or inner subkey matches any subkey of 'pathkey'. - */ -static int -match_pathkey_joinkeys(List *pathkey, - List *joinkeys, - int outer_or_inner) -{ - Var *path_subkey; - int pos; - List *i = NIL; - List *x = NIL; - JoinKey *jk; - - foreach(i, pathkey) - { - path_subkey = (Var *) lfirst(i); - pos = 0; - foreach(x, joinkeys) - { - jk = (JoinKey *) lfirst(x); - if (var_equal(path_subkey, - extract_join_key(jk, outer_or_inner))) - return pos; - pos++; - } - } - return -1; /* no index found */ -} - - -/* - * get_cheapest_path_for_joinkeys - * 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 - * the Nth join key in 'joinkeys'. - * - * 'joinkeys' is the list of key pairs to which the path keys must be - * matched - * 'ordering' is the ordering of the(outer) path to which 'joinkeys' - * 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 - * in 'joinkeys' - * - * Find the cheapest path that matches the join keys - */ -Path * -get_cheapest_path_for_joinkeys(List *joinkeys, - PathOrder *ordering, - List *paths, - int outer_or_inner) -{ - Path *matched_path = NULL; - List *i = NIL; - - foreach(i, paths) - { - Path *path = (Path *) lfirst(i); - int better_sort, better_key; - - if (joinkeys_pathkeys_match(joinkeys, path->pathkeys, outer_or_inner) && - length(joinkeys) == length(path->pathkeys) && - pathorder_match(ordering, path->pathorder, &better_sort) && - better_sort == 0) - { - if (matched_path) - if (path->path_cost < matched_path->path_cost) - matched_path = path; - else - matched_path = path; - } - } - return matched_path; -} - - -/* - * extract_path_keys - * Builds a subkey list for a path by pulling one of the subkeys from - * a list of join keys 'joinkeys' and then finding the var node in the - * target list 'tlist' that corresponds to that subkey. - * - * '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 - * 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) -{ - List *pathkeys = NIL; - List *jk; - - foreach(jk, joinkeys) - { - JoinKey *jkey = (JoinKey *) lfirst(jk); - Var *var, - *key; - List *p; - - /* - * 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); - - /* - * Include it in the pathkeys list if we haven't already done so - */ - foreach(p, pathkeys) - { - Var *pkey = lfirst((List *) lfirst(p)); /* XXX fix me */ - - if (key == pkey) - break; - } - if (p != NIL) - continue; /* key already in pathkeys */ - - pathkeys = lappend(pathkeys, lcons(key, NIL)); - } - return pathkeys; -} - - -/* - * joinkeys_pathkeys_match - */ -static bool -joinkeys_pathkeys_match(List *joinkeys, List *pathkey, int outer_or_inner) -{ - JoinKey *xjoinkey; - Var *temp; - Var *tempkey = NULL; - bool found = false; - List *i = NIL; - List *j = NIL; - - foreach(i, joinkeys) - { - xjoinkey = (JoinKey *) lfirst(i); - found = false; - foreach(j, pathkey) - { - temp = (Var *) lfirst((List *) lfirst(j)); - if (temp == NULL) - continue; - tempkey = extract_join_key(xjoinkey, outer_or_inner); - if (var_equal(tempkey, temp)) - { - found = true; - break; - } - } - if (found == false) - return false; - } - return found; -} - - -/**************************************************************************** - * NEW PATHKEY FORMATION - ****************************************************************************/ - -/* - * new_join_pathkeys - * Find the path keys for a join relation by finding all vars in the list - * of join clauses 'joinclauses' such that: - * (1) the var corresponding to the outer join relation is a - * key on the outer path - * (2) the var appears in the target list of the join relation - * In other words, add to each outer path key the inner path keys that - * are required for qualification. - * - * 'outer_pathkeys' is the list of the outer path's path keys - * 'join_rel_tlist' is the target list of the join relation - * 'joinclauses' is the list of restricting join clauses - * - * Returns the list of new path keys. - * - */ -List * -new_join_pathkeys(List *outer_pathkeys, - List *join_rel_tlist, - List *joinclauses) -{ - List *outer_pathkey = NIL; - List *t_list = NIL; - List *x; - 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); - } - return t_list; -} - -/* - * 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. - * - * Note that each returned subkey 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 - * found - * 'considered_subkeys' is the current list of all subkeys corresponding - * to a given pathkey - * - * Returns a new pathkey(list of subkeys). - * - */ -static List * -new_join_pathkey(List *subkeys, - List *considered_subkeys, - List *join_rel_tlist, - List *joinclauses) -{ - List *t_list = NIL; - Var *subkey; - List *i = NIL; - List *matched_subkeys = NIL; - Expr *tlist_key = (Expr *) NULL; - List *newly_considered_subkeys = NIL; - - foreach(i, subkeys) - { - 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; - - if (tlist_key) - { - if (!member(tlist_key, matched_subkeys)) - newly_considered_subkeys = lcons(tlist_key, matched_subkeys); - } - 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; -} - -/* - * new_matching_subkeys - * Returns a list of new subkeys: - * (1) which are not listed in 'considered_subkeys' - * (2) for which the "other" variable in some clause in 'joinclauses' is - * 'subkey' - * (3) which are mentioned in 'join_rel_tlist' - * - * Note that each returned subkey 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 - * clauses - * - * Returns a list of new subkeys. - * - */ -static List * -new_matching_subkeys(Var *subkey, - List *considered_subkeys, - List *join_rel_tlist, - List *joinclauses) -{ - List *t_list = NIL; - Expr *joinclause; - List *i; - Expr *tlist_other_var; - - foreach(i, joinclauses) - { - joinclause = lfirst(i); - tlist_other_var = matching_tlist_var( - other_join_clause_var(subkey, joinclause), - join_rel_tlist); - - if (tlist_other_var && - !(member(tlist_other_var, considered_subkeys))) - { - - /* XXX was "push" function */ - considered_subkeys = lappend(considered_subkeys, - tlist_other_var); - - /* - * considered_subkeys = nreverse(considered_subkeys); XXX -- I - * am not sure of this. - */ - - t_list = lappend(t_list, tlist_other_var); - } - } - return t_list; -} diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c new file mode 100644 index 00000000000..996c197350c --- /dev/null +++ b/src/backend/optimizer/path/pathkeys.c @@ -0,0 +1,432 @@ +/*------------------------------------------------------------------------- + * + * joinutils.c + * Utilities for matching and building join and path keys + * + * Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.1 1999/02/20 15:27:42 momjian Exp $ + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include "nodes/pg_list.h" +#include "nodes/relation.h" +#include "nodes/plannodes.h" + +#include "optimizer/internal.h" +#include "optimizer/paths.h" +#include "optimizer/var.h" +#include "optimizer/keys.h" +#include "optimizer/tlist.h" +#include "optimizer/joininfo.h" +#include "optimizer/ordering.h" + + +static int match_pathkey_joinkeys(List *pathkey, List *joinkeys, + int outer_or_inner); +static bool joinkeys_pathkeys_match(List *joinkeys, List *pathkey, + 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, + List *join_rel_tlist, List *joinclauses); + +/**************************************************************************** + * KEY COMPARISONS + ****************************************************************************/ + +/* + * order_joinkeys_by_pathkeys + * Attempts to match the keys of a path against the keys of join clauses. + * This is done by looking for a matching join key in 'joinkeys' for + * every path key in the list 'path.keys'. If there is a matching join key + * (not necessarily unique) for every path key, then the list of + * corresponding join keys and join clauses are returned in the order in + * which the keys matched the path keys. + * + * 'pathkeys' is a list of path keys: + * ( ( (var) (var) ... ) ( (var) ... ) ) + * 'joinkeys' is a list of join keys: + * ( (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 + * in 'joinkeys' + * + * Returns the join keys and corresponding join clauses in a list if all + * of the path keys were matched: + * ( + * ( (outerkey0 innerkey0) ... (outerkeyN innerkeyN) ) + * ( clause0 ... clauseN ) + * ) + * and nil otherwise. + * + * Returns a list of matched join keys and a list of matched join clauses + * in matchedJoinClausesPtr. - ay 11/94 + */ +List * +order_joinkeys_by_pathkeys(List *pathkeys, + List *joinkeys, + List *joinclauses, + int outer_or_inner, + List **matchedJoinClausesPtr) +{ + List *matched_joinkeys = NIL; + List *matched_joinclauses = NIL; + List *pathkey = NIL; + List *i = NIL; + int matched_joinkey_index = -1; + + foreach(i, pathkeys) + { + pathkey = lfirst(i); + matched_joinkey_index = match_pathkey_joinkeys(pathkey, joinkeys, + outer_or_inner); + + if (matched_joinkey_index != -1) + { + List *xjoinkey = nth(matched_joinkey_index, joinkeys); + List *joinclause = nth(matched_joinkey_index, joinclauses); + + matched_joinkeys = lappend(matched_joinkeys, xjoinkey); + matched_joinclauses = lappend(matched_joinclauses, joinclause); + } + else + { + *matchedJoinClausesPtr = NIL; + return NIL; + } + } + + *matchedJoinClausesPtr = matched_joinclauses; + return matched_joinkeys; +} + + +/* + * match_pathkey_joinkeys + * Returns the 0-based index into 'joinkeys' of the first joinkey whose + * outer or inner subkey matches any subkey of 'pathkey'. + */ +static int +match_pathkey_joinkeys(List *pathkey, + List *joinkeys, + int outer_or_inner) +{ + Var *path_subkey; + int pos; + List *i = NIL; + List *x = NIL; + JoinKey *jk; + + foreach(i, pathkey) + { + path_subkey = (Var *) lfirst(i); + pos = 0; + foreach(x, joinkeys) + { + jk = (JoinKey *) lfirst(x); + if (var_equal(path_subkey, + extract_join_key(jk, outer_or_inner))) + return pos; + pos++; + } + } + return -1; /* no index found */ +} + + +/* + * get_cheapest_path_for_joinkeys + * 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 + * the Nth join key in 'joinkeys'. + * + * 'joinkeys' is the list of key pairs to which the path keys must be + * matched + * 'ordering' is the ordering of the(outer) path to which 'joinkeys' + * 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 + * in 'joinkeys' + * + * Find the cheapest path that matches the join keys + */ +Path * +get_cheapest_path_for_joinkeys(List *joinkeys, + PathOrder *ordering, + List *paths, + int outer_or_inner) +{ + Path *matched_path = NULL; + List *i = NIL; + + foreach(i, paths) + { + Path *path = (Path *) lfirst(i); + int better_sort, better_key; + + if (joinkeys_pathkeys_match(joinkeys, path->pathkeys, outer_or_inner) && + length(joinkeys) == length(path->pathkeys) && + pathorder_match(ordering, path->pathorder, &better_sort) && + better_sort == 0) + { + if (matched_path) + if (path->path_cost < matched_path->path_cost) + matched_path = path; + else + matched_path = path; + } + } + return matched_path; +} + + +/* + * extract_path_keys + * Builds a subkey list for a path by pulling one of the subkeys from + * a list of join keys 'joinkeys' and then finding the var node in the + * target list 'tlist' that corresponds to that subkey. + * + * '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 + * 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) +{ + List *pathkeys = NIL; + List *jk; + + foreach(jk, joinkeys) + { + JoinKey *jkey = (JoinKey *) lfirst(jk); + Var *var, + *key; + List *p; + + /* + * 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); + + /* + * Include it in the pathkeys list if we haven't already done so + */ + foreach(p, pathkeys) + { + Var *pkey = lfirst((List *) lfirst(p)); /* XXX fix me */ + + if (key == pkey) + break; + } + if (p != NIL) + continue; /* key already in pathkeys */ + + pathkeys = lappend(pathkeys, lcons(key, NIL)); + } + return pathkeys; +} + + +/* + * joinkeys_pathkeys_match + */ +static bool +joinkeys_pathkeys_match(List *joinkeys, List *pathkey, int outer_or_inner) +{ + JoinKey *xjoinkey; + Var *temp; + Var *tempkey = NULL; + bool found = false; + List *i = NIL; + List *j = NIL; + + foreach(i, joinkeys) + { + xjoinkey = (JoinKey *) lfirst(i); + found = false; + foreach(j, pathkey) + { + temp = (Var *) lfirst((List *) lfirst(j)); + if (temp == NULL) + continue; + tempkey = extract_join_key(xjoinkey, outer_or_inner); + if (var_equal(tempkey, temp)) + { + found = true; + break; + } + } + if (found == false) + return false; + } + return found; +} + + +/**************************************************************************** + * NEW PATHKEY FORMATION + ****************************************************************************/ + +/* + * new_join_pathkeys + * Find the path keys for a join relation by finding all vars in the list + * of join clauses 'joinclauses' such that: + * (1) the var corresponding to the outer join relation is a + * key on the outer path + * (2) the var appears in the target list of the join relation + * In other words, add to each outer path key the inner path keys that + * are required for qualification. + * + * 'outer_pathkeys' is the list of the outer path's path keys + * 'join_rel_tlist' is the target list of the join relation + * 'joinclauses' is the list of restricting join clauses + * + * Returns the list of new path keys. + * + */ +List * +new_join_pathkeys(List *outer_pathkeys, + List *join_rel_tlist, + List *joinclauses) +{ + List *outer_pathkey = NIL; + List *t_list = NIL; + List *x; + 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); + } + return t_list; +} + +/* + * 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. + * + * Note that each returned subkey 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 + * found + * 'considered_subkeys' is the current list of all subkeys corresponding + * to a given pathkey + * + * Returns a new pathkey(list of subkeys). + * + */ +static List * +new_join_pathkey(List *subkeys, + List *considered_subkeys, + List *join_rel_tlist, + List *joinclauses) +{ + List *t_list = NIL; + Var *subkey; + List *i = NIL; + List *matched_subkeys = NIL; + Expr *tlist_key = (Expr *) NULL; + List *newly_considered_subkeys = NIL; + + foreach(i, subkeys) + { + 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; + + if (tlist_key) + { + if (!member(tlist_key, matched_subkeys)) + newly_considered_subkeys = lcons(tlist_key, matched_subkeys); + } + 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; +} + +/* + * new_matching_subkeys + * Returns a list of new subkeys: + * (1) which are not listed in 'considered_subkeys' + * (2) for which the "other" variable in some clause in 'joinclauses' is + * 'subkey' + * (3) which are mentioned in 'join_rel_tlist' + * + * Note that each returned subkey 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 + * clauses + * + * Returns a list of new subkeys. + * + */ +static List * +new_matching_subkeys(Var *subkey, + List *considered_subkeys, + List *join_rel_tlist, + List *joinclauses) +{ + List *t_list = NIL; + Expr *joinclause; + List *i; + Expr *tlist_other_var; + + foreach(i, joinclauses) + { + joinclause = lfirst(i); + tlist_other_var = matching_tlist_var( + other_join_clause_var(subkey, joinclause), + join_rel_tlist); + + if (tlist_other_var && + !(member(tlist_other_var, considered_subkeys))) + { + + /* XXX was "push" function */ + considered_subkeys = lappend(considered_subkeys, + tlist_other_var); + + /* + * considered_subkeys = nreverse(considered_subkeys); XXX -- I + * am not sure of this. + */ + + t_list = lappend(t_list, tlist_other_var); + } + } + return t_list; +} -- cgit v1.2.3