mirror of
https://github.com/postgres/postgres.git
synced 2025-09-11 00:12:06 +03:00
Renaming cleanup, no pgindent yet.
This commit is contained in:
@@ -6,7 +6,7 @@
|
||||
* CX operator according to Oliver et al
|
||||
* (Proc 2nd Int'l Conf on GA's)
|
||||
*
|
||||
* $Id: geqo_cx.c,v 1.4 1997/09/08 21:44:15 momjian Exp $
|
||||
* $Id: geqo_cx.c,v 1.5 1998/09/01 03:23:04 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -133,5 +133,5 @@ cx(Gene *tour1, Gene *tour2, Gene *offspring, int num_gene, City *city_table)
|
||||
|
||||
}
|
||||
|
||||
return (num_diffs);
|
||||
return num_diffs;
|
||||
}
|
||||
|
@@ -3,7 +3,7 @@
|
||||
* geqo_erx.c--
|
||||
* edge recombination crossover [ER]
|
||||
*
|
||||
* $Id: geqo_erx.c,v 1.9 1998/06/15 19:28:34 momjian Exp $
|
||||
* $Id: geqo_erx.c,v 1.10 1998/09/01 03:23:06 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -77,7 +77,7 @@ alloc_edge_table(int num_gene)
|
||||
|
||||
edge_table = (Edge *) palloc((num_gene + 1) * sizeof(Edge));
|
||||
|
||||
return (edge_table);
|
||||
return edge_table;
|
||||
}
|
||||
|
||||
/* free_edge_table--
|
||||
@@ -147,7 +147,7 @@ gimme_edge_table(Gene *tour1, Gene *tour2, int num_gene, Edge *edge_table)
|
||||
}
|
||||
|
||||
/* return average number of edges per index */
|
||||
return (((float) (edge_total * 2) / (float) num_gene));
|
||||
return ((float) (edge_total * 2) / (float) num_gene);
|
||||
}
|
||||
|
||||
/* gimme_edge--
|
||||
@@ -184,7 +184,7 @@ gimme_edge(Gene gene1, Gene gene2, Edge *edge_table)
|
||||
/* mark shared edges as negative */
|
||||
edge_table[city1].edge_list[i] = 0 - city2;
|
||||
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -195,7 +195,7 @@ gimme_edge(Gene gene1, Gene gene2, Edge *edge_table)
|
||||
edge_table[city1].total_edges++;
|
||||
edge_table[city1].unused_edges++;
|
||||
|
||||
return (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* gimme_tour--
|
||||
@@ -242,7 +242,7 @@ gimme_tour(Edge *edge_table, Gene *new_gene, int num_gene)
|
||||
|
||||
} /* for (i=1; i<num_gene; i++) */
|
||||
|
||||
return (edge_failures);
|
||||
return edge_failures;
|
||||
|
||||
}
|
||||
|
||||
@@ -326,7 +326,7 @@ gimme_gene(Edge edge, Edge *edge_table)
|
||||
* converting to absolute values
|
||||
*/
|
||||
if (friend < 0)
|
||||
return ((Gene) Abs(friend));
|
||||
return (Gene) Abs(friend);
|
||||
|
||||
|
||||
/*
|
||||
@@ -372,7 +372,7 @@ gimme_gene(Edge edge, Edge *edge_table)
|
||||
minimum_count--;
|
||||
|
||||
if (minimum_count == rand_decision)
|
||||
return (friend);
|
||||
return friend;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -433,7 +433,7 @@ edge_failure(Gene *gene, int index, Edge *edge_table, int num_gene)
|
||||
four_count--;
|
||||
|
||||
if (rand_decision == four_count)
|
||||
return ((Gene) i);
|
||||
return (Gene) i;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -458,7 +458,7 @@ edge_failure(Gene *gene, int index, Edge *edge_table, int num_gene)
|
||||
remaining_edges--;
|
||||
|
||||
if (rand_decision == remaining_edges)
|
||||
return (i);
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -478,7 +478,7 @@ edge_failure(Gene *gene, int index, Edge *edge_table, int num_gene)
|
||||
|
||||
for (i = 1; i <= num_gene; i++)
|
||||
if (edge_table[i].unused_edges >= 0)
|
||||
return ((Gene) i);
|
||||
return (Gene) i;
|
||||
|
||||
elog(DEBUG, "edge_failure(3): no edge found via looking for the last ununsed point");
|
||||
}
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_eval.c,v 1.22 1998/08/10 02:26:16 momjian Exp $
|
||||
* $Id: geqo_eval.c,v 1.23 1998/09/01 03:23:07 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -52,7 +52,7 @@
|
||||
|
||||
static List *gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static RelOptInfo *gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo);
|
||||
static List *new_join_tlist(List *tlist, List *other_relids, int first_resdomno);
|
||||
static List *new_joininfo_list(List *joininfo_list, List *join_relids);
|
||||
static void geqo_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
@@ -86,7 +86,7 @@ geqo_eval(Query *root, Gene *tour, int num_gene)
|
||||
pfree(joinrel);
|
||||
freeList(temp);
|
||||
|
||||
return (fitness);
|
||||
return fitness;
|
||||
|
||||
}
|
||||
|
||||
@@ -176,7 +176,7 @@ gimme_tree(Query *root, Gene *tour, int rel_count, int num_gene, RelOptInfo *out
|
||||
|
||||
}
|
||||
|
||||
return (outer_rel); /* tree finished ... */
|
||||
return outer_rel; /* tree finished ... */
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -197,7 +197,7 @@ gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(i);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel = NULL;
|
||||
|
||||
if (!joininfo->inactive)
|
||||
@@ -228,7 +228,7 @@ gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
}
|
||||
}
|
||||
|
||||
return (join_list);
|
||||
return join_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -242,7 +242,7 @@ gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
static RelOptInfo *
|
||||
gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
{
|
||||
return (init_join_rel(outer_rel, inner_rel, (JInfo *) NULL));
|
||||
return init_join_rel(outer_rel, inner_rel, (JoinInfo *) NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -257,7 +257,7 @@ gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
* Returns the new join relation node.
|
||||
*/
|
||||
static RelOptInfo *
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo)
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
||||
{
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
List *joinrel_joininfo_list = NIL;
|
||||
@@ -315,7 +315,7 @@ init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo)
|
||||
|
||||
geqo_joinrel_size(joinrel, outer_rel, inner_rel);
|
||||
|
||||
return (joinrel);
|
||||
return joinrel;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -363,7 +363,7 @@ new_join_tlist(List *tlist,
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -389,13 +389,13 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
{
|
||||
List *current_joininfo_list = NIL;
|
||||
List *new_otherrels = NIL;
|
||||
JInfo *other_joininfo = (JInfo *) NULL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
List *xjoininfo = NIL;
|
||||
|
||||
foreach(xjoininfo, joininfo_list)
|
||||
{
|
||||
List *or;
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
new_otherrels = joininfo->otherrels;
|
||||
foreach(or, new_otherrels)
|
||||
@@ -416,7 +416,7 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
}
|
||||
else
|
||||
{
|
||||
other_joininfo = makeNode(JInfo);
|
||||
other_joininfo = makeNode(JoinInfo);
|
||||
|
||||
other_joininfo->otherrels =
|
||||
joininfo->otherrels;
|
||||
@@ -434,7 +434,7 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
}
|
||||
}
|
||||
|
||||
return (current_joininfo_list);
|
||||
return current_joininfo_list;
|
||||
}
|
||||
|
||||
#ifdef NOTUSED
|
||||
@@ -462,7 +462,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
|
||||
List *super_rels;
|
||||
List *xsuper_rel = NIL;
|
||||
JInfo *new_joininfo;
|
||||
JoinInfo *new_joininfo;
|
||||
|
||||
foreach(xjoinrel, joinrels)
|
||||
{
|
||||
@@ -506,7 +506,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
|
||||
foreach(xjoininfo, joinrel->joininfo)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
List *other_rels = joininfo->otherrels;
|
||||
List *clause_info = joininfo->jinfoclauseinfo;
|
||||
bool mergejoinable = joininfo->mergejoinable;
|
||||
@@ -537,7 +537,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
rel = rel_member(relids, root->base_rel_list);
|
||||
|
||||
super_rels = rel->superrels;
|
||||
new_joininfo = makeNode(JInfo);
|
||||
new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = joinrel->relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
@@ -554,7 +554,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
if (nonoverlap_rels(super_rel, joinrel))
|
||||
{
|
||||
List *new_relids = super_rel->relids;
|
||||
JInfo *other_joininfo =
|
||||
JoinInfo *other_joininfo =
|
||||
joininfo_member(new_relids,
|
||||
joinrel->joininfo);
|
||||
|
||||
@@ -566,7 +566,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
}
|
||||
else
|
||||
{
|
||||
JInfo *new_joininfo = makeNode(JInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = new_relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
@@ -617,7 +617,7 @@ geqo_final_join_rels(List *join_rel_list)
|
||||
|
||||
foreach(xjoininfo, rel->joininfo)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (joininfo->otherrels != NIL)
|
||||
{
|
||||
@@ -632,7 +632,7 @@ geqo_final_join_rels(List *join_rel_list)
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -662,7 +662,7 @@ add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
||||
static bool
|
||||
nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2)
|
||||
{
|
||||
return (nonoverlap_sets(rel1->relids, rel2->relids));
|
||||
return nonoverlap_sets(rel1->relids, rel2->relids);
|
||||
}
|
||||
|
||||
static bool
|
||||
@@ -675,9 +675,9 @@ nonoverlap_sets(List *s1, List *s2)
|
||||
int e = lfirsti(x);
|
||||
|
||||
if (intMember(e, s2))
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
return (true);
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* NOTUSED */
|
||||
@@ -712,7 +712,7 @@ geqo_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_
|
||||
double
|
||||
geqo_log(double x, double b)
|
||||
{
|
||||
return (log(x) / log(b));
|
||||
return log(x) / log(b);
|
||||
}
|
||||
|
||||
static RelOptInfo *
|
||||
|
@@ -6,7 +6,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_main.c,v 1.9 1998/08/10 02:26:17 momjian Exp $
|
||||
* $Id: geqo_main.c,v 1.10 1998/09/01 03:23:09 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -284,5 +284,5 @@ print_plan(best_plan, root);
|
||||
|
||||
free_pool(pool);
|
||||
|
||||
return (best_rel);
|
||||
return best_rel;
|
||||
}
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_misc.c,v 1.9 1998/07/18 04:22:28 momjian Exp $
|
||||
* $Id: geqo_misc.c,v 1.10 1998/09/01 03:23:10 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -58,7 +58,7 @@ avg_pool(Pool *pool)
|
||||
for (i = 0; i < pool->size; i++)
|
||||
cumulative = cumulative + pool->data[i].worth;
|
||||
|
||||
return ((float) cumulative / pool->size);
|
||||
return (float) cumulative / pool->size;
|
||||
}
|
||||
|
||||
/* print_pool--
|
||||
@@ -146,7 +146,7 @@ geqo_print_joinclauses(Query *root, List *clauses)
|
||||
|
||||
foreach(l, clauses)
|
||||
{
|
||||
CInfo *c = lfirst(l);
|
||||
ClauseInfo *c = lfirst(l);
|
||||
|
||||
print_expr((Node *) c->clause, root->rtable);
|
||||
if (lnext(l))
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_params.c,v 1.9 1998/06/15 19:28:36 momjian Exp $
|
||||
* $Id: geqo_params.c,v 1.10 1998/09/01 03:23:11 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -297,7 +297,7 @@ next_token(FILE *fp, char *buf, int bufsz)
|
||||
ungetc(c, fp);
|
||||
|
||||
/* If we ended with a newline, return that, otherwise return 0 */
|
||||
return (c == '\n' ? '\n' : 0);
|
||||
return c == '\n' ? '\n' : 0;
|
||||
}
|
||||
|
||||
/* gimme_pool_size--
|
||||
@@ -315,11 +315,11 @@ gimme_pool_size(int string_length)
|
||||
size = pow(2.0, exponent);
|
||||
|
||||
if (size < MIN_POOL)
|
||||
return (MIN_POOL);
|
||||
return MIN_POOL;
|
||||
else if (size > MAX_POOL)
|
||||
return (MAX_POOL);
|
||||
return MAX_POOL;
|
||||
else
|
||||
return ((int) ceil(size));
|
||||
return (int) ceil(size);
|
||||
}
|
||||
|
||||
/* gimme_number_generations--
|
||||
@@ -333,5 +333,5 @@ gimme_number_generations(int pool_size, int effort)
|
||||
|
||||
number_gens = (int) ceil(geqo_log((double) pool_size, 2.0));
|
||||
|
||||
return (effort * number_gens);
|
||||
return effort * number_gens;
|
||||
}
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_paths.c,v 1.10 1998/07/18 04:22:28 momjian Exp $
|
||||
* $Id: geqo_paths.c,v 1.11 1998/09/01 03:23:12 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -50,7 +50,7 @@ geqo_prune_rels(List *rel_list)
|
||||
geqo_prune_rels(geqo_prune_rel((RelOptInfo *) lfirst(rel_list),
|
||||
lnext(rel_list))));
|
||||
}
|
||||
return (temp_list);
|
||||
return temp_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -88,7 +88,7 @@ geqo_prune_rel(RelOptInfo *rel, List *other_rels)
|
||||
t_list = nconc(t_list, temp_node);
|
||||
}
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -149,5 +149,5 @@ set_paths(RelOptInfo *rel, Path *unorderedpath)
|
||||
else
|
||||
rel->unorderedpath = (Path *) unorderedpath;
|
||||
|
||||
return (cheapest);
|
||||
return cheapest;
|
||||
}
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_pool.c,v 1.8 1998/06/15 19:28:37 momjian Exp $
|
||||
* $Id: geqo_pool.c,v 1.9 1998/09/01 03:23:13 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -68,7 +68,7 @@ alloc_pool(int pool_size, int string_length)
|
||||
for (i = 0; i < pool_size; i++)
|
||||
chromo[i].string = palloc((string_length + 1) * sizeof(Gene));
|
||||
|
||||
return (new_pool);
|
||||
return new_pool;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -140,11 +140,11 @@ compare(const void *arg1, const void *arg2)
|
||||
Chromosome chromo2 = *(Chromosome *) arg2;
|
||||
|
||||
if (chromo1.worth == chromo2.worth)
|
||||
return (0);
|
||||
return 0;
|
||||
else if (chromo1.worth > chromo2.worth)
|
||||
return (1);
|
||||
return 1;
|
||||
else
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* alloc_chromo--
|
||||
@@ -158,7 +158,7 @@ alloc_chromo(int string_length)
|
||||
chromo = (Chromosome *) palloc(sizeof(Chromosome));
|
||||
chromo->string = (Gene *) palloc((string_length + 1) * sizeof(Gene));
|
||||
|
||||
return (chromo);
|
||||
return chromo;
|
||||
}
|
||||
|
||||
/* free_chromo--
|
||||
|
@@ -3,7 +3,7 @@
|
||||
* geqo_recombination.c--
|
||||
* misc recombination procedures
|
||||
*
|
||||
* $Id: geqo_recombination.c,v 1.5 1998/02/26 04:32:25 momjian Exp $
|
||||
* $Id: geqo_recombination.c,v 1.6 1998/09/01 03:23:15 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -96,7 +96,7 @@ alloc_city_table(int num_gene)
|
||||
|
||||
city_table = (City *) palloc((num_gene + 1) * sizeof(City));
|
||||
|
||||
return (city_table);
|
||||
return city_table;
|
||||
}
|
||||
|
||||
/* free_city_table--
|
||||
|
@@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_selection.c,v 1.4 1997/09/08 21:44:41 momjian Exp $
|
||||
* $Id: geqo_selection.c,v 1.5 1998/09/01 03:23:16 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -101,5 +101,5 @@ linear(int pool_size, double bias) /* bias is y-intercept of linear
|
||||
max * (bias - sqrt((bias * bias) - 4.0 * (bias - 1.0) * geqo_rand()))
|
||||
/ 2.0 / (bias - 1.0);
|
||||
|
||||
return ((int) index);
|
||||
return (int) index;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.21 1998/08/10 04:49:36 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.22 1998/09/01 03:23:17 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -280,7 +280,7 @@ print_joinclauses(Query *root, List *clauses)
|
||||
|
||||
foreach(l, clauses)
|
||||
{
|
||||
CInfo *c = lfirst(l);
|
||||
ClauseInfo *c = lfirst(l);
|
||||
|
||||
print_expr((Node *) c->clause, root->rtable);
|
||||
if (lnext(l))
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.11 1998/08/09 04:17:37 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.12 1998/09/01 03:23:19 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -46,12 +46,12 @@ void
|
||||
set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity)
|
||||
{
|
||||
List *temp;
|
||||
CInfo *clausenode;
|
||||
ClauseInfo *clausenode;
|
||||
Cost cost_clause;
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
{
|
||||
clausenode = (CInfo *) lfirst(temp);
|
||||
clausenode = (ClauseInfo *) lfirst(temp);
|
||||
cost_clause = clausenode->selectivity;
|
||||
if (FLOAT_IS_ZERO(cost_clause) || new_selectivity < cost_clause)
|
||||
clausenode->selectivity = new_selectivity;
|
||||
@@ -76,11 +76,11 @@ product_selec(List *clauseinfo_list)
|
||||
|
||||
foreach(xclausenode, clauseinfo_list)
|
||||
{
|
||||
temp = ((CInfo *) lfirst(xclausenode))->selectivity;
|
||||
temp = ((ClauseInfo *) lfirst(xclausenode))->selectivity;
|
||||
result = result * temp;
|
||||
}
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -117,12 +117,12 @@ void
|
||||
set_rest_selec(Query *root, List *clauseinfo_list)
|
||||
{
|
||||
List *temp = NIL;
|
||||
CInfo *clausenode = (CInfo *) NULL;
|
||||
ClauseInfo *clausenode = (ClauseInfo *) NULL;
|
||||
Cost cost_clause;
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
{
|
||||
clausenode = (CInfo *) lfirst(temp);
|
||||
clausenode = (ClauseInfo *) lfirst(temp);
|
||||
cost_clause = clausenode->selectivity;
|
||||
|
||||
/*
|
||||
@@ -179,11 +179,11 @@ compute_clause_selec(Query *root, Node *clause, List *or_selectivities)
|
||||
* Both 'or' and 'and' clauses are evaluated as described in
|
||||
* (compute_selec).
|
||||
*/
|
||||
return (compute_selec(root, ((Expr *) clause)->args, or_selectivities));
|
||||
return compute_selec(root, ((Expr *) clause)->args, or_selectivities);
|
||||
}
|
||||
else
|
||||
{
|
||||
return (compute_selec(root, lcons(clause, NIL), or_selectivities));
|
||||
return compute_selec(root, lcons(clause, NIL), or_selectivities);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -350,7 +350,7 @@ compute_selec(Query *root, List *clauses, List *or_selectivities)
|
||||
*/
|
||||
|
||||
if (length(clauses) < 2)
|
||||
return (s1);
|
||||
return s1;
|
||||
else
|
||||
{
|
||||
/* Compute selectivity of the 'or'ed subclauses. */
|
||||
@@ -361,6 +361,6 @@ compute_selec(Query *root, List *clauses, List *or_selectivities)
|
||||
s2 = compute_selec(root, lnext(clauses), lnext(or_selectivities));
|
||||
else
|
||||
s2 = compute_selec(root, lnext(clauses), NIL);
|
||||
return (s1 + s2 - s1 * s2);
|
||||
return s1 + s2 - s1 * s2;
|
||||
}
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.23 1998/08/04 16:44:04 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.24 1998/09/01 03:23:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -95,7 +95,7 @@ cost_seqscan(int relid, int relpages, int reltuples)
|
||||
temp += _cpu_page_wight_ * reltuples;
|
||||
}
|
||||
Assert(temp >= 0);
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
||||
@@ -152,7 +152,7 @@ cost_index(Oid indexid,
|
||||
temp = temp + (_cpu_page_wight_ * selec * reltuples);
|
||||
|
||||
Assert(temp >= 0);
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -186,7 +186,7 @@ cost_sort(List *keys, int tuples, int width, bool noread)
|
||||
if (tuples == 0 || keys == NULL)
|
||||
{
|
||||
Assert(temp >= 0);
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
temp += pages * base_log((double) pages, (double) 2.0);
|
||||
|
||||
@@ -201,7 +201,7 @@ cost_sort(List *keys, int tuples, int width, bool noread)
|
||||
temp = temp + cost_seqscan(_TEMP_RELATION_ID_, npages, tuples);
|
||||
Assert(temp >= 0);
|
||||
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
||||
@@ -222,7 +222,7 @@ cost_result(int tuples, int width)
|
||||
temp = temp + page_size(tuples, width);
|
||||
temp = temp + _cpu_page_wight_ * tuples;
|
||||
Assert(temp >= 0);
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -255,7 +255,7 @@ cost_nestloop(Cost outercost,
|
||||
temp += outertuples * innercost;
|
||||
Assert(temp >= 0);
|
||||
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -294,7 +294,7 @@ cost_mergejoin(Cost outercost,
|
||||
temp += _cpu_page_wight_ * (outersize + innersize);
|
||||
Assert(temp >= 0);
|
||||
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -346,7 +346,7 @@ cost_hashjoin(Cost outercost,
|
||||
temp += _cpu_page_wight_ * (outersize + nrun * innersize);
|
||||
Assert(temp >= 0);
|
||||
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -373,7 +373,7 @@ compute_rel_size(RelOptInfo *rel)
|
||||
temp1 = ceil((double) temp);
|
||||
Assert(temp1 >= 0);
|
||||
Assert(temp1 <= MAXINT);
|
||||
return (temp1);
|
||||
return temp1;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -385,7 +385,7 @@ compute_rel_size(RelOptInfo *rel)
|
||||
int
|
||||
compute_rel_width(RelOptInfo *rel)
|
||||
{
|
||||
return (compute_targetlist_width(get_actual_tlist(rel->targetlist)));
|
||||
return compute_targetlist_width(get_actual_tlist(rel->targetlist));
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -405,7 +405,7 @@ compute_targetlist_width(List *targetlist)
|
||||
tuple_width = tuple_width +
|
||||
compute_attribute_width(lfirst(temp_tl));
|
||||
}
|
||||
return (tuple_width);
|
||||
return tuple_width;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -423,9 +423,9 @@ compute_attribute_width(TargetEntry *tlistentry)
|
||||
int width = get_typlen(tlistentry->resdom->restype);
|
||||
|
||||
if (width < 0)
|
||||
return (_DEFAULT_ATTRIBUTE_WIDTH_);
|
||||
return _DEFAULT_ATTRIBUTE_WIDTH_;
|
||||
else
|
||||
return (width);
|
||||
return width;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -457,7 +457,7 @@ compute_joinrel_size(JoinPath *joinpath)
|
||||
}
|
||||
Assert(temp1 >= 0);
|
||||
|
||||
return (temp1);
|
||||
return temp1;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -473,11 +473,11 @@ page_size(int tuples, int width)
|
||||
temp = ceil((double) (tuples * (width + sizeof(HeapTupleData)))
|
||||
/ BLCKSZ);
|
||||
Assert(temp >= 0);
|
||||
return (temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
static double
|
||||
base_log(double x, double b)
|
||||
{
|
||||
return (log(x) / log(b));
|
||||
return log(x) / log(b);
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.5 1998/02/26 04:32:30 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.6 1998/09/01 03:23:22 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -39,13 +39,13 @@ group_clauses_by_hashop(List *clauseinfo_list,
|
||||
int inner_relid)
|
||||
{
|
||||
List *hashinfo_list = NIL;
|
||||
CInfo *clauseinfo = (CInfo *) NULL;
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
List *i = NIL;
|
||||
Oid hashjoinop = 0;
|
||||
|
||||
foreach(i, clauseinfo_list)
|
||||
{
|
||||
clauseinfo = (CInfo *) lfirst(i);
|
||||
clauseinfo = (ClauseInfo *) lfirst(i);
|
||||
hashjoinop = clauseinfo->hashjoinoperator;
|
||||
|
||||
/*
|
||||
@@ -96,7 +96,7 @@ group_clauses_by_hashop(List *clauseinfo_list,
|
||||
lcons(keys, xhashinfo->jmethod.jmkeys);
|
||||
}
|
||||
}
|
||||
return (hashinfo_list);
|
||||
return hashinfo_list;
|
||||
}
|
||||
|
||||
|
||||
@@ -121,8 +121,8 @@ match_hashop_hashinfo(Oid hashop, List *hashinfo_list)
|
||||
key = xhashinfo->hashop;
|
||||
if (hashop == key)
|
||||
{ /* found */
|
||||
return (xhashinfo); /* should be a hashinfo node ! */
|
||||
return xhashinfo; /* should be a hashinfo node ! */
|
||||
}
|
||||
}
|
||||
return ((HInfo *) NIL);
|
||||
return (HInfo *) NIL;
|
||||
}
|
||||
|
@@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.32 1998/08/31 07:19:54 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.33 1998/09/01 03:23:23 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -60,9 +60,9 @@ group_clauses_by_indexkey(RelOptInfo *rel, RelOptInfo *index,
|
||||
static List *
|
||||
group_clauses_by_ikey_for_joins(RelOptInfo *rel, RelOptInfo *index,
|
||||
int *indexkeys, Oid *classes, List *join_cinfo_list, List *restr_cinfo_list);
|
||||
static CInfo *
|
||||
static ClauseInfo *
|
||||
match_clause_to_indexkey(RelOptInfo *rel, RelOptInfo *index, int indexkey,
|
||||
int xclass, CInfo *clauseInfo, bool join);
|
||||
int xclass, ClauseInfo *clauseInfo, bool join);
|
||||
static bool
|
||||
pred_test(List *predicate_list, List *clauseinfo_list,
|
||||
List *joininfo_list);
|
||||
@@ -231,12 +231,12 @@ match_index_orclauses(RelOptInfo *rel,
|
||||
int xclass,
|
||||
List *clauseinfo_list)
|
||||
{
|
||||
CInfo *clauseinfo = (CInfo *) NULL;
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, clauseinfo_list)
|
||||
{
|
||||
clauseinfo = (CInfo *) lfirst(i);
|
||||
clauseinfo = (ClauseInfo *) lfirst(i);
|
||||
if (valid_or_clause(clauseinfo))
|
||||
{
|
||||
|
||||
@@ -350,7 +350,7 @@ match_index_orclause(RelOptInfo *rel,
|
||||
|
||||
matching_indices = lnext(matching_indices);
|
||||
}
|
||||
return (index_list);
|
||||
return index_list;
|
||||
|
||||
}
|
||||
|
||||
@@ -403,7 +403,7 @@ group_clauses_by_indexkey(RelOptInfo *rel,
|
||||
List *clauseinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
CInfo *matched_clause = (CInfo *) NULL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
List *clausegroup = NIL;
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
@@ -420,7 +420,7 @@ group_clauses_by_indexkey(RelOptInfo *rel,
|
||||
|
||||
foreach(curCinfo, clauseinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
@@ -446,7 +446,7 @@ group_clauses_by_indexkey(RelOptInfo *rel,
|
||||
/* clausegroup holds all matched clauses ordered by indexkeys */
|
||||
|
||||
if (clausegroup != NIL)
|
||||
return (lcons(clausegroup, NIL));
|
||||
return lcons(clausegroup, NIL);
|
||||
return NIL;
|
||||
}
|
||||
|
||||
@@ -466,7 +466,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
List *restr_cinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
CInfo *matched_clause = (CInfo *) NULL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
List *clausegroup = NIL;
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
@@ -484,7 +484,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
|
||||
foreach(curCinfo, join_cinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
@@ -500,7 +500,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
}
|
||||
foreach(curCinfo, restr_cinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
@@ -537,7 +537,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
freeList(clausegroup);
|
||||
return NIL;
|
||||
}
|
||||
return (lcons(clausegroup, NIL));
|
||||
return lcons(clausegroup, NIL);
|
||||
}
|
||||
return NIL;
|
||||
}
|
||||
@@ -579,12 +579,12 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
* NOTE: returns nil if clause is an or_clause.
|
||||
*
|
||||
*/
|
||||
static CInfo *
|
||||
static ClauseInfo *
|
||||
match_clause_to_indexkey(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
int indexkey,
|
||||
int xclass,
|
||||
CInfo *clauseInfo,
|
||||
ClauseInfo *clauseInfo,
|
||||
bool join)
|
||||
{
|
||||
Expr *clause = clauseInfo->clause;
|
||||
@@ -596,7 +596,7 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
||||
|
||||
if (or_clause((Node *) clause) ||
|
||||
not_clause((Node *) clause) || single_node((Node *) clause))
|
||||
return ((CInfo *) NULL);
|
||||
return (ClauseInfo *) NULL;
|
||||
|
||||
leftop = get_leftop(clause);
|
||||
rightop = get_rightop(clause);
|
||||
@@ -771,9 +771,9 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
||||
}
|
||||
|
||||
if (isIndexable)
|
||||
return (clauseInfo);
|
||||
return clauseInfo;
|
||||
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
@@ -848,13 +848,13 @@ pred_test(List *predicate_list, List *clauseinfo_list, List *joininfo_list)
|
||||
static bool
|
||||
one_pred_test(Expr *predicate, List *clauseinfo_list)
|
||||
{
|
||||
CInfo *clauseinfo;
|
||||
ClauseInfo *clauseinfo;
|
||||
List *item;
|
||||
|
||||
Assert(predicate != NULL);
|
||||
foreach(item, clauseinfo_list)
|
||||
{
|
||||
clauseinfo = (CInfo *) lfirst(item);
|
||||
clauseinfo = (ClauseInfo *) lfirst(item);
|
||||
/* if any clause implies the predicate, return true */
|
||||
if (one_pred_clause_expr_test(predicate, (Node *) clauseinfo->clause))
|
||||
return true;
|
||||
@@ -1187,7 +1187,7 @@ clause_pred_clause_test(Expr *predicate, Node *clause)
|
||||
*
|
||||
* Returns a list of these clause groups.
|
||||
*
|
||||
* Added: clauseinfo_list - list of restriction CInfos. It's to
|
||||
* Added: clauseinfo_list - list of restriction ClauseInfos. It's to
|
||||
* support multi-column indices in joins and for cases
|
||||
* when a key is in both join & restriction clauses. - vadim 03/18/97
|
||||
*
|
||||
@@ -1196,14 +1196,14 @@ static List *
|
||||
indexable_joinclauses(RelOptInfo *rel, RelOptInfo *index,
|
||||
List *joininfo_list, List *clauseinfo_list)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) NULL;
|
||||
JoinInfo *joininfo = (JoinInfo *) NULL;
|
||||
List *cg_list = NIL;
|
||||
List *i = NIL;
|
||||
List *clausegroups = NIL;
|
||||
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
joininfo = (JInfo *) lfirst(i);
|
||||
joininfo = (JoinInfo *) lfirst(i);
|
||||
|
||||
if (joininfo->jinfoclauseinfo == NIL)
|
||||
continue;
|
||||
@@ -1219,12 +1219,12 @@ indexable_joinclauses(RelOptInfo *rel, RelOptInfo *index,
|
||||
{
|
||||
List *clauses = lfirst(clausegroups);
|
||||
|
||||
((CInfo *) lfirst(clauses))->cinfojoinid =
|
||||
((ClauseInfo *) lfirst(clauses))->cinfojoinid =
|
||||
joininfo->otherrels;
|
||||
}
|
||||
cg_list = nconc(cg_list, clausegroups);
|
||||
}
|
||||
return (cg_list);
|
||||
return cg_list;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
@@ -1245,7 +1245,7 @@ extract_restrict_clauses(List *clausegroup)
|
||||
|
||||
foreach(l, clausegroup)
|
||||
{
|
||||
CInfo *cinfo = lfirst(l);
|
||||
ClauseInfo *cinfo = lfirst(l);
|
||||
|
||||
if (!is_joinable((Node *) cinfo->clause))
|
||||
restrict_cls = lappend(restrict_cls, cinfo);
|
||||
@@ -1305,7 +1305,7 @@ index_innerjoin(Query *root, RelOptInfo *rel, List *clausegroup_list,
|
||||
pathnode->indexkeys = index->indexkeys;
|
||||
pathnode->indexqual = clausegroup;
|
||||
|
||||
pathnode->path.joinid = ((CInfo *) lfirst(clausegroup))->cinfojoinid;
|
||||
pathnode->path.joinid = ((ClauseInfo *) lfirst(clausegroup))->cinfojoinid;
|
||||
|
||||
pathnode->path.path_cost =
|
||||
cost_index((Oid) lfirsti(index->relids),
|
||||
@@ -1335,7 +1335,7 @@ index_innerjoin(Query *root, RelOptInfo *rel, List *clausegroup_list,
|
||||
#endif
|
||||
cg_list = lappend(cg_list, pathnode);
|
||||
}
|
||||
return (cg_list);
|
||||
return cg_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1367,7 +1367,7 @@ create_index_paths(Query *root,
|
||||
|
||||
foreach(i, clausegroup_list)
|
||||
{
|
||||
CInfo *clauseinfo;
|
||||
ClauseInfo *clauseinfo;
|
||||
List *temp_node = NIL;
|
||||
bool temp = true;
|
||||
|
||||
@@ -1375,7 +1375,7 @@ create_index_paths(Query *root,
|
||||
|
||||
foreach(j, clausegroup)
|
||||
{
|
||||
clauseinfo = (CInfo *) lfirst(j);
|
||||
clauseinfo = (ClauseInfo *) lfirst(j);
|
||||
if (!(is_joinable((Node *) clauseinfo->clause) &&
|
||||
equal_path_merge_ordering(index->ordering,
|
||||
clauseinfo->mergejoinorder)))
|
||||
@@ -1389,7 +1389,7 @@ create_index_paths(Query *root,
|
||||
ip_list = nconc(ip_list, temp_node);
|
||||
}
|
||||
}
|
||||
return (ip_list);
|
||||
return ip_list;
|
||||
}
|
||||
|
||||
static List *
|
||||
@@ -1447,10 +1447,10 @@ function_index_operand(Expr *funcOpnd, RelOptInfo *rel, RelOptInfo *index)
|
||||
{
|
||||
|
||||
if (indexKeys[i] == 0)
|
||||
return (false);
|
||||
return false;
|
||||
|
||||
if (((Var *) lfirst(arg))->varattno != indexKeys[i])
|
||||
return (false);
|
||||
return false;
|
||||
|
||||
i++;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.8 1998/08/04 16:44:07 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.9 1998/09/01 03:23:24 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -221,7 +221,7 @@ best_innerjoin(List *join_paths, List *outer_relids)
|
||||
cheapest = (Path *) lfirst(join_path);
|
||||
}
|
||||
}
|
||||
return (cheapest);
|
||||
return cheapest;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -285,7 +285,7 @@ sort_inner_and_outer(RelOptInfo *joinrel,
|
||||
|
||||
ms_list = lappend(ms_list, temp_node);
|
||||
}
|
||||
return (ms_list);
|
||||
return ms_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -442,7 +442,7 @@ match_unsorted_outer(RelOptInfo *joinrel,
|
||||
temp_node = paths;
|
||||
jp_list = nconc(jp_list, temp_node);
|
||||
}
|
||||
return (jp_list);
|
||||
return jp_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -560,7 +560,7 @@ match_unsorted_inner(RelOptInfo *joinrel,
|
||||
}
|
||||
}
|
||||
}
|
||||
return (mp_list);
|
||||
return mp_list;
|
||||
|
||||
}
|
||||
|
||||
@@ -645,5 +645,5 @@ hash_inner_and_outer(RelOptInfo *joinrel,
|
||||
hjoin_list = lappend(hjoin_list, temp_node);
|
||||
}
|
||||
}
|
||||
return (hjoin_list);
|
||||
return hjoin_list;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.13 1998/08/10 02:26:24 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.14 1998/09/01 03:23:25 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -33,7 +33,7 @@ bool _use_right_sided_plans_ = false;
|
||||
|
||||
static List *find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list);
|
||||
static List *find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo);
|
||||
static List *
|
||||
new_join_tlist(List *tlist, List *other_relids,
|
||||
int first_resdomno);
|
||||
@@ -43,7 +43,7 @@ static bool nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2);
|
||||
static bool nonoverlap_sets(List *s1, List *s2);
|
||||
static void
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel,
|
||||
JInfo *jinfo);
|
||||
JoinInfo *jinfo);
|
||||
|
||||
/*
|
||||
* find-join-rels--
|
||||
@@ -80,7 +80,7 @@ find_join_rels(Query *root, List *outer_rels)
|
||||
join_list = nconc(join_list, joins);
|
||||
}
|
||||
|
||||
return (join_list);
|
||||
return join_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -106,7 +106,7 @@ find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list)
|
||||
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(i);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel;
|
||||
|
||||
if (!joininfo->inactive)
|
||||
@@ -146,7 +146,7 @@ find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list)
|
||||
}
|
||||
}
|
||||
|
||||
return (join_list);
|
||||
return join_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -172,13 +172,13 @@ find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels)
|
||||
{
|
||||
temp_node = lcons(init_join_rel(outer_rel,
|
||||
inner_rel,
|
||||
(JInfo *) NULL),
|
||||
(JoinInfo *) NULL),
|
||||
NIL);
|
||||
t_list = nconc(t_list, temp_node);
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -193,7 +193,7 @@ find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels)
|
||||
* Returns the new join relation node.
|
||||
*/
|
||||
static RelOptInfo *
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo)
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
||||
{
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
List *joinrel_joininfo_list = NIL;
|
||||
@@ -253,7 +253,7 @@ init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *joininfo)
|
||||
|
||||
set_joinrel_size(joinrel, outer_rel, inner_rel, joininfo);
|
||||
|
||||
return (joinrel);
|
||||
return joinrel;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -301,7 +301,7 @@ new_join_tlist(List *tlist,
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -327,13 +327,13 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
{
|
||||
List *current_joininfo_list = NIL;
|
||||
List *new_otherrels = NIL;
|
||||
JInfo *other_joininfo = (JInfo *) NULL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
List *xjoininfo = NIL;
|
||||
|
||||
foreach(xjoininfo, joininfo_list)
|
||||
{
|
||||
List *or;
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
new_otherrels = joininfo->otherrels;
|
||||
foreach(or, new_otherrels)
|
||||
@@ -354,7 +354,7 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
}
|
||||
else
|
||||
{
|
||||
other_joininfo = makeNode(JInfo);
|
||||
other_joininfo = makeNode(JoinInfo);
|
||||
|
||||
other_joininfo->otherrels =
|
||||
joininfo->otherrels;
|
||||
@@ -372,7 +372,7 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
||||
}
|
||||
}
|
||||
|
||||
return (current_joininfo_list);
|
||||
return current_joininfo_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -412,7 +412,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
|
||||
foreach(xjoininfo, joinrel->joininfo)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
List *other_rels = joininfo->otherrels;
|
||||
List *clause_info = joininfo->jinfoclauseinfo;
|
||||
bool mergejoinable = joininfo->mergejoinable;
|
||||
@@ -424,7 +424,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
RelOptInfo *rel = get_join_rel(root, relid);
|
||||
List *super_rels = rel->superrels;
|
||||
List *xsuper_rel = NIL;
|
||||
JInfo *new_joininfo = makeNode(JInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = joinrel->relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
@@ -441,7 +441,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
if (nonoverlap_rels(super_rel, joinrel))
|
||||
{
|
||||
List *new_relids = super_rel->relids;
|
||||
JInfo *other_joininfo =
|
||||
JoinInfo *other_joininfo =
|
||||
joininfo_member(new_relids,
|
||||
joinrel->joininfo);
|
||||
|
||||
@@ -453,7 +453,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
||||
}
|
||||
else
|
||||
{
|
||||
JInfo *new_joininfo = makeNode(JInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = new_relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
@@ -505,7 +505,7 @@ final_join_rels(List *join_rel_list)
|
||||
|
||||
foreach(xjoininfo, rel->joininfo)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (joininfo->otherrels != NIL)
|
||||
{
|
||||
@@ -520,7 +520,7 @@ final_join_rels(List *join_rel_list)
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -550,7 +550,7 @@ add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
||||
static bool
|
||||
nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2)
|
||||
{
|
||||
return (nonoverlap_sets(rel1->relids, rel2->relids));
|
||||
return nonoverlap_sets(rel1->relids, rel2->relids);
|
||||
}
|
||||
|
||||
static bool
|
||||
@@ -563,13 +563,13 @@ nonoverlap_sets(List *s1, List *s2)
|
||||
int e = lfirsti(x);
|
||||
|
||||
if (intMember(e, s2))
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
return (true);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, JInfo *jinfo)
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *jinfo)
|
||||
{
|
||||
int ntuples;
|
||||
float selec;
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.6 1998/06/15 19:28:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.7 1998/09/01 03:23:27 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -106,7 +106,7 @@ match_pathkeys_joinkeys(List *pathkeys,
|
||||
joinkeys = LispRemove(xjoinkey, joinkeys);
|
||||
}
|
||||
else
|
||||
return (NIL);
|
||||
return NIL;
|
||||
|
||||
}
|
||||
if (matched_joinkeys == NULL ||
|
||||
@@ -114,7 +114,7 @@ match_pathkeys_joinkeys(List *pathkeys,
|
||||
return NIL;
|
||||
|
||||
*matchedJoinClausesPtr = nreverse(matched_joinclauses);
|
||||
return (nreverse(matched_joinkeys));
|
||||
return nreverse(matched_joinkeys);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -142,11 +142,11 @@ match_pathkey_joinkeys(List *pathkey,
|
||||
jk = (JoinKey *) lfirst(x);
|
||||
if (var_equal(path_subkey,
|
||||
extract_subkey(jk, which_subkey)))
|
||||
return (pos);
|
||||
return pos;
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
return (-1); /* no index found */
|
||||
return -1; /* no index found */
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -197,9 +197,9 @@ every_func(List *joinkeys, List *pathkey, int which_subkey)
|
||||
}
|
||||
}
|
||||
if (found == false)
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
return (found);
|
||||
return found;
|
||||
}
|
||||
|
||||
|
||||
@@ -294,7 +294,7 @@ extract_path_keys(List *joinkeys,
|
||||
pathkeys =
|
||||
lappend(pathkeys, lcons(key, NIL));
|
||||
}
|
||||
return (pathkeys);
|
||||
return pathkeys;
|
||||
}
|
||||
|
||||
|
||||
@@ -337,7 +337,7 @@ new_join_pathkeys(List *outer_pathkeys,
|
||||
if (x != NIL)
|
||||
t_list = lappend(t_list, x);
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -395,7 +395,7 @@ new_join_pathkey(List *subkeys,
|
||||
|
||||
t_list = nconc(t_list, newly_considered_subkeys);
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -451,5 +451,5 @@ new_matching_subkeys(Var *subkey,
|
||||
t_list = nconc(t_list, temp);
|
||||
}
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.7 1998/08/04 16:44:10 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.8 1998/09/01 03:23:28 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -42,7 +42,7 @@ group_clauses_by_order(List *clauseinfo_list,
|
||||
|
||||
foreach(xclauseinfo, clauseinfo_list)
|
||||
{
|
||||
CInfo *clauseinfo = (CInfo *) lfirst(xclauseinfo);
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) lfirst(xclauseinfo);
|
||||
MergeOrder *merge_ordering = clauseinfo->mergejoinorder;
|
||||
|
||||
if (merge_ordering)
|
||||
@@ -92,7 +92,7 @@ group_clauses_by_order(List *clauseinfo_list,
|
||||
((JoinMethod *) xmergeinfo)->jmkeys);
|
||||
}
|
||||
}
|
||||
return (mergeinfo_list);
|
||||
return mergeinfo_list;
|
||||
}
|
||||
|
||||
|
||||
@@ -122,8 +122,8 @@ match_order_mergeinfo(PathOrder *ordering, List *mergeinfo_list)
|
||||
equal_path_merge_ordering(ordering->ord.sortop, xmergeorder)))
|
||||
{
|
||||
|
||||
return (mergeinfo);
|
||||
return mergeinfo;
|
||||
}
|
||||
}
|
||||
return ((MInfo *) NIL);
|
||||
return (MInfo *) NIL;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.9 1998/08/31 07:19:55 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.10 1998/09/01 03:23:29 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -59,7 +59,7 @@ create_or_index_paths(Query *root,
|
||||
|
||||
foreach(clist, clauses)
|
||||
{
|
||||
CInfo *clausenode = (CInfo *) (lfirst(clist));
|
||||
ClauseInfo *clausenode = (ClauseInfo *) (lfirst(clist));
|
||||
|
||||
/*
|
||||
* Check to see if this clause is an 'or' clause, and, if so,
|
||||
@@ -131,7 +131,7 @@ create_or_index_paths(Query *root,
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.11 1998/06/15 19:28:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.12 1998/09/01 03:23:30 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -67,7 +67,7 @@ static void xfunc_free_stream(Stream root);
|
||||
static Stream xfunc_add_clauses(Stream current);
|
||||
static void xfunc_setup_group(Stream node, Stream bottom);
|
||||
static Stream
|
||||
xfunc_streaminsert(CInfo clauseinfo, Stream current,
|
||||
xfunc_streaminsert(ClauseInfo clauseinfo, Stream current,
|
||||
int clausetype);
|
||||
static int xfunc_num_relids(Stream node);
|
||||
static StreamPtr xfunc_get_downjoin(Stream node);
|
||||
@@ -102,7 +102,7 @@ xfunc_do_predmig(Path root)
|
||||
if (progress)
|
||||
changed = true;
|
||||
} while (progress);
|
||||
return (changed);
|
||||
return changed;
|
||||
}
|
||||
|
||||
|
||||
@@ -145,7 +145,7 @@ xfunc_predmig(JoinPath pathnode,/* root of the join tree */
|
||||
set_downstream(laststream, (StreamPtr) newstream);
|
||||
set_downstream(newstream, (StreamPtr) NULL);
|
||||
set_pathptr(newstream, (pathPtr) pathnode);
|
||||
set_cinfo(newstream, (CInfo) NULL);
|
||||
set_cinfo(newstream, (ClauseInfo) NULL);
|
||||
set_clausetype(newstream, XFUNC_UNKNOWN);
|
||||
|
||||
/* base case: we're at a leaf, call xfunc_series_llel */
|
||||
@@ -203,7 +203,7 @@ xfunc_series_llel(Stream stream)
|
||||
if (xfunc_llel_chains(stream, temp))
|
||||
progress = true;
|
||||
}
|
||||
return (progress);
|
||||
return progress;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -270,7 +270,7 @@ xfunc_llel_chains(Stream root, Stream bottom)
|
||||
|
||||
/* free up origstream */
|
||||
xfunc_free_stream(origstream);
|
||||
return (progress);
|
||||
return progress;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -304,7 +304,7 @@ xfunc_complete_stream(Stream stream)
|
||||
tmpstream = (Stream) get_upstream(tmpstream))
|
||||
/* no body in for loop */ ;
|
||||
|
||||
return (tmpstream);
|
||||
return tmpstream;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -318,7 +318,7 @@ xfunc_complete_stream(Stream stream)
|
||||
static bool
|
||||
xfunc_prdmig_pullup(Stream origstream, Stream pullme, JoinPath joinpath)
|
||||
{
|
||||
CInfo clauseinfo = get_cinfo(pullme);
|
||||
ClauseInfo clauseinfo = get_cinfo(pullme);
|
||||
bool progress = false;
|
||||
Stream upjoin,
|
||||
orignode,
|
||||
@@ -391,7 +391,7 @@ xfunc_prdmig_pullup(Stream origstream, Stream pullme, JoinPath joinpath)
|
||||
}
|
||||
if (!progress)
|
||||
elog(DEBUG, "didn't succeed in pulling up in xfunc_prdmig_pullup");
|
||||
return (progress);
|
||||
return progress;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -530,7 +530,7 @@ xfunc_add_clauses(Stream current)
|
||||
foreach(temp, get_locclauseinfo((Path) get_pathptr(current)))
|
||||
{
|
||||
topnode =
|
||||
xfunc_streaminsert((CInfo) lfirst(temp), topnode,
|
||||
xfunc_streaminsert((ClauseInfo) lfirst(temp), topnode,
|
||||
XFUNC_LOCPRD);
|
||||
}
|
||||
|
||||
@@ -540,13 +540,13 @@ xfunc_add_clauses(Stream current)
|
||||
primjoin = xfunc_primary_join((JoinPath) get_pathptr(current));
|
||||
foreach(temp, get_pathclauseinfo((JoinPath) get_pathptr(current)))
|
||||
{
|
||||
if (!equal(get_clause((CInfo) lfirst(temp)), primjoin))
|
||||
if (!equal(get_clause((ClauseInfo) lfirst(temp)), primjoin))
|
||||
topnode =
|
||||
xfunc_streaminsert((CInfo) lfirst(temp), topnode,
|
||||
xfunc_streaminsert((ClauseInfo) lfirst(temp), topnode,
|
||||
XFUNC_JOINPRD);
|
||||
}
|
||||
}
|
||||
return (topnode);
|
||||
return topnode;
|
||||
}
|
||||
|
||||
|
||||
@@ -596,7 +596,7 @@ xfunc_setup_group(Stream node, Stream bottom)
|
||||
** Return new node.
|
||||
*/
|
||||
static Stream
|
||||
xfunc_streaminsert(CInfo clauseinfo,
|
||||
xfunc_streaminsert(ClauseInfo clauseinfo,
|
||||
Stream current,
|
||||
int clausetype) /* XFUNC_LOCPRD or XFUNC_JOINPRD */
|
||||
{
|
||||
@@ -610,7 +610,7 @@ xfunc_streaminsert(CInfo clauseinfo,
|
||||
set_pathptr(newstream, get_pathptr(current));
|
||||
set_cinfo(newstream, clauseinfo);
|
||||
set_clausetype(newstream, clausetype);
|
||||
return (newstream);
|
||||
return newstream;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -623,7 +623,7 @@ static int
|
||||
xfunc_num_relids(Stream node)
|
||||
{
|
||||
if (!node || !IsA(get_pathptr(node), JoinPath))
|
||||
return (0);
|
||||
return 0;
|
||||
else
|
||||
return (length
|
||||
(get_relids(get_parent((JoinPath) get_pathptr(node)))));
|
||||
@@ -645,7 +645,7 @@ xfunc_get_downjoin(Stream node)
|
||||
temp = (Stream) get_downstream(temp))
|
||||
/* empty body in for loop */ ;
|
||||
|
||||
return ((StreamPtr) temp);
|
||||
return (StreamPtr) temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -663,7 +663,7 @@ xfunc_get_upjoin(Stream node)
|
||||
temp = (Stream) get_upstream(temp))
|
||||
/* empty body in for loop */ ;
|
||||
|
||||
return ((StreamPtr) temp);
|
||||
return (StreamPtr) temp;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -685,7 +685,7 @@ xfunc_stream_qsort(Stream root, Stream bottom)
|
||||
tmp = (Stream) get_downstream(tmp))
|
||||
num++;
|
||||
if (num <= 1)
|
||||
return (root);
|
||||
return root;
|
||||
|
||||
/* copy elements of the list into an array */
|
||||
nodearray = (Stream *) palloc(num * sizeof(Stream));
|
||||
@@ -710,7 +710,7 @@ xfunc_stream_qsort(Stream root, Stream bottom)
|
||||
set_upstream(bottom, (StreamPtr) nodearray[0]);
|
||||
|
||||
Assert(xfunc_check_stream(output));
|
||||
return (output);
|
||||
return output;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -731,33 +731,33 @@ xfunc_stream_compare(void *arg1, void *arg2)
|
||||
rank2 = get_grouprank(stream2);
|
||||
|
||||
if (rank1 > rank2)
|
||||
return (1);
|
||||
return 1;
|
||||
else if (rank1 < rank2)
|
||||
return (-1);
|
||||
return -1;
|
||||
else
|
||||
{
|
||||
if (is_clause(stream1) && is_clause(stream2))
|
||||
return (0); /* doesn't matter what order if both are
|
||||
return 0; /* doesn't matter what order if both are
|
||||
* restrictions */
|
||||
else if (!is_clause(stream1) && !is_clause(stream2))
|
||||
{
|
||||
if (xfunc_num_relids(stream1) < xfunc_num_relids(stream2))
|
||||
return (-1);
|
||||
return -1;
|
||||
else
|
||||
return (1);
|
||||
return 1;
|
||||
}
|
||||
else if (is_clause(stream1) && !is_clause(stream2))
|
||||
{
|
||||
if (xfunc_num_relids(stream1) == xfunc_num_relids(stream2))
|
||||
/* stream1 is a restriction over stream2 */
|
||||
return (1);
|
||||
return 1;
|
||||
else
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
else if (!is_clause(stream1) && is_clause(stream2))
|
||||
{
|
||||
/* stream2 is a restriction over stream1: never push down */
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -788,20 +788,20 @@ xfunc_check_stream(Stream node)
|
||||
if ((Stream) get_upstream((Stream) get_downstream(temp)) != temp)
|
||||
{
|
||||
elog(ERROR, "bad pointers in stream");
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
if (!is_clause(temp))
|
||||
{
|
||||
if ((tmp = xfunc_num_relids(temp)) >= numrelids)
|
||||
{
|
||||
elog(ERROR, "Joins got reordered!");
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
numrelids = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
return (true);
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -815,6 +815,6 @@ xfunc_in_stream(Stream node, Stream stream)
|
||||
|
||||
for (temp = stream; temp; temp = (Stream) get_downstream(temp))
|
||||
if (temp == node)
|
||||
return (1);
|
||||
return (0);
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.15 1998/07/18 04:22:34 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.16 1998/09/01 03:23:32 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -77,7 +77,7 @@ prune_joinrel(RelOptInfo *rel, List *other_rels)
|
||||
else
|
||||
result = nconc(result, lcons(other_rel, NIL));
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -145,7 +145,7 @@ prune_rel_path(RelOptInfo *rel, Path *unorderedpath)
|
||||
else
|
||||
rel->unorderedpath = (Path *) unorderedpath;
|
||||
|
||||
return (cheapest);
|
||||
return cheapest;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -169,7 +169,7 @@ merge_joinrels(List *rel_list1, List *rel_list2)
|
||||
|
||||
rel_list2 = prune_joinrel(rel, rel_list2);
|
||||
}
|
||||
return (append(rel_list1, rel_list2));
|
||||
return append(rel_list1, rel_list2);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -204,7 +204,7 @@ prune_oldrels(List *old_rels)
|
||||
{
|
||||
foreach(xjoininfo, joininfo_list)
|
||||
{
|
||||
JInfo *joininfo = (JInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (!joininfo->inactive)
|
||||
{
|
||||
|
@@ -9,7 +9,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.20 1998/08/24 01:37:53 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.21 1998/09/01 03:23:33 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -60,7 +60,7 @@ void
|
||||
xfunc_trypullup(RelOptInfo rel)
|
||||
{
|
||||
LispValue y; /* list ptr */
|
||||
CInfo maxcinfo; /* The CInfo to pull up, as calculated by
|
||||
ClauseInfo maxcinfo; /* The ClauseInfo to pull up, as calculated by
|
||||
* xfunc_shouldpull() */
|
||||
JoinPath curpath; /* current path in list */
|
||||
int progress; /* has progress been made this time
|
||||
@@ -147,12 +147,12 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
Path childpath,
|
||||
JoinPath parentpath,
|
||||
int whichchild,
|
||||
CInfo *maxcinfopt) /* Out: pointer to clause to
|
||||
ClauseInfo *maxcinfopt) /* Out: pointer to clause to
|
||||
* pullup */
|
||||
{
|
||||
LispValue clauselist,
|
||||
tmplist; /* lists of clauses */
|
||||
CInfo maxcinfo; /* clause to pullup */
|
||||
ClauseInfo maxcinfo; /* clause to pullup */
|
||||
LispValue primjoinclause /* primary join clause */
|
||||
= xfunc_primary_join(parentpath);
|
||||
Cost tmprank,
|
||||
@@ -167,16 +167,16 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
{
|
||||
/* find local predicate with maximum rank */
|
||||
for (tmplist = clauselist,
|
||||
maxcinfo = (CInfo) lfirst(tmplist),
|
||||
maxcinfo = (ClauseInfo) lfirst(tmplist),
|
||||
maxrank = xfunc_rank(get_clause(maxcinfo));
|
||||
tmplist != LispNil;
|
||||
tmplist = lnext(tmplist))
|
||||
{
|
||||
|
||||
if ((tmprank = xfunc_rank(get_clause((CInfo) lfirst(tmplist))))
|
||||
if ((tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
|
||||
> maxrank)
|
||||
{
|
||||
maxcinfo = (CInfo) lfirst(tmplist);
|
||||
maxcinfo = (ClauseInfo) lfirst(tmplist);
|
||||
maxrank = tmprank;
|
||||
}
|
||||
}
|
||||
@@ -194,16 +194,16 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
{
|
||||
|
||||
if (tmplist != LispNil &&
|
||||
(tmprank = xfunc_rank(get_clause((CInfo) lfirst(tmplist))))
|
||||
(tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
|
||||
> maxrank)
|
||||
{
|
||||
maxcinfo = (CInfo) lfirst(tmplist);
|
||||
maxcinfo = (ClauseInfo) lfirst(tmplist);
|
||||
maxrank = tmprank;
|
||||
retval = XFUNC_JOINPRD;
|
||||
}
|
||||
}
|
||||
if (maxrank == (-1 * MAXFLOAT)) /* no expensive clauses */
|
||||
return (0);
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* * Pullup over join if clause is higher rank than join, or if * join
|
||||
@@ -233,7 +233,7 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
{
|
||||
|
||||
*maxcinfopt = maxcinfo;
|
||||
return (retval);
|
||||
return retval;
|
||||
|
||||
}
|
||||
else if (maxrank != -(MAXFLOAT))
|
||||
@@ -248,7 +248,7 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
/* and fall through */
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -261,13 +261,13 @@ xfunc_shouldpull(Query *queryInfo,
|
||||
** in the query; it's merely a parent for the new childpath.
|
||||
** We also have to fix up the path costs of the child and parent.
|
||||
**
|
||||
** Now returns a pointer to the new pulled-up CInfo. -- JMH, 11/18/92
|
||||
** Now returns a pointer to the new pulled-up ClauseInfo. -- JMH, 11/18/92
|
||||
*/
|
||||
CInfo
|
||||
ClauseInfo
|
||||
xfunc_pullup(Query *queryInfo,
|
||||
Path childpath,
|
||||
JoinPath parentpath,
|
||||
CInfo cinfo, /* clause to pull up */
|
||||
ClauseInfo cinfo, /* clause to pull up */
|
||||
int whichchild, /* whether child is INNER or OUTER of join */
|
||||
int clausetype) /* whether clause to pull is join or local */
|
||||
{
|
||||
@@ -275,7 +275,7 @@ xfunc_pullup(Query *queryInfo,
|
||||
RelOptInfo newrel;
|
||||
Cost pulled_selec;
|
||||
Cost cost;
|
||||
CInfo newinfo;
|
||||
ClauseInfo newinfo;
|
||||
|
||||
/* remove clause from childpath */
|
||||
newkid = (Path) copyObject((Node) childpath);
|
||||
@@ -321,7 +321,7 @@ xfunc_pullup(Query *queryInfo,
|
||||
* * We copy the cinfo, since it may appear in other plans, and we're
|
||||
* going * to munge it. -- JMH, 7/22/92
|
||||
*/
|
||||
newinfo = (CInfo) copyObject((Node) cinfo);
|
||||
newinfo = (ClauseInfo) copyObject((Node) cinfo);
|
||||
|
||||
/*
|
||||
* * Fix all vars in the clause * to point to the right varno and
|
||||
@@ -346,7 +346,7 @@ xfunc_pullup(Query *queryInfo,
|
||||
cost = xfunc_total_path_cost(parentpath);
|
||||
set_path_cost(parentpath, cost);
|
||||
|
||||
return (newinfo);
|
||||
return newinfo;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -360,10 +360,10 @@ xfunc_rank(Query *queryInfo, LispValue clause)
|
||||
|
||||
if (cost == 0)
|
||||
if (selec > 1)
|
||||
return (MAXFLOAT);
|
||||
return MAXFLOAT;
|
||||
else
|
||||
return (-(MAXFLOAT));
|
||||
return ((selec - 1) / cost);
|
||||
return -(MAXFLOAT);
|
||||
return (selec - 1) / cost;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -385,7 +385,7 @@ LispValue clause;
|
||||
cost /= card;
|
||||
}
|
||||
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -414,7 +414,7 @@ xfunc_join_expense(Query *queryInfo, JoinPath path, int whichchild)
|
||||
if (card)
|
||||
cost /= card;
|
||||
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -429,13 +429,13 @@ xfunc_local_expense(LispValue clause)
|
||||
|
||||
/* First handle the base case */
|
||||
if (IsA(clause, Const) ||IsA(clause, Var) ||IsA(clause, Param))
|
||||
return (0);
|
||||
return 0;
|
||||
/* now other stuff */
|
||||
else if (IsA(clause, Iter))
|
||||
/* Too low. Should multiply by the expected number of iterations. */
|
||||
return (xfunc_local_expense(get_iterexpr((Iter) clause)));
|
||||
return xfunc_local_expense(get_iterexpr((Iter) clause));
|
||||
else if (IsA(clause, ArrayRef))
|
||||
return (xfunc_local_expense(get_refexpr((ArrayRef) clause)));
|
||||
return xfunc_local_expense(get_refexpr((ArrayRef) clause));
|
||||
else if (fast_is_clause(clause))
|
||||
return (xfunc_func_expense((LispValue) get_op(clause),
|
||||
(LispValue) get_opargs(clause)));
|
||||
@@ -443,19 +443,19 @@ xfunc_local_expense(LispValue clause)
|
||||
return (xfunc_func_expense((LispValue) get_function(clause),
|
||||
(LispValue) get_funcargs(clause)));
|
||||
else if (fast_not_clause(clause))
|
||||
return (xfunc_local_expense(lsecond(clause)));
|
||||
return xfunc_local_expense(lsecond(clause));
|
||||
else if (fast_or_clause(clause) || fast_and_clause(clause))
|
||||
{
|
||||
/* find cost of evaluating each disjunct */
|
||||
for (tmpclause = lnext(clause); tmpclause != LispNil;
|
||||
tmpclause = lnext(tmpclause))
|
||||
cost += xfunc_local_expense(lfirst(tmpclause));
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
else
|
||||
{
|
||||
elog(ERROR, "Clause node of undetermined type");
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -545,7 +545,7 @@ xfunc_func_expense(LispValue node, LispValue args)
|
||||
*/
|
||||
foreach(tmpplan, planlist)
|
||||
cost += get_cost((Plan) lfirst(tmpplan));
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
else
|
||||
{ /* it's a C function */
|
||||
@@ -593,7 +593,7 @@ xfunc_width(LispValue clause)
|
||||
{
|
||||
Relation rd; /* Relation Descriptor */
|
||||
HeapTuple tupl; /* structure to hold a cached tuple */
|
||||
TypeTupleForm type; /* structure to hold a type tuple */
|
||||
Form_pg_type type; /* structure to hold a type tuple */
|
||||
int retval = 0;
|
||||
|
||||
if (IsA(clause, Const))
|
||||
@@ -617,7 +617,7 @@ xfunc_width(LispValue clause)
|
||||
if (!HeapTupleIsValid(tupl))
|
||||
elog(ERROR, "Cache lookup failed for type %d",
|
||||
get_vartype((Var) clause));
|
||||
type = (TypeTupleForm) GETSTRUCT(tupl);
|
||||
type = (Form_pg_type) GETSTRUCT(tupl);
|
||||
if (get_varattno((Var) clause) == 0)
|
||||
{
|
||||
/* clause is a tuple. Get its width */
|
||||
@@ -682,7 +682,7 @@ xfunc_width(LispValue clause)
|
||||
elog(ERROR, "Cache lookup failed for procedure %d",
|
||||
get_opno((Oper) get_op(clause)));
|
||||
return (xfunc_func_width
|
||||
((RegProcedure) (((OperatorTupleForm) (GETSTRUCT(tupl)))->oprcode),
|
||||
((RegProcedure) (((Form_pg_operator) (GETSTRUCT(tupl)))->oprcode),
|
||||
(LispValue) get_opargs(clause)));
|
||||
}
|
||||
else if (fast_is_funcclause(clause))
|
||||
@@ -711,13 +711,13 @@ xfunc_width(LispValue clause)
|
||||
else
|
||||
{
|
||||
elog(ERROR, "Clause node of undetermined type");
|
||||
return (-1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
exit:
|
||||
if (retval == -1)
|
||||
retval = VARLEN_DEFAULT;
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -748,7 +748,7 @@ xfunc_card_unreferenced(Query *queryInfo,
|
||||
referenced = xfunc_find_references(clause);
|
||||
unreferenced = set_difference(allrelids, referenced);
|
||||
|
||||
return (xfunc_card_product(unreferenced));
|
||||
return xfunc_card_product(unreferenced);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -774,10 +774,10 @@ xfunc_card_product(Query *queryInfo, Relid relids)
|
||||
/* factor in the selectivity of all zero-cost clauses */
|
||||
foreach(cinfonode, get_clauseinfo(currel))
|
||||
{
|
||||
if (!xfunc_expense(queryInfo, get_clause((CInfo) lfirst(cinfonode))))
|
||||
if (!xfunc_expense(queryInfo, get_clause((ClauseInfo) lfirst(cinfonode))))
|
||||
tuples *=
|
||||
compute_clause_selec(queryInfo,
|
||||
get_clause((CInfo) lfirst(cinfonode)),
|
||||
get_clause((ClauseInfo) lfirst(cinfonode)),
|
||||
LispNil);
|
||||
}
|
||||
|
||||
@@ -789,7 +789,7 @@ xfunc_card_product(Query *queryInfo, Relid relids)
|
||||
}
|
||||
if (retval == 0)
|
||||
retval = 1; /* saves caller from dividing by zero */
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
@@ -805,9 +805,9 @@ xfunc_find_references(LispValue clause)
|
||||
|
||||
/* Base cases */
|
||||
if (IsA(clause, Var))
|
||||
return (lispCons(lfirst(get_varid((Var) clause)), LispNil));
|
||||
return lispCons(lfirst(get_varid((Var) clause)), LispNil);
|
||||
else if (IsA(clause, Const) ||IsA(clause, Param))
|
||||
return ((List) LispNil);
|
||||
return (List) LispNil;
|
||||
|
||||
/* recursion */
|
||||
else if (IsA(clause, Iter))
|
||||
@@ -816,16 +816,16 @@ xfunc_find_references(LispValue clause)
|
||||
* Too low. Should multiply by the expected number of iterations.
|
||||
* maybe
|
||||
*/
|
||||
return (xfunc_find_references(get_iterexpr((Iter) clause)));
|
||||
return xfunc_find_references(get_iterexpr((Iter) clause));
|
||||
else if (IsA(clause, ArrayRef))
|
||||
return (xfunc_find_references(get_refexpr((ArrayRef) clause)));
|
||||
return xfunc_find_references(get_refexpr((ArrayRef) clause));
|
||||
else if (fast_is_clause(clause))
|
||||
{
|
||||
/* string together result of all operands of Oper */
|
||||
for (tmpclause = (LispValue) get_opargs(clause); tmpclause != LispNil;
|
||||
tmpclause = lnext(tmpclause))
|
||||
retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
else if (fast_is_funcclause(clause))
|
||||
{
|
||||
@@ -834,22 +834,22 @@ xfunc_find_references(LispValue clause)
|
||||
tmpclause != LispNil;
|
||||
tmpclause = lnext(tmpclause))
|
||||
retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
else if (fast_not_clause(clause))
|
||||
return (xfunc_find_references(lsecond(clause)));
|
||||
return xfunc_find_references(lsecond(clause));
|
||||
else if (fast_or_clause(clause) || fast_and_clause(clause))
|
||||
{
|
||||
/* string together result of all operands of OR */
|
||||
for (tmpclause = lnext(clause); tmpclause != LispNil;
|
||||
tmpclause = lnext(tmpclause))
|
||||
retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
else
|
||||
{
|
||||
elog(ERROR, "Clause node of undetermined type");
|
||||
return ((List) LispNil);
|
||||
return (List) LispNil;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -863,7 +863,7 @@ LispValue
|
||||
xfunc_primary_join(JoinPath pathnode)
|
||||
{
|
||||
LispValue joinclauselist = get_pathclauseinfo(pathnode);
|
||||
CInfo mincinfo;
|
||||
ClauseInfo mincinfo;
|
||||
LispValue tmplist;
|
||||
LispValue minclause = LispNil;
|
||||
Cost minrank,
|
||||
@@ -882,7 +882,7 @@ xfunc_primary_join(JoinPath pathnode)
|
||||
minrank = tmprank;
|
||||
minclause = lfirst(tmplist);
|
||||
}
|
||||
return (minclause);
|
||||
return minclause;
|
||||
}
|
||||
else if (IsA(pathnode, HashPath))
|
||||
{
|
||||
@@ -897,24 +897,24 @@ xfunc_primary_join(JoinPath pathnode)
|
||||
minrank = tmprank;
|
||||
minclause = lfirst(tmplist);
|
||||
}
|
||||
return (minclause);
|
||||
return minclause;
|
||||
}
|
||||
|
||||
/* if we drop through, it's nested loop join */
|
||||
if (joinclauselist == LispNil)
|
||||
return (LispNil);
|
||||
return LispNil;
|
||||
|
||||
for (tmplist = joinclauselist, mincinfo = (CInfo) lfirst(joinclauselist),
|
||||
minrank = xfunc_rank(get_clause((CInfo) lfirst(tmplist)));
|
||||
for (tmplist = joinclauselist, mincinfo = (ClauseInfo) lfirst(joinclauselist),
|
||||
minrank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist)));
|
||||
tmplist != LispNil;
|
||||
tmplist = lnext(tmplist))
|
||||
if ((tmprank = xfunc_rank(get_clause((CInfo) lfirst(tmplist))))
|
||||
if ((tmprank = xfunc_rank(get_clause((ClauseInfo) lfirst(tmplist))))
|
||||
< minrank)
|
||||
{
|
||||
minrank = tmprank;
|
||||
mincinfo = (CInfo) lfirst(tmplist);
|
||||
mincinfo = (ClauseInfo) lfirst(tmplist);
|
||||
}
|
||||
return ((LispValue) get_clause(mincinfo));
|
||||
return (LispValue) get_clause(mincinfo);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -942,10 +942,10 @@ xfunc_get_path_cost(Query *queryInfo, Path pathnode)
|
||||
tmplist != LispNil;
|
||||
tmplist = lnext(tmplist))
|
||||
{
|
||||
cost += (Cost) (xfunc_local_expense(get_clause((CInfo) lfirst(tmplist)))
|
||||
cost += (Cost) (xfunc_local_expense(get_clause((ClauseInfo) lfirst(tmplist)))
|
||||
* (Cost) get_tuples(get_parent(pathnode)) * selec);
|
||||
selec *= compute_clause_selec(queryInfo,
|
||||
get_clause((CInfo) lfirst(tmplist)),
|
||||
get_clause((ClauseInfo) lfirst(tmplist)),
|
||||
LispNil);
|
||||
}
|
||||
|
||||
@@ -963,10 +963,10 @@ xfunc_get_path_cost(Query *queryInfo, Path pathnode)
|
||||
tmplist != LispNil;
|
||||
tmplist = lnext(tmplist))
|
||||
{
|
||||
cost += (Cost) (xfunc_local_expense(get_clause((CInfo) lfirst(tmplist)))
|
||||
cost += (Cost) (xfunc_local_expense(get_clause((ClauseInfo) lfirst(tmplist)))
|
||||
* (Cost) get_tuples(get_parent(pathnode)) * selec);
|
||||
selec *= compute_clause_selec(queryInfo,
|
||||
get_clause((CInfo) lfirst(tmplist)),
|
||||
get_clause((ClauseInfo) lfirst(tmplist)),
|
||||
LispNil);
|
||||
}
|
||||
}
|
||||
@@ -1005,7 +1005,7 @@ xfunc_get_path_cost(Query *queryInfo, Path pathnode)
|
||||
}
|
||||
}
|
||||
Assert(cost >= 0);
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1037,7 +1037,7 @@ xfunc_total_path_cost(JoinPath pathnode)
|
||||
get_width(get_parent((Path) get_innerjoinpath
|
||||
(mrgnode))));
|
||||
Assert(cost >= 0);
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
else if (IsA(pathnode, HashPath))
|
||||
{
|
||||
@@ -1056,7 +1056,7 @@ xfunc_total_path_cost(JoinPath pathnode)
|
||||
get_width(get_parent((Path) get_innerjoinpath
|
||||
(hashnode))));
|
||||
Assert(cost >= 0);
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
else
|
||||
/* Nested Loop Join */
|
||||
@@ -1071,7 +1071,7 @@ xfunc_total_path_cost(JoinPath pathnode)
|
||||
(pathnode))),
|
||||
IsA(get_innerjoinpath(pathnode), IndexPath));
|
||||
Assert(cost >= 0);
|
||||
return (cost);
|
||||
return cost;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1105,7 +1105,7 @@ xfunc_expense_per_tuple(JoinPath joinnode, int whichchild)
|
||||
if (IsA(joinnode, HashPath))
|
||||
{
|
||||
if (whichchild == INNER)
|
||||
return ((1 + _CPU_PAGE_WEIGHT_) * outers_per_page / NBuffers);
|
||||
return (1 + _CPU_PAGE_WEIGHT_) * outers_per_page / NBuffers;
|
||||
else
|
||||
return (((1 + _CPU_PAGE_WEIGHT_) * outers_per_page / NBuffers)
|
||||
+ _CPU_PAGE_WEIGHT_
|
||||
@@ -1125,7 +1125,7 @@ xfunc_expense_per_tuple(JoinPath joinnode, int whichchild)
|
||||
/* nestloop */
|
||||
{
|
||||
Assert(IsA(joinnode, JoinPath));
|
||||
return (_CPU_PAGE_WEIGHT_);
|
||||
return _CPU_PAGE_WEIGHT_;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1189,19 +1189,19 @@ xfunc_fixvars(LispValue clause, /* clause being pulled up */
|
||||
|
||||
|
||||
/*
|
||||
** Comparison function for lisp_qsort() on a list of CInfo's.
|
||||
** arg1 and arg2 should really be of type (CInfo *).
|
||||
** Comparison function for lisp_qsort() on a list of ClauseInfo's.
|
||||
** arg1 and arg2 should really be of type (ClauseInfo *).
|
||||
*/
|
||||
int
|
||||
xfunc_cinfo_compare(void *arg1, void *arg2)
|
||||
{
|
||||
CInfo info1 = *(CInfo *) arg1;
|
||||
CInfo info2 = *(CInfo *) arg2;
|
||||
ClauseInfo info1 = *(ClauseInfo *) arg1;
|
||||
ClauseInfo info2 = *(ClauseInfo *) arg2;
|
||||
|
||||
LispValue clause1 = (LispValue) get_clause(info1),
|
||||
clause2 = (LispValue) get_clause(info2);
|
||||
|
||||
return (xfunc_clause_compare((void *) &clause1, (void *) &clause2));
|
||||
return xfunc_clause_compare((void *) &clause1, (void *) &clause2);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1221,11 +1221,11 @@ xfunc_clause_compare(void *arg1, void *arg2)
|
||||
rank2 = xfunc_rank(clause2);
|
||||
|
||||
if (rank1 < rank2)
|
||||
return (-1);
|
||||
return -1;
|
||||
else if (rank1 == rank2)
|
||||
return (0);
|
||||
return 0;
|
||||
else
|
||||
return (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1285,11 +1285,11 @@ xfunc_disjunct_compare(Query *queryInfo, void *arg1, void *arg2)
|
||||
rank2 = cost2 / selec2;
|
||||
|
||||
if (rank1 < rank2)
|
||||
return (-1);
|
||||
return -1;
|
||||
else if (rank1 == rank2)
|
||||
return (0);
|
||||
return 0;
|
||||
else
|
||||
return (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ------------------------ UTILITY FUNCTIONS ------------------------------- */
|
||||
@@ -1303,7 +1303,7 @@ xfunc_func_width(RegProcedure funcid, LispValue args)
|
||||
Relation rd; /* Relation Descriptor */
|
||||
HeapTuple tupl; /* structure to hold a cached tuple */
|
||||
Form_pg_proc proc; /* structure to hold the pg_proc tuple */
|
||||
TypeTupleForm type; /* structure to hold the pg_type tuple */
|
||||
Form_pg_type type; /* structure to hold the pg_type tuple */
|
||||
LispValue tmpclause;
|
||||
int retval;
|
||||
|
||||
@@ -1332,7 +1332,7 @@ xfunc_func_width(RegProcedure funcid, LispValue args)
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tupl))
|
||||
elog(ERROR, "Cache lookup failed for type %d", proc->prorettype);
|
||||
type = (TypeTupleForm) GETSTRUCT(tupl);
|
||||
type = (Form_pg_type) GETSTRUCT(tupl);
|
||||
/* if the type length is known, return that */
|
||||
if (type->typlen != -1)
|
||||
{
|
||||
@@ -1352,7 +1352,7 @@ xfunc_func_width(RegProcedure funcid, LispValue args)
|
||||
}
|
||||
}
|
||||
exit:
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1364,7 +1364,7 @@ xfunc_tuple_width(Relation rd)
|
||||
{
|
||||
int i;
|
||||
int retval = 0;
|
||||
TupleDesc tdesc = RelationGetTupleDescriptor(rd);
|
||||
TupleDesc tdesc = RelationGetDescr(rd);
|
||||
|
||||
for (i = 0; i < tdesc->natts; i++)
|
||||
{
|
||||
@@ -1374,7 +1374,7 @@ xfunc_tuple_width(Relation rd)
|
||||
retval += VARLEN_DEFAULT;
|
||||
}
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1387,11 +1387,11 @@ xfunc_num_join_clauses(JoinPath path)
|
||||
int num = length(get_pathclauseinfo(path));
|
||||
|
||||
if (IsA(path, MergePath))
|
||||
return (num + length(get_path_mergeclauses((MergePath) path)));
|
||||
return num + length(get_path_mergeclauses((MergePath) path));
|
||||
else if (IsA(path, HashPath))
|
||||
return (num + length(get_path_hashclauses((HashPath) path)));
|
||||
return num + length(get_path_hashclauses((HashPath) path));
|
||||
else
|
||||
return (num);
|
||||
return num;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1414,7 +1414,7 @@ xfunc_LispRemove(LispValue foo, List bar)
|
||||
if (!sanity)
|
||||
elog(ERROR, "xfunc_LispRemove: didn't find a match!");
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define Node_Copy(a, b, c, d) \
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.30 1998/08/04 16:44:12 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.31 1998/09/01 03:23:35 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -154,7 +154,7 @@ create_plan(Path *best_path)
|
||||
}
|
||||
#endif
|
||||
|
||||
return (plan_node);
|
||||
return plan_node;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -281,7 +281,7 @@ create_join_node(JoinPath *best_path, List *tlist)
|
||||
(get_locclauseinfo(best_path)))));
|
||||
#endif
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -316,7 +316,7 @@ create_seqscan_node(Path *best_path, List *tlist, List *scan_clauses)
|
||||
|
||||
scan_node->plan.cost = best_path->path_cost;
|
||||
|
||||
return (scan_node);
|
||||
return scan_node;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -342,7 +342,7 @@ create_indexscan_node(IndexPath *best_path,
|
||||
IndexScan *scan_node = (IndexScan *) NULL;
|
||||
bool lossy = FALSE;
|
||||
HeapTuple indexTuple;
|
||||
IndexTupleForm index;
|
||||
Form_pg_index index;
|
||||
|
||||
/*
|
||||
* If an 'or' clause is to be used with this index, the indxqual field
|
||||
@@ -377,7 +377,7 @@ create_indexscan_node(IndexPath *best_path,
|
||||
if (!HeapTupleIsValid(indexTuple))
|
||||
elog(ERROR, "create_plan: index %d not found",
|
||||
lfirsti(ixid));
|
||||
index = (IndexTupleForm) GETSTRUCT(indexTuple);
|
||||
index = (Form_pg_index) GETSTRUCT(indexTuple);
|
||||
if (index->indislossy)
|
||||
lossy = TRUE;
|
||||
}
|
||||
@@ -418,7 +418,7 @@ create_indexscan_node(IndexPath *best_path,
|
||||
fixed_indxqual,
|
||||
best_path->path.path_cost);
|
||||
|
||||
return (scan_node);
|
||||
return scan_node;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -506,7 +506,7 @@ create_nestloop_node(JoinPath *best_path,
|
||||
|
||||
join_node->join.cost = best_path->path.path_cost;
|
||||
|
||||
return (join_node);
|
||||
return join_node;
|
||||
}
|
||||
|
||||
static MergeJoin *
|
||||
@@ -595,7 +595,7 @@ create_mergejoin_node(MergePath *best_path,
|
||||
|
||||
join_node->join.cost = best_path->jpath.path.path_cost;
|
||||
|
||||
return (join_node);
|
||||
return join_node;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -650,7 +650,7 @@ create_hashjoin_node(HashPath *best_path,
|
||||
(Plan *) hash_node);
|
||||
join_node->join.cost = best_path->jpath.path.path_cost;
|
||||
|
||||
return (join_node);
|
||||
return join_node;
|
||||
}
|
||||
|
||||
|
||||
@@ -684,17 +684,17 @@ fix_indxqual_references(Node *clause, Path *index_path)
|
||||
}
|
||||
newclause = copyObject((Node *) clause);
|
||||
((Var *) newclause)->varattno = pos + 1;
|
||||
return (newclause);
|
||||
return newclause;
|
||||
}
|
||||
else
|
||||
return (clause);
|
||||
return clause;
|
||||
}
|
||||
else if (IsA(clause, Const))
|
||||
return (clause);
|
||||
return clause;
|
||||
else if (IsA(clause, Param))
|
||||
{
|
||||
/* Function parameter used as index scan arg. DZ - 27-8-1996 */
|
||||
return (clause);
|
||||
return clause;
|
||||
}
|
||||
else if (is_opclause(clause) &&
|
||||
is_funcclause((Node *) get_leftop((Expr *) clause)) &&
|
||||
@@ -743,7 +743,7 @@ fix_indxqual_references(Node *clause, Path *index_path)
|
||||
make_clause(expr->opType, expr->oper, new_subclauses);
|
||||
}
|
||||
else
|
||||
return (clause);
|
||||
return clause;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -770,7 +770,7 @@ fix_indxqual_references(Node *clause, Path *index_path)
|
||||
if (new_subclauses)
|
||||
return (Node *) new_subclauses;
|
||||
else
|
||||
return (clause);
|
||||
return clause;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -812,7 +812,7 @@ switch_outer(List *clauses)
|
||||
else
|
||||
t_list = lappend(t_list, clause);
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -856,7 +856,7 @@ set_temp_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
|
||||
}
|
||||
keyno += 1;
|
||||
}
|
||||
return (tlist);
|
||||
return tlist;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -917,7 +917,7 @@ make_temp(List *tlist,
|
||||
elog(ERROR, "make_temp: unknown temp type %d", temptype);
|
||||
|
||||
}
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
@@ -939,7 +939,7 @@ make_seqscan(List *qptlist,
|
||||
node->scanrelid = scanrelid;
|
||||
node->scanstate = (CommonScanState *) NULL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
static IndexScan *
|
||||
@@ -964,7 +964,7 @@ make_indexscan(List *qptlist,
|
||||
node->indxqual = indxqual;
|
||||
node->scan.scanstate = (CommonScanState *) NULL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@@ -986,7 +986,7 @@ make_nestloop(List *qptlist,
|
||||
plan->righttree = righttree;
|
||||
node->nlstate = (NestLoopState *) NULL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
static HashJoin *
|
||||
@@ -1013,7 +1013,7 @@ make_hashjoin(List *tlist,
|
||||
node->hashjointablesize = 0;
|
||||
node->hashdone = false;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
static Hash *
|
||||
@@ -1034,7 +1034,7 @@ make_hash(List *tlist, Var *hashkey, Plan *lefttree)
|
||||
node->hashtablekey = 0;
|
||||
node->hashtablesize = 0;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
static MergeJoin *
|
||||
@@ -1062,7 +1062,7 @@ make_mergejoin(List *tlist,
|
||||
node->mergerightorder = rightorder;
|
||||
node->mergeleftorder = leftorder;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
Sort *
|
||||
@@ -1080,7 +1080,7 @@ make_sort(List *tlist, Oid tempid, Plan *lefttree, int keycount)
|
||||
node->tempid = tempid;
|
||||
node->keycount = keycount;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
static Material *
|
||||
@@ -1101,7 +1101,7 @@ make_material(List *tlist,
|
||||
node->tempid = tempid;
|
||||
node->keycount = keycount;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
Agg *
|
||||
@@ -1117,7 +1117,7 @@ make_agg(List *tlist, Plan *lefttree)
|
||||
node->plan.righttree = (Plan *) NULL;
|
||||
node->aggs = NIL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
Group *
|
||||
@@ -1139,7 +1139,7 @@ make_group(List *tlist,
|
||||
node->numCols = ngrp;
|
||||
node->grpColIdx = grpColIdx;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1168,7 +1168,7 @@ make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
|
||||
node->uniqueAttr = NULL;
|
||||
else
|
||||
node->uniqueAttr = pstrdup(uniqueAttr);
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.18 1998/08/10 02:26:26 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.19 1998/09/01 03:23:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -40,7 +40,7 @@
|
||||
extern int Quiet;
|
||||
|
||||
static void add_clause_to_rels(Query *root, List *clause);
|
||||
static void add_join_info_to_rels(Query *root, CInfo *clauseinfo,
|
||||
static void add_join_info_to_rels(Query *root, ClauseInfo *clauseinfo,
|
||||
List *join_relids);
|
||||
static void add_vars_to_targetlist(Query *root, List *vars, List *join_relids);
|
||||
|
||||
@@ -170,7 +170,7 @@ add_clause_to_rels(Query *root, List *clause)
|
||||
{
|
||||
List *relids;
|
||||
List *vars;
|
||||
CInfo *clauseinfo = makeNode(CInfo);
|
||||
ClauseInfo *clauseinfo = makeNode(ClauseInfo);
|
||||
|
||||
/*
|
||||
* Retrieve all relids and vars contained within the clause.
|
||||
@@ -252,13 +252,13 @@ add_clause_to_rels(Query *root, List *clause)
|
||||
*
|
||||
*/
|
||||
static void
|
||||
add_join_info_to_rels(Query *root, CInfo *clauseinfo, List *join_relids)
|
||||
add_join_info_to_rels(Query *root, ClauseInfo *clauseinfo, List *join_relids)
|
||||
{
|
||||
List *join_relid;
|
||||
|
||||
foreach(join_relid, join_relids)
|
||||
{
|
||||
JInfo *joininfo;
|
||||
JoinInfo *joininfo;
|
||||
List *other_rels = NIL;
|
||||
List *rel;
|
||||
|
||||
@@ -332,8 +332,8 @@ init_join_info(List *rel_list)
|
||||
*y,
|
||||
*z;
|
||||
RelOptInfo *rel;
|
||||
JInfo *joininfo;
|
||||
CInfo *clauseinfo;
|
||||
JoinInfo *joininfo;
|
||||
ClauseInfo *clauseinfo;
|
||||
Expr *clause;
|
||||
|
||||
foreach(x, rel_list)
|
||||
@@ -341,10 +341,10 @@ init_join_info(List *rel_list)
|
||||
rel = (RelOptInfo *) lfirst(x);
|
||||
foreach(y, rel->joininfo)
|
||||
{
|
||||
joininfo = (JInfo *) lfirst(y);
|
||||
joininfo = (JoinInfo *) lfirst(y);
|
||||
foreach(z, joininfo->jinfoclauseinfo)
|
||||
{
|
||||
clauseinfo = (CInfo *) lfirst(z);
|
||||
clauseinfo = (ClauseInfo *) lfirst(z);
|
||||
clause = clauseinfo->clause;
|
||||
if (is_joinable((Node *) clause))
|
||||
{
|
||||
@@ -400,10 +400,10 @@ mergejoinop(Expr *clause)
|
||||
morder->right_operator = rightOp;
|
||||
morder->left_type = (get_leftop(clause))->vartype;
|
||||
morder->right_type = (get_rightop(clause))->vartype;
|
||||
return (morder);
|
||||
return morder;
|
||||
}
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.26 1998/08/10 04:49:39 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.27 1998/09/01 03:23:38 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -112,7 +112,7 @@ query_planner(Query *root,
|
||||
(Plan *) NULL));
|
||||
}
|
||||
else
|
||||
return ((Plan *) NULL);
|
||||
return (Plan *) NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -167,12 +167,12 @@ query_planner(Query *root,
|
||||
(Plan *) scan));
|
||||
}
|
||||
else
|
||||
return ((Plan *) scan);
|
||||
return (Plan *) scan;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return ((Plan *) NULL);
|
||||
return (Plan *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -312,11 +312,11 @@ subplanner(Query *root,
|
||||
* it.
|
||||
*/
|
||||
if (final_rel)
|
||||
return (create_plan((Path *) final_rel->cheapestpath));
|
||||
return create_plan((Path *) final_rel->cheapestpath);
|
||||
else
|
||||
{
|
||||
elog(NOTICE, "final relation is nil");
|
||||
return (create_plan((Path *) NULL));
|
||||
return create_plan((Path *) NULL);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -344,7 +344,7 @@ make_result(List *tlist,
|
||||
node->resconstantqual = resconstantqual;
|
||||
node->resstate = NULL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.30 1998/08/29 04:09:25 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.31 1998/09/01 03:23:39 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -79,7 +79,7 @@ planner(Query *parse)
|
||||
}
|
||||
result_plan->nParamExec = length(PlannerParamVar);
|
||||
|
||||
return (result_plan);
|
||||
return result_plan;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -298,14 +298,14 @@ union_planner(Query *parse)
|
||||
{
|
||||
Plan *sortplan = make_sortplan(tlist, parse->sortClause, result_plan);
|
||||
|
||||
return ((Plan *) make_unique(tlist, sortplan, parse->uniqueFlag));
|
||||
return (Plan *) make_unique(tlist, sortplan, parse->uniqueFlag);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (parse->sortClause)
|
||||
return (make_sortplan(tlist, parse->sortClause, result_plan));
|
||||
return make_sortplan(tlist, parse->sortClause, result_plan);
|
||||
else
|
||||
return ((Plan *) result_plan);
|
||||
return (Plan *) result_plan;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -367,7 +367,7 @@ make_sortplan(List *tlist, List *sortcls, Plan *plannode)
|
||||
|
||||
sortplan->cost = plannode->cost;
|
||||
|
||||
return (sortplan);
|
||||
return sortplan;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.24 1998/07/20 19:53:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.25 1998/09/01 03:23:40 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -274,7 +274,7 @@ index_outerjoin_references(List *inner_indxqual,
|
||||
}
|
||||
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -305,14 +305,14 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
temp = (List *) replace_joinvar_refs((Var *) clause,
|
||||
outer_tlist, inner_tlist);
|
||||
if (temp)
|
||||
return (temp);
|
||||
return temp;
|
||||
else if (clause != NULL)
|
||||
return ((List *) clause);
|
||||
return (List *) clause;
|
||||
else
|
||||
return (NIL);
|
||||
return NIL;
|
||||
}
|
||||
else if (single_node((Node *) clause))
|
||||
return ((List *) clause);
|
||||
return (List *) clause;
|
||||
else if (and_clause((Node *) clause))
|
||||
{
|
||||
List *andclause =
|
||||
@@ -320,7 +320,7 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
outer_tlist,
|
||||
inner_tlist);
|
||||
|
||||
return ((List *) make_andclause(andclause));
|
||||
return (List *) make_andclause(andclause);
|
||||
}
|
||||
else if (or_clause((Node *) clause))
|
||||
{
|
||||
@@ -329,7 +329,7 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
outer_tlist,
|
||||
inner_tlist);
|
||||
|
||||
return ((List *) make_orclause(orclause));
|
||||
return (List *) make_orclause(orclause);
|
||||
}
|
||||
else if (IsA(clause, ArrayRef))
|
||||
{
|
||||
@@ -355,7 +355,7 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
* structure 'clause'.
|
||||
*/
|
||||
|
||||
return ((List *) clause);
|
||||
return (List *) clause;
|
||||
}
|
||||
else if (is_funcclause((Node *) clause))
|
||||
{
|
||||
@@ -374,7 +374,7 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
outer_tlist,
|
||||
inner_tlist);
|
||||
|
||||
return ((List *) make_notclause((Expr *) notclause));
|
||||
return (List *) make_notclause((Expr *) notclause);
|
||||
}
|
||||
else if (is_opclause((Node *) clause))
|
||||
{
|
||||
@@ -401,7 +401,7 @@ replace_clause_joinvar_refs(Expr *clause,
|
||||
replace_subclause_joinvar_refs(((SubPlan *) ((Expr *) clause)->oper)->sublink->oper,
|
||||
outer_tlist,
|
||||
inner_tlist);
|
||||
return ((List *) clause);
|
||||
return (List *) clause;
|
||||
}
|
||||
/* shouldn't reach here */
|
||||
elog(ERROR, "replace_clause_joinvar_refs: unsupported clause %d",
|
||||
@@ -425,7 +425,7 @@ replace_subclause_joinvar_refs(List *clauses,
|
||||
inner_tlist);
|
||||
t_list = lappend(t_list, temp);
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
static Var *
|
||||
@@ -508,7 +508,7 @@ tlist_temp_references(Oid tempid,
|
||||
|
||||
t_list = lappend(t_list, temp);
|
||||
}
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------
|
||||
|
@@ -58,7 +58,7 @@ _new_param(Var *var, int varlevel)
|
||||
lfirst(last) = makeVar(var->varno, var->varattno, var->vartype,
|
||||
var->vartypmod, varlevel, var->varnoold, var->varoattno);
|
||||
|
||||
return (i);
|
||||
return i;
|
||||
}
|
||||
|
||||
static Param *
|
||||
@@ -99,7 +99,7 @@ _replace_var(Var *var)
|
||||
retval->paramid = (AttrNumber) i;
|
||||
retval->paramtype = var->vartype;
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static Node *
|
||||
@@ -239,7 +239,7 @@ _make_subplan(SubLink *slink)
|
||||
result = (Node *) expr;
|
||||
}
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
@@ -247,11 +247,11 @@ static List *
|
||||
set_unioni(List *l1, List *l2)
|
||||
{
|
||||
if (l1 == NULL)
|
||||
return (l2);
|
||||
return l2;
|
||||
if (l2 == NULL)
|
||||
return (l1);
|
||||
return l1;
|
||||
|
||||
return (nconc(l1, set_differencei(l2, l1)));
|
||||
return nconc(l1, set_differencei(l2, l1));
|
||||
}
|
||||
|
||||
static List *
|
||||
@@ -260,15 +260,15 @@ _finalize_primnode(void *expr, List **subplan)
|
||||
List *result = NULL;
|
||||
|
||||
if (expr == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
if (IsA(expr, Param))
|
||||
{
|
||||
if (((Param *) expr)->paramkind == PARAM_EXEC)
|
||||
return (lconsi(((Param *) expr)->paramid, (List *) NULL));
|
||||
return lconsi(((Param *) expr)->paramid, (List *) NULL);
|
||||
}
|
||||
else if (single_node(expr))
|
||||
return (NULL);
|
||||
return NULL;
|
||||
else if (IsA(expr, List))
|
||||
{
|
||||
List *le;
|
||||
@@ -278,12 +278,12 @@ _finalize_primnode(void *expr, List **subplan)
|
||||
_finalize_primnode(lfirst(le), subplan));
|
||||
}
|
||||
else if (IsA(expr, Iter))
|
||||
return (_finalize_primnode(((Iter *) expr)->iterexpr, subplan));
|
||||
return _finalize_primnode(((Iter *) expr)->iterexpr, subplan);
|
||||
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
|
||||
not_clause(expr) || is_funcclause(expr))
|
||||
return (_finalize_primnode(((Expr *) expr)->args, subplan));
|
||||
return _finalize_primnode(((Expr *) expr)->args, subplan);
|
||||
else if (IsA(expr, Aggreg))
|
||||
return (_finalize_primnode(((Aggreg *) expr)->target, subplan));
|
||||
return _finalize_primnode(((Aggreg *) expr)->target, subplan);
|
||||
else if (IsA(expr, ArrayRef))
|
||||
{
|
||||
result = _finalize_primnode(((ArrayRef *) expr)->refupperindexpr, subplan);
|
||||
@@ -295,7 +295,7 @@ _finalize_primnode(void *expr, List **subplan)
|
||||
_finalize_primnode(((ArrayRef *) expr)->refassgnexpr, subplan));
|
||||
}
|
||||
else if (IsA(expr, TargetEntry))
|
||||
return (_finalize_primnode(((TargetEntry *) expr)->expr, subplan));
|
||||
return _finalize_primnode(((TargetEntry *) expr)->expr, subplan);
|
||||
else if (is_subplan(expr))
|
||||
{
|
||||
List *lst;
|
||||
@@ -314,7 +314,7 @@ _finalize_primnode(void *expr, List **subplan)
|
||||
elog(ERROR, "_finalize_primnode: can't handle node %d",
|
||||
nodeTag(expr));
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
Node *
|
||||
@@ -322,7 +322,7 @@ SS_replace_correlation_vars(Node *expr)
|
||||
{
|
||||
|
||||
if (expr == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
if (IsA(expr, List))
|
||||
{
|
||||
List *le;
|
||||
@@ -344,7 +344,7 @@ SS_replace_correlation_vars(Node *expr)
|
||||
SS_replace_correlation_vars(((Iter *) expr)->iterexpr);
|
||||
}
|
||||
else if (single_node(expr))
|
||||
return (expr);
|
||||
return expr;
|
||||
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
|
||||
not_clause(expr) || is_funcclause(expr))
|
||||
((Expr *) expr)->args = (List *)
|
||||
@@ -384,14 +384,14 @@ SS_replace_correlation_vars(Node *expr)
|
||||
elog(NOTICE, "SS_replace_correlation_vars: can't handle node %d",
|
||||
nodeTag(expr));
|
||||
|
||||
return (expr);
|
||||
return expr;
|
||||
}
|
||||
|
||||
Node *
|
||||
SS_process_sublinks(Node *expr)
|
||||
{
|
||||
if (expr == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
if (IsA(expr, List))
|
||||
{
|
||||
List *le;
|
||||
@@ -419,7 +419,7 @@ SS_process_sublinks(Node *expr)
|
||||
expr = _make_subplan((SubLink *) expr);
|
||||
}
|
||||
|
||||
return (expr);
|
||||
return expr;
|
||||
}
|
||||
|
||||
List *
|
||||
@@ -432,7 +432,7 @@ SS_finalize_plan(Plan *plan)
|
||||
List *lst;
|
||||
|
||||
if (plan == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
param_list = _finalize_primnode(plan->targetlist, &subPlan);
|
||||
Assert(subPlan == NULL);
|
||||
@@ -489,7 +489,7 @@ SS_finalize_plan(Plan *plan)
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "SS_finalize_plan: node %d unsupported", nodeTag(plan));
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
param_list = set_unioni(param_list, _finalize_primnode(plan->qual, &subPlan));
|
||||
@@ -515,7 +515,7 @@ SS_finalize_plan(Plan *plan)
|
||||
plan->locParam = locParam;
|
||||
plan->subPlan = subPlan;
|
||||
|
||||
return (param_list);
|
||||
return param_list;
|
||||
|
||||
}
|
||||
|
||||
@@ -527,7 +527,7 @@ SS_pull_subplan(void *expr)
|
||||
List *result = NULL;
|
||||
|
||||
if (expr == NULL || single_node(expr))
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
if (IsA(expr, List))
|
||||
{
|
||||
@@ -537,12 +537,12 @@ SS_pull_subplan(void *expr)
|
||||
result = nconc(result, SS_pull_subplan(lfirst(le)));
|
||||
}
|
||||
else if (IsA(expr, Iter))
|
||||
return (SS_pull_subplan(((Iter *) expr)->iterexpr));
|
||||
return SS_pull_subplan(((Iter *) expr)->iterexpr);
|
||||
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
|
||||
not_clause(expr) || is_funcclause(expr))
|
||||
return (SS_pull_subplan(((Expr *) expr)->args));
|
||||
return SS_pull_subplan(((Expr *) expr)->args);
|
||||
else if (IsA(expr, Aggreg))
|
||||
return (SS_pull_subplan(((Aggreg *) expr)->target));
|
||||
return SS_pull_subplan(((Aggreg *) expr)->target);
|
||||
else if (IsA(expr, ArrayRef))
|
||||
{
|
||||
result = SS_pull_subplan(((ArrayRef *) expr)->refupperindexpr);
|
||||
@@ -554,12 +554,12 @@ SS_pull_subplan(void *expr)
|
||||
SS_pull_subplan(((ArrayRef *) expr)->refassgnexpr));
|
||||
}
|
||||
else if (IsA(expr, TargetEntry))
|
||||
return (SS_pull_subplan(((TargetEntry *) expr)->expr));
|
||||
return SS_pull_subplan(((TargetEntry *) expr)->expr);
|
||||
else if (is_subplan(expr))
|
||||
return (lcons(((Expr *) expr)->oper, NULL));
|
||||
return lcons(((Expr *) expr)->oper, NULL);
|
||||
else
|
||||
elog(ERROR, "SS_pull_subplan: can't handle node %d",
|
||||
nodeTag(expr));
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.9 1998/06/15 19:28:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.10 1998/09/01 03:23:43 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -101,7 +101,7 @@ static Expr *
|
||||
pull_args(Expr *qual)
|
||||
{
|
||||
if (qual == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
if (is_opclause((Node *) qual))
|
||||
{
|
||||
@@ -117,7 +117,7 @@ pull_args(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, pull_args(lfirst(temp)));
|
||||
return (make_andclause(pull_ands(t_list)));
|
||||
return make_andclause(pull_ands(t_list));
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -126,12 +126,12 @@ pull_args(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, pull_args(lfirst(temp)));
|
||||
return (make_orclause(pull_ors(t_list)));
|
||||
return make_orclause(pull_ors(t_list));
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return (make_notclause(pull_args(get_notclausearg(qual))));
|
||||
return make_notclause(pull_args(get_notclausearg(qual)));
|
||||
else
|
||||
return (qual);
|
||||
return qual;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -145,7 +145,7 @@ static List *
|
||||
pull_ors(List *orlist)
|
||||
{
|
||||
if (orlist == NIL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
|
||||
if (or_clause(lfirst(orlist)))
|
||||
{
|
||||
@@ -155,7 +155,7 @@ pull_ors(List *orlist)
|
||||
copyObject((Node *) lnext(orlist)))));
|
||||
}
|
||||
else
|
||||
return (lcons(lfirst(orlist), pull_ors(lnext(orlist))));
|
||||
return lcons(lfirst(orlist), pull_ors(lnext(orlist)));
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -169,7 +169,7 @@ static List *
|
||||
pull_ands(List *andlist)
|
||||
{
|
||||
if (andlist == NIL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
|
||||
if (and_clause(lfirst(andlist)))
|
||||
{
|
||||
@@ -179,7 +179,7 @@ pull_ands(List *andlist)
|
||||
copyObject((Node *) lnext(andlist)))));
|
||||
}
|
||||
else
|
||||
return (lcons(lfirst(andlist), pull_ands(lnext(andlist))));
|
||||
return lcons(lfirst(andlist), pull_ands(lnext(andlist)));
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -196,7 +196,7 @@ static Expr *
|
||||
find_nots(Expr *qual)
|
||||
{
|
||||
if (qual == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
if (is_opclause((Node *) qual))
|
||||
{
|
||||
@@ -213,7 +213,7 @@ find_nots(Expr *qual)
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, find_nots(lfirst(temp)));
|
||||
|
||||
return (make_andclause(t_list));
|
||||
return make_andclause(t_list);
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -222,12 +222,12 @@ find_nots(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, find_nots(lfirst(temp)));
|
||||
return (make_orclause(t_list));
|
||||
return make_orclause(t_list);
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return (push_nots(get_notclausearg(qual)));
|
||||
return push_nots(get_notclausearg(qual));
|
||||
else
|
||||
return (qual);
|
||||
return qual;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -241,7 +241,7 @@ static Expr *
|
||||
push_nots(Expr *qual)
|
||||
{
|
||||
if (qual == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Negate an operator clause if possible: ("NOT" (< A B)) => (> A B)
|
||||
@@ -265,7 +265,7 @@ push_nots(Expr *qual)
|
||||
(make_opclause(op, get_leftop(qual), get_rightop(qual)));
|
||||
}
|
||||
else
|
||||
return (make_notclause(qual));
|
||||
return make_notclause(qual);
|
||||
}
|
||||
else if (and_clause((Node *) qual))
|
||||
{
|
||||
@@ -280,7 +280,7 @@ push_nots(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, push_nots(lfirst(temp)));
|
||||
return (make_orclause(t_list));
|
||||
return make_orclause(t_list);
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -289,7 +289,7 @@ push_nots(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, push_nots(lfirst(temp)));
|
||||
return (make_andclause(t_list));
|
||||
return make_andclause(t_list);
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
|
||||
@@ -297,14 +297,14 @@ push_nots(Expr *qual)
|
||||
* Another 'not' cancels this 'not', so eliminate the 'not' and
|
||||
* stop negating this branch.
|
||||
*/
|
||||
return (find_nots(get_notclausearg(qual)));
|
||||
return find_nots(get_notclausearg(qual));
|
||||
else
|
||||
|
||||
/*
|
||||
* We don't know how to negate anything else, place a 'not' at
|
||||
* this level.
|
||||
*/
|
||||
return (make_notclause(qual));
|
||||
return make_notclause(qual);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -322,7 +322,7 @@ static Expr *
|
||||
normalize(Expr *qual)
|
||||
{
|
||||
if (qual == NULL)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
|
||||
if (is_opclause((Node *) qual))
|
||||
{
|
||||
@@ -340,7 +340,7 @@ normalize(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, normalize(lfirst(temp)));
|
||||
return (make_andclause(t_list));
|
||||
return make_andclause(t_list);
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -360,15 +360,15 @@ normalize(Expr *qual)
|
||||
}
|
||||
}
|
||||
if (has_andclause == TRUE)
|
||||
return (make_andclause(or_normalize(orlist)));
|
||||
return make_andclause(or_normalize(orlist));
|
||||
else
|
||||
return (make_orclause(orlist));
|
||||
return make_orclause(orlist);
|
||||
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return (make_notclause(normalize(get_notclausearg(qual))));
|
||||
return make_notclause(normalize(get_notclausearg(qual)));
|
||||
else
|
||||
return (qual);
|
||||
return qual;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -405,7 +405,7 @@ or_normalize(List *orlist)
|
||||
lnext(new_orlist))));
|
||||
}
|
||||
else
|
||||
return (orlist);
|
||||
return orlist;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -425,7 +425,7 @@ distribute_args(List *item, List *args)
|
||||
List *t_list = NIL;
|
||||
|
||||
if (args == NULL)
|
||||
return (item);
|
||||
return item;
|
||||
|
||||
foreach(temp, args)
|
||||
{
|
||||
@@ -434,7 +434,7 @@ distribute_args(List *item, List *args)
|
||||
or_list = (List *) make_orclause(n_list);
|
||||
t_list = lappend(t_list, or_list);
|
||||
}
|
||||
return ((List *) make_andclause(t_list));
|
||||
return (List *) make_andclause(t_list);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -450,7 +450,7 @@ static List *
|
||||
qualcleanup(Expr *qual)
|
||||
{
|
||||
if (qual == NULL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
|
||||
if (is_opclause((Node *) qual))
|
||||
{
|
||||
@@ -471,9 +471,9 @@ qualcleanup(Expr *qual)
|
||||
new_and_args = remove_duplicates(t_list);
|
||||
|
||||
if (length(new_and_args) > 1)
|
||||
return ((List *) make_andclause(new_and_args));
|
||||
return (List *) make_andclause(new_and_args);
|
||||
else
|
||||
return (lfirst(new_and_args));
|
||||
return lfirst(new_and_args);
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -488,15 +488,15 @@ qualcleanup(Expr *qual)
|
||||
|
||||
|
||||
if (length(new_or_args) > 1)
|
||||
return ((List *) make_orclause(new_or_args));
|
||||
return (List *) make_orclause(new_or_args);
|
||||
else
|
||||
return (lfirst(new_or_args));
|
||||
return lfirst(new_or_args);
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return ((List *) make_notclause((Expr *) qualcleanup((Expr *) get_notclausearg(qual))));
|
||||
return (List *) make_notclause((Expr *) qualcleanup((Expr *) get_notclausearg(qual)));
|
||||
|
||||
else
|
||||
return ((List *) qual);
|
||||
return (List *) qual;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -513,7 +513,7 @@ remove_ands(Expr *qual)
|
||||
List *t_list = NIL;
|
||||
|
||||
if (qual == NULL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
if (is_opclause((Node *) qual))
|
||||
{
|
||||
return ((List *) make_clause(qual->opType, qual->oper,
|
||||
@@ -527,7 +527,7 @@ remove_ands(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, remove_ands(lfirst(temp)));
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
else if (or_clause((Node *) qual))
|
||||
{
|
||||
@@ -535,12 +535,12 @@ remove_ands(Expr *qual)
|
||||
|
||||
foreach(temp, qual->args)
|
||||
t_list = lappend(t_list, remove_ands(lfirst(temp)));
|
||||
return ((List *) make_orclause((List *) t_list));
|
||||
return (List *) make_orclause((List *) t_list);
|
||||
}
|
||||
else if (not_clause((Node *) qual))
|
||||
return ((List *) make_notclause((Expr *) remove_ands((Expr *) get_notclausearg(qual))));
|
||||
return (List *) make_notclause((Expr *) remove_ands((Expr *) get_notclausearg(qual)));
|
||||
else
|
||||
return ((List *) qual);
|
||||
return (List *) qual;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -558,7 +558,7 @@ remove_duplicates(List *list)
|
||||
bool there_exists_duplicate = false;
|
||||
|
||||
if (length(list) == 1)
|
||||
return (list);
|
||||
return list;
|
||||
|
||||
foreach(i, list)
|
||||
{
|
||||
@@ -575,5 +575,5 @@ remove_duplicates(List *list)
|
||||
there_exists_duplicate = false;
|
||||
}
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/preptlist.c,v 1.14 1998/07/20 19:53:47 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/preptlist.c,v 1.15 1998/09/01 03:23:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -118,7 +118,7 @@ preprocess_targetlist(List *tlist,
|
||||
t_list = lappend(t_list, ctid);
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -164,10 +164,10 @@ expand_targetlist(List *tlist,
|
||||
result_relation,
|
||||
node_type);
|
||||
|
||||
return (replace_matching_resname(ntlist, tlist));
|
||||
return replace_matching_resname(ntlist, tlist);
|
||||
}
|
||||
else
|
||||
return (tlist);
|
||||
return tlist;
|
||||
|
||||
}
|
||||
|
||||
@@ -236,7 +236,7 @@ replace_matching_resname(List *new_tlist, List *old_tlist)
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -331,5 +331,5 @@ new_relation_targetlist(Oid relid, Index rt_index, NodeTag node_type)
|
||||
}
|
||||
}
|
||||
|
||||
return (t_list);
|
||||
return t_list;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.25 1998/07/15 14:54:37 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.26 1998/09/01 03:23:46 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -297,7 +297,7 @@ plan_inherit_query(List *relids,
|
||||
}
|
||||
|
||||
*union_rtentriesPtr = union_rtentries;
|
||||
return (union_plans);
|
||||
return union_plans;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -333,7 +333,7 @@ find_all_inheritors(List *unexamined_relids,
|
||||
new_examined_relids);
|
||||
|
||||
if (new_unexamined_relids == NULL)
|
||||
return (new_examined_relids);
|
||||
return new_examined_relids;
|
||||
else
|
||||
{
|
||||
return (find_all_inheritors(new_unexamined_relids,
|
||||
@@ -386,7 +386,7 @@ new_rangetable_entry(Oid new_relid, RangeTblEntry *old_entry)
|
||||
new_entry->relname = get_rel_name(new_relid);
|
||||
|
||||
new_entry->relid = new_relid;
|
||||
return (new_entry);
|
||||
return new_entry;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -406,7 +406,7 @@ subst_rangetable(Query *root, Index index, RangeTblEntry *new_entry)
|
||||
;
|
||||
lfirst(temp) = new_entry;
|
||||
|
||||
return (new_root);
|
||||
return new_root;
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -516,5 +516,5 @@ make_append(List *appendplans,
|
||||
node->plan.lefttree = (Plan *) NULL;
|
||||
node->plan.righttree = (Plan *) NULL;
|
||||
|
||||
return (node);
|
||||
return node;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/clauseinfo.c,v 1.7 1998/02/26 04:33:09 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/clauseinfo.c,v 1.8 1998/09/01 03:23:47 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -27,15 +27,15 @@
|
||||
*
|
||||
*/
|
||||
bool
|
||||
valid_or_clause(CInfo *clauseinfo)
|
||||
valid_or_clause(ClauseInfo *clauseinfo)
|
||||
{
|
||||
if (clauseinfo != NULL &&
|
||||
!single_node((Node *) clauseinfo->clause) &&
|
||||
!clauseinfo->notclause &&
|
||||
or_clause((Node *) clauseinfo->clause))
|
||||
return (true);
|
||||
return true;
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -49,14 +49,14 @@ get_actual_clauses(List *clauseinfo_list)
|
||||
{
|
||||
List *temp = NIL;
|
||||
List *result = NIL;
|
||||
CInfo *clause = (CInfo *) NULL;
|
||||
ClauseInfo *clause = (ClauseInfo *) NULL;
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
{
|
||||
clause = (CInfo *) lfirst(temp);
|
||||
clause = (ClauseInfo *) lfirst(temp);
|
||||
result = lappend(result, clause->clause);
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -93,7 +93,7 @@ get_relattvals(List *clauseinfo_list,
|
||||
List *result1 = NIL;
|
||||
List *result2 = NIL;
|
||||
List *result3 = NIL;
|
||||
CInfo *temp = (CInfo *) NULL;
|
||||
ClauseInfo *temp = (ClauseInfo *) NULL;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, clauseinfo_list)
|
||||
@@ -103,7 +103,7 @@ get_relattvals(List *clauseinfo_list,
|
||||
Datum constval;
|
||||
int flag;
|
||||
|
||||
temp = (CInfo *) lfirst(i);
|
||||
temp = (ClauseInfo *) lfirst(i);
|
||||
get_relattval((Node *) temp->clause, &dummy, &attno, &constval, &flag);
|
||||
result1 = lappendi(result1, (int) attno);
|
||||
result2 = lappendi(result2, constval);
|
||||
@@ -144,7 +144,7 @@ get_joinvars(Oid relid,
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
{
|
||||
CInfo *clauseinfo = lfirst(temp);
|
||||
ClauseInfo *clauseinfo = lfirst(temp);
|
||||
Expr *clause = clauseinfo->clause;
|
||||
|
||||
if (IsA(get_leftop(clause), Var) &&
|
||||
@@ -176,16 +176,16 @@ get_joinvars(Oid relid,
|
||||
List *
|
||||
get_opnos(List *clauseinfo_list)
|
||||
{
|
||||
CInfo *temp = (CInfo *) NULL;
|
||||
ClauseInfo *temp = (ClauseInfo *) NULL;
|
||||
List *result = NIL;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, clauseinfo_list)
|
||||
{
|
||||
temp = (CInfo *) lfirst(i);
|
||||
temp = (ClauseInfo *) lfirst(i);
|
||||
result =
|
||||
lappendi(result,
|
||||
(((Oper *) temp->clause->oper)->opno));
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.22 1998/08/31 07:55:47 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.23 1998/09/01 03:23:49 momjian Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
@@ -60,7 +60,7 @@ make_clause(int type, Node *oper, List *args)
|
||||
{
|
||||
elog(ERROR, "make_clause: unsupported type %d", type);
|
||||
/* will this ever happen? translated from lispy C code - ay 10/94 */
|
||||
return ((Expr *) args);
|
||||
return (Expr *) args;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -117,7 +117,7 @@ Var *
|
||||
get_leftop(Expr *clause)
|
||||
{
|
||||
if (clause->args != NULL)
|
||||
return (lfirst(clause->args));
|
||||
return lfirst(clause->args);
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
@@ -132,7 +132,7 @@ Var *
|
||||
get_rightop(Expr *clause)
|
||||
{
|
||||
if (clause->args != NULL && lnext(clause->args) != NULL)
|
||||
return (lfirst(lnext(clause->args)));
|
||||
return lfirst(lnext(clause->args));
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
@@ -266,7 +266,7 @@ make_notclause(Expr *notclause)
|
||||
Expr *
|
||||
get_notclausearg(Expr *notclause)
|
||||
{
|
||||
return (lfirst(notclause->args));
|
||||
return lfirst(notclause->args);
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -405,7 +405,7 @@ NumRelids(Node *clause)
|
||||
var_list = lconsi(var->varno, var_list);
|
||||
}
|
||||
|
||||
return (length(var_list));
|
||||
return length(var_list);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -419,10 +419,10 @@ bool
|
||||
contains_not(Node *clause)
|
||||
{
|
||||
if (single_node(clause))
|
||||
return (false);
|
||||
return false;
|
||||
|
||||
if (not_clause(clause))
|
||||
return (true);
|
||||
return true;
|
||||
|
||||
if (or_clause(clause) || and_clause(clause))
|
||||
{
|
||||
@@ -431,11 +431,11 @@ contains_not(Node *clause)
|
||||
foreach(a, ((Expr *) clause)->args)
|
||||
{
|
||||
if (contains_not(lfirst(a)))
|
||||
return (true);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -467,9 +467,9 @@ is_joinable(Node *clause)
|
||||
* ... or a func node.
|
||||
*/
|
||||
if (is_funcclause(leftop) || is_funcclause(rightop))
|
||||
return (true);
|
||||
return true;
|
||||
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -487,11 +487,11 @@ qual_clause_p(Node *clause)
|
||||
/* How about Param-s ? - vadim 02/03/98 */
|
||||
if (IsA(get_leftop((Expr *) clause), Var) &&
|
||||
IsA(get_rightop((Expr *) clause), Const))
|
||||
return (true);
|
||||
return true;
|
||||
else if (IsA(get_rightop((Expr *) clause), Var) &&
|
||||
IsA(get_leftop((Expr *) clause), Const))
|
||||
return (true);
|
||||
return (false);
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -558,7 +558,7 @@ fix_opids(List *clauses)
|
||||
foreach(clause, clauses)
|
||||
fix_opid(lfirst(clause));
|
||||
|
||||
return (clauses);
|
||||
return clauses;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -759,7 +759,7 @@ CommuteClause(Node *clause)
|
||||
{
|
||||
Node *temp;
|
||||
Oper *commu;
|
||||
OperatorTupleForm commuTup;
|
||||
Form_pg_operator commuTup;
|
||||
HeapTuple heapTup;
|
||||
|
||||
if (!is_opclause(clause))
|
||||
@@ -771,7 +771,7 @@ CommuteClause(Node *clause)
|
||||
if (heapTup == (HeapTuple) NULL)
|
||||
return;
|
||||
|
||||
commuTup = (OperatorTupleForm) GETSTRUCT(heapTup);
|
||||
commuTup = (Form_pg_operator) GETSTRUCT(heapTup);
|
||||
|
||||
commu = makeOper(heapTup->t_oid,
|
||||
InvalidOid,
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.8 1998/07/18 04:22:40 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.9 1998/09/01 03:23:50 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -36,9 +36,9 @@ List *
|
||||
find_relation_indices(Query *root, RelOptInfo *rel)
|
||||
{
|
||||
if (rel->indexed)
|
||||
return (find_secondary_index(root, lfirsti(rel->relids)));
|
||||
return find_secondary_index(root, lfirsti(rel->relids));
|
||||
else
|
||||
return (NIL);
|
||||
return NIL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.10 1998/08/10 02:26:30 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.11 1998/09/01 03:23:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -35,7 +35,7 @@
|
||||
* exists.
|
||||
*
|
||||
*/
|
||||
JInfo *
|
||||
JoinInfo *
|
||||
joininfo_member(List *join_relids, List *joininfo_list)
|
||||
{
|
||||
List *i = NIL;
|
||||
@@ -44,10 +44,10 @@ joininfo_member(List *join_relids, List *joininfo_list)
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
other_rels = lfirst(i);
|
||||
if (same(join_relids, ((JInfo *) other_rels)->otherrels))
|
||||
return ((JInfo *) other_rels);
|
||||
if (same(join_relids, ((JoinInfo *) other_rels)->otherrels))
|
||||
return (JoinInfo *) other_rels;
|
||||
}
|
||||
return ((JInfo *) NULL);
|
||||
return (JoinInfo *) NULL;
|
||||
}
|
||||
|
||||
|
||||
@@ -61,15 +61,15 @@ joininfo_member(List *join_relids, List *joininfo_list)
|
||||
* Returns a joininfo node.
|
||||
*
|
||||
*/
|
||||
JInfo *
|
||||
JoinInfo *
|
||||
find_joininfo_node(RelOptInfo *this_rel, List *join_relids)
|
||||
{
|
||||
JInfo *joininfo = joininfo_member(join_relids,
|
||||
JoinInfo *joininfo = joininfo_member(join_relids,
|
||||
this_rel->joininfo);
|
||||
|
||||
if (joininfo == NULL)
|
||||
{
|
||||
joininfo = makeNode(JInfo);
|
||||
joininfo = makeNode(JoinInfo);
|
||||
joininfo->otherrels = join_relids;
|
||||
joininfo->jinfoclauseinfo = NIL;
|
||||
joininfo->mergejoinable = false;
|
||||
@@ -77,7 +77,7 @@ find_joininfo_node(RelOptInfo *this_rel, List *join_relids)
|
||||
joininfo->inactive = false;
|
||||
this_rel->joininfo = lcons(joininfo, this_rel->joininfo);
|
||||
}
|
||||
return (joininfo);
|
||||
return joininfo;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -108,5 +108,5 @@ other_join_clause_var(Var *var, Expr *clause)
|
||||
retval = l;
|
||||
}
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/keys.c,v 1.7 1998/07/18 04:22:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/keys.c,v 1.8 1998/09/01 03:23:53 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -59,9 +59,9 @@ match_indexkey_operand(int indexkey, Var *operand, RelOptInfo *rel)
|
||||
if (IsA(operand, Var) &&
|
||||
(lfirsti(rel->relids) == operand->varno) &&
|
||||
equal_indexkey_var(indexkey, operand))
|
||||
return (true);
|
||||
return true;
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -74,9 +74,9 @@ static bool
|
||||
equal_indexkey_var(int index_key, Var *var)
|
||||
{
|
||||
if (index_key == var->varattno)
|
||||
return (true);
|
||||
return true;
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -102,7 +102,7 @@ extract_subkey(JoinKey *jk, int which_subkey)
|
||||
elog(DEBUG, "extract_subkey with neither INNER or OUTER");
|
||||
retval = NULL;
|
||||
}
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -130,9 +130,9 @@ samekeys(List *keys1, List *keys2)
|
||||
allmember = false;
|
||||
|
||||
if ((length(keys2) >= length(keys1)) && allmember)
|
||||
return (true);
|
||||
return true;
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -172,9 +172,9 @@ matching2_tlvar(int var, List *tlist, bool (*test) ())
|
||||
}
|
||||
|
||||
if (tlentry)
|
||||
return ((Expr *) get_expr(tlentry));
|
||||
return (Expr *) get_expr(tlentry);
|
||||
else
|
||||
return ((Expr *) NULL);
|
||||
return (Expr *) NULL;
|
||||
}
|
||||
|
||||
|
||||
@@ -197,5 +197,5 @@ collect_index_pathkeys(int *index_keys, List *tlist)
|
||||
NIL));
|
||||
index_keys++;
|
||||
}
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.6 1997/09/08 21:45:52 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.7 1998/09/01 03:23:54 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -81,13 +81,13 @@ equal_path_merge_ordering(Oid *path_ordering,
|
||||
MergeOrder *merge_ordering)
|
||||
{
|
||||
if (path_ordering == NULL || merge_ordering == NULL)
|
||||
return (false);
|
||||
return false;
|
||||
|
||||
if (path_ordering[0] == merge_ordering->left_operator ||
|
||||
path_ordering[0] == merge_ordering->right_operator)
|
||||
return (true);
|
||||
return true;
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -99,7 +99,7 @@ bool
|
||||
equal_merge_merge_ordering(MergeOrder *merge_ordering1,
|
||||
MergeOrder *merge_ordering2)
|
||||
{
|
||||
return (equal(merge_ordering1, merge_ordering2));
|
||||
return equal(merge_ordering1, merge_ordering2);
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -116,7 +116,7 @@ equal_sortops_order(Oid *ordering1, Oid *ordering2)
|
||||
int i = 0;
|
||||
|
||||
if (ordering1 == NULL || ordering2 == NULL)
|
||||
return (ordering1 == ordering2);
|
||||
return ordering1 == ordering2;
|
||||
|
||||
while (ordering1[i] != 0 && ordering2[i] != 0)
|
||||
{
|
||||
@@ -125,5 +125,5 @@ equal_sortops_order(Oid *ordering1, Oid *ordering2)
|
||||
i++;
|
||||
}
|
||||
|
||||
return (ordering1[i] == 0 && ordering2[i] == 0);
|
||||
return ordering1[i] == 0 && ordering2[i] == 0;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.10 1998/08/04 16:44:18 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.11 1998/09/01 03:23:55 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -47,7 +47,7 @@ path_is_cheaper(Path *path1, Path *path2)
|
||||
Cost cost1 = path1->path_cost;
|
||||
Cost cost2 = path2->path_cost;
|
||||
|
||||
return ((bool) (cost1 < cost2));
|
||||
return (bool) (cost1 < cost2);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -82,7 +82,7 @@ set_cheapest(RelOptInfo *parent_rel, List *pathlist)
|
||||
|
||||
parent_rel->cheapestpath = cheapest_so_far;
|
||||
|
||||
return (cheapest_so_far);
|
||||
return cheapest_so_far;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -133,7 +133,7 @@ add_pathlist(RelOptInfo *parent_rel, List *unique_paths, List *new_paths)
|
||||
LispRemove(old_path, unique_paths));
|
||||
}
|
||||
}
|
||||
return (unique_paths);
|
||||
return unique_paths;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -184,7 +184,7 @@ better_path(Path *new_path, List *unique_paths, bool *noOther)
|
||||
retval = old_path;
|
||||
}
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
@@ -233,7 +233,7 @@ create_seqscan_path(RelOptInfo *rel)
|
||||
xfunc_get_path_cost(pathnode);
|
||||
}
|
||||
#endif
|
||||
return (pathnode);
|
||||
return pathnode;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -388,7 +388,7 @@ create_index_path(Query *root,
|
||||
/* XXX Can this divide the selectivities in a better way? */
|
||||
set_clause_selectivities(restriction_clauses, clausesel);
|
||||
}
|
||||
return (pathnode);
|
||||
return pathnode;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -458,7 +458,7 @@ create_nestloop_path(RelOptInfo *joinrel,
|
||||
if (XfuncMode != XFUNC_OFF)
|
||||
pathnode->path_cost += xfunc_get_path_cost((Path *) pathnode);
|
||||
#endif
|
||||
return (pathnode);
|
||||
return pathnode;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -525,7 +525,7 @@ create_mergejoin_path(RelOptInfo *joinrel,
|
||||
xfunc_get_path_cost((Path *) pathnode);
|
||||
}
|
||||
#endif
|
||||
return (pathnode);
|
||||
return pathnode;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -592,5 +592,5 @@ create_hashjoin_path(RelOptInfo *joinrel,
|
||||
xfunc_get_path_cost((Path *) pathnode);
|
||||
}
|
||||
#endif
|
||||
return (pathnode);
|
||||
return pathnode;
|
||||
}
|
||||
|
@@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.19 1998/08/19 02:02:16 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.20 1998/09/01 03:23:56 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -42,8 +42,8 @@
|
||||
|
||||
static void
|
||||
IndexSelectivity(Oid indexrelid, Oid indrelid, int32 nIndexKeys,
|
||||
Oid AccessMethodOperatorClasses[], Oid operatorObjectIds[],
|
||||
int32 varAttributeNumbers[], char *constValues[], int32 constFlags[],
|
||||
Oid *AccessMethodOperatorClasses, Oid *operatorObjectIds,
|
||||
int32 *varAttributeNumbers, char **constValues, int32 *constFlags,
|
||||
float *idxPages, float *idxSelec);
|
||||
|
||||
|
||||
@@ -106,7 +106,7 @@ index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
|
||||
int i;
|
||||
HeapTuple indexTuple,
|
||||
amopTuple;
|
||||
IndexTupleForm index;
|
||||
Form_pg_index index;
|
||||
Relation indexRelation;
|
||||
uint16 amstrategy;
|
||||
Oid relam;
|
||||
@@ -160,11 +160,11 @@ index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
|
||||
heap_close(relation);
|
||||
scan = (HeapScanDesc) NULL;
|
||||
relation = (Relation) NULL;
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Extract info from the index tuple */
|
||||
index = (IndexTupleForm) GETSTRUCT(indexTuple);
|
||||
index = (Form_pg_index) GETSTRUCT(indexTuple);
|
||||
info->relid = index->indexrelid; /* index relation */
|
||||
for (i = 0; i < 8; i++)
|
||||
info->indexkeys[i] = index->indkey[i];
|
||||
@@ -223,7 +223,7 @@ index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
|
||||
info->orderOprs[i] =
|
||||
((Form_pg_amop) GETSTRUCT(amopTuple))->amopopr;
|
||||
}
|
||||
return (TRUE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -347,7 +347,7 @@ restriction_selectivity(Oid functionObjectId,
|
||||
elog(ERROR, "RestrictionClauseSelectivity: bad value %lf",
|
||||
*result);
|
||||
|
||||
return ((Cost) *result);
|
||||
return (Cost) *result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -386,7 +386,7 @@ join_selectivity(Oid functionObjectId,
|
||||
elog(ERROR, "JoinClauseSelectivity: bad value %lf",
|
||||
*result);
|
||||
|
||||
return ((Cost) *result);
|
||||
return (Cost) *result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -416,12 +416,12 @@ find_inheritance_children(Oid inhparent)
|
||||
scan = heap_beginscan(relation, 0, SnapshotNow, 1, key);
|
||||
while (HeapTupleIsValid(inheritsTuple = heap_getnext(scan, 0)))
|
||||
{
|
||||
inhrelid = ((InheritsTupleForm) GETSTRUCT(inheritsTuple))->inhrel;
|
||||
inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrel;
|
||||
list = lappendi(list, inhrelid);
|
||||
}
|
||||
heap_endscan(scan);
|
||||
heap_close(relation);
|
||||
return (list);
|
||||
return list;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -450,7 +450,7 @@ VersionGetParents(Oid verrelid)
|
||||
scan = heap_beginscan(relation, 0, SnapshotNow, 1, key);
|
||||
while (HeapTupleIsValid(versionTuple = heap_getnext(scan, 0)))
|
||||
{
|
||||
verbaseid = ((VersionTupleForm)
|
||||
verbaseid = ((Form_pg_version)
|
||||
GETSTRUCT(versionTuple))->verbaseid;
|
||||
|
||||
list = lconsi(verbaseid, list);
|
||||
@@ -460,7 +460,7 @@ VersionGetParents(Oid verrelid)
|
||||
}
|
||||
heap_endscan(scan);
|
||||
heap_close(relation);
|
||||
return (list);
|
||||
return list;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@@ -492,11 +492,11 @@ static void
|
||||
IndexSelectivity(Oid indexrelid,
|
||||
Oid indrelid,
|
||||
int32 nIndexKeys,
|
||||
Oid AccessMethodOperatorClasses[], /* XXX not used? */
|
||||
Oid operatorObjectIds[],
|
||||
int32 varAttributeNumbers[],
|
||||
char *constValues[],
|
||||
int32 constFlags[],
|
||||
Oid *AccessMethodOperatorClasses, /* XXX not used? */
|
||||
Oid *operatorObjectIds,
|
||||
int32 *varAttributeNumbers,
|
||||
char **constValues,
|
||||
int32 *constFlags,
|
||||
float *idxPages,
|
||||
float *idxSelec)
|
||||
{
|
||||
@@ -505,7 +505,7 @@ IndexSelectivity(Oid indexrelid,
|
||||
HeapTuple indexTuple,
|
||||
amopTuple,
|
||||
indRel;
|
||||
IndexTupleForm index;
|
||||
Form_pg_index index;
|
||||
Form_pg_amop amop;
|
||||
Oid indclass;
|
||||
float64data npages,
|
||||
@@ -530,7 +530,7 @@ IndexSelectivity(Oid indexrelid,
|
||||
if (!HeapTupleIsValid(indexTuple))
|
||||
elog(ERROR, "IndexSelectivity: index %d not found",
|
||||
indexrelid);
|
||||
index = (IndexTupleForm) GETSTRUCT(indexTuple);
|
||||
index = (Form_pg_index) GETSTRUCT(indexTuple);
|
||||
|
||||
/*
|
||||
* Hack for non-functional btree npages estimation: npages =
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.7 1998/08/10 02:26:32 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.8 1998/09/01 03:23:58 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -124,8 +124,8 @@ rel_member(List *relid, List *rels)
|
||||
{
|
||||
temprelid = ((RelOptInfo *) lfirst(temp))->relids;
|
||||
if (same(temprelid, relid))
|
||||
return ((RelOptInfo *) (lfirst(temp)));
|
||||
return (RelOptInfo *) (lfirst(temp));
|
||||
}
|
||||
}
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.16 1998/07/20 21:18:34 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.17 1998/09/01 03:23:59 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -54,10 +54,10 @@ tlistentry_member(Var *var, List *targetlist)
|
||||
{
|
||||
if (var_equal(var,
|
||||
get_expr(lfirst(temp))))
|
||||
return ((TargetEntry *) lfirst(temp));
|
||||
return (TargetEntry *) lfirst(temp);
|
||||
}
|
||||
}
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -75,9 +75,9 @@ matching_tlvar(Var *var, List *targetlist)
|
||||
|
||||
tlentry = tlistentry_member(var, targetlist);
|
||||
if (tlentry)
|
||||
return ((Expr *) get_expr(tlentry));
|
||||
return (Expr *) get_expr(tlentry);
|
||||
|
||||
return ((Expr *) NULL);
|
||||
return (Expr *) NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -163,7 +163,7 @@ get_actual_tlist(List *tlist)
|
||||
if (tlist == NULL)
|
||||
{
|
||||
elog(DEBUG, "calling get_actual_tlist with empty tlist");
|
||||
return (NIL);
|
||||
return NIL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -175,7 +175,7 @@ get_actual_tlist(List *tlist)
|
||||
foreach(element, tlist)
|
||||
result = lappend(result, lfirst((List *) lfirst(element)));
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
#endif
|
||||
return tlist;
|
||||
}
|
||||
@@ -216,11 +216,11 @@ tlist_member(Var *var, List *tlist)
|
||||
}
|
||||
|
||||
if (tl_elt != NULL)
|
||||
return (tl_elt->resdom);
|
||||
return tl_elt->resdom;
|
||||
else
|
||||
return ((Resdom *) NULL);
|
||||
return (Resdom *) NULL;
|
||||
}
|
||||
return ((Resdom *) NULL);
|
||||
return (Resdom *) NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -239,9 +239,9 @@ tlist_resdom(List *tlist, Resdom *resnode)
|
||||
resdom = temp_tle->resdom;
|
||||
/* Since resnos are supposed to be unique */
|
||||
if (resnode->resno == resdom->resno)
|
||||
return (resdom);
|
||||
return resdom;
|
||||
}
|
||||
return ((Resdom *) NULL);
|
||||
return (Resdom *) NULL;
|
||||
}
|
||||
|
||||
|
||||
@@ -291,11 +291,11 @@ match_varid(Var *test_var, List *tlist)
|
||||
{
|
||||
|
||||
if (tlvar->vartype == type_var)
|
||||
return (entry);
|
||||
return entry;
|
||||
}
|
||||
}
|
||||
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
@@ -322,7 +322,7 @@ new_unsorted_tlist(List *targetlist)
|
||||
tle->resdom->reskey = 0;
|
||||
tle->resdom->reskeyop = (Oid) 0;
|
||||
}
|
||||
return (new_targetlist);
|
||||
return new_targetlist;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -352,7 +352,7 @@ copy_vars(List *target, List *source)
|
||||
|
||||
result = lappend(result, temp);
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -436,7 +436,7 @@ flatten_tlist_vars(List *full_tlist, List *flat_tlist)
|
||||
flat_tlist)));
|
||||
}
|
||||
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -546,7 +546,7 @@ get_expr(TargetEntry *tle)
|
||||
Assert(tle != NULL);
|
||||
Assert(tle->expr != NULL);
|
||||
|
||||
return ((Var *) tle->expr);
|
||||
return (Var *) tle->expr;
|
||||
}
|
||||
|
||||
|
||||
|
@@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.12 1998/06/15 19:28:50 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.13 1998/09/01 03:24:00 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -42,7 +42,7 @@ pull_varnos(Node *me)
|
||||
*result = NIL;
|
||||
|
||||
if (me == NULL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
|
||||
switch (nodeTag(me))
|
||||
{
|
||||
@@ -63,7 +63,7 @@ pull_varnos(Node *me)
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return (result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -154,7 +154,7 @@ pull_var_clause(Node *clause)
|
||||
List *retval = NIL;
|
||||
|
||||
if (clause == NULL)
|
||||
return (NIL);
|
||||
return NIL;
|
||||
else if (IsA(clause, Var))
|
||||
retval = lcons(clause, NIL);
|
||||
else if (IsA(clause, Iter))
|
||||
@@ -202,7 +202,7 @@ pull_var_clause(Node *clause)
|
||||
else
|
||||
retval = NIL;
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -221,8 +221,8 @@ var_equal(Var *var1, Var *var2)
|
||||
(((Var *) var1)->varattno == ((Var *) var2)->varattno))
|
||||
{
|
||||
Assert(((Var *) var1)->varlevelsup == 0);
|
||||
return (true);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return (false);
|
||||
return false;
|
||||
}
|
||||
|
Reference in New Issue
Block a user