</para>
<para>
This algorithm is on by default, which used GEQO for
- statements of six or more tables and indexes.
+ statements of six or more tables.
(See the chapter on GEQO in the Programmer's Guide
for more information).
</para>
SET DATESTYLE TO 'ISO';
</programlisting>
<programlisting>
- --Enable GEQO for queries with 4 or more tables and indexes
+ --Enable GEQO for queries with 4 or more tables
--
SET GEQO ON=4;
</programlisting>
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_eval.c,v 1.29 1999/02/13 23:16:07 momjian Exp $
+ * $Id: geqo_eval.c,v 1.30 1999/02/14 04:56:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* process new_rel->pathlist */
- find_all_join_paths(root, new_rels);
+ update_rels_pathlist_for_joins(root, new_rels);
/* prune new_rels */
/* MAU: is this necessary? */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.31 1999/02/13 23:16:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.32 1999/02/14 04:56:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int32 _use_geqo_rels_ = GEQO_RELS;
-static void find_rel_paths(Query *root, List *rels);
+static void find_base_rel_paths(Query *root, List *rels);
static List *find_join_paths(Query *root, List *outer_rels, int levels_needed);
#ifdef OPTIMIZER_DEBUG
if (levels_needed <= 0)
return NIL;
- /*
- * Find the base relation paths.
- */
- find_rel_paths(root, rels);
+ find_base_rel_paths(root, rels);
if (levels_needed <= 1)
{
}
/*
- * find_rel_paths
+ * find_base_rel_paths
* Finds all paths available for scanning each relation entry in
* 'rels'. Sequential scan and any available indices are considered
* if possible(indices are not considered for lower nesting levels).
* MODIFIES: rels
*/
static void
-find_rel_paths(Query *root, List *rels)
+find_base_rel_paths(Query *root, List *rels)
{
List *temp;
* finding ways to join relations(both original and derived) together.
*
* 'outer_rels' is the current list of relations for which join paths
- * are to be found, i.e., he current list of relations that
+ * are to be found, i.e., the current list of relations that
* have already been derived.
* 'levels_needed' is the number of iterations needed
*
* genetic query optimizer entry point *
* <utesch@aut.tu-freiberg.de> *
*******************************************/
- {
- List *temp;
- int paths_to_consider = 0;
-
- foreach(temp, outer_rels)
- {
- RelOptInfo *rel = (RelOptInfo *) lfirst(temp);
- paths_to_consider += length(rel->pathlist);
- }
-
- if ((_use_geqo_) && paths_to_consider >= _use_geqo_rels_)
- /* returns _one_ RelOptInfo, so lcons it */
- return lcons(geqo(root), NIL);
- }
+ if ((_use_geqo_) && length(root->base_relation_list_) >= _use_geqo_rels_)
+ return lcons(geqo(root), NIL); /* returns *one* Rel, so lcons it */
/*******************************************
* rest will be deprecated in case of GEQO *
* modify 'new_rels' accordingly, then eliminate redundant join
* relations.
*/
- new_rels = find_join_rels(root, outer_rels);
+ new_rels = make_new_rels_by_joins(root, outer_rels);
- find_all_join_paths(root, new_rels);
+ update_rels_pathlist_for_joins(root, new_rels);
- prune_joinrels(new_rels);
+ merge_rels_with_same_relids(new_rels);
#if 0
/*
foreach(x, new_rels)
{
rel = (RelOptInfo *) lfirst(x);
+
if (rel->size <= 0)
rel->size = compute_rel_size(rel);
rel->width = compute_rel_width(rel);
- /* #define OPTIMIZER_DEBUG */
#ifdef OPTIMIZER_DEBUG
printf("levels left: %d\n", levels_needed);
debug_print_rel(root, rel);
}
else
root->join_rel_list = new_rels;
+
if (!BushyPlanFlag)
outer_rels = new_rels;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.23 1999/02/13 23:16:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.24 1999/02/14 04:56:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
List *hashinfo_list);
/*
- * find_all_join_paths
+ * update_rels_pathlist_for_joins
* Creates all possible ways to process joins for each of the join
* relations in the list 'joinrels.' Each unique path will be included
* in the join relation's 'pathlist' field.
* It does a destructive modification.
*/
void
-find_all_join_paths(Query *root, List *joinrels)
+update_rels_pathlist_for_joins(Query *root, List *joinrels)
{
List *mergeinfo_list = NIL;
List *hashinfo_list = NIL;
List *temp_list = NIL;
List *path = NIL;
+ List *j;
- while (joinrels != NIL)
+ foreach(j, joinrels)
{
- RelOptInfo *joinrel = (RelOptInfo *) lfirst(joinrels);
+ RelOptInfo *joinrel = (RelOptInfo *) lfirst(j);
List *innerrelids;
List *outerrelids;
RelOptInfo *innerrel;
* since the base level
*/
}
-
- joinrels = lnext(joinrels);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.20 1999/02/13 23:16:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.21 1999/02/14 04:56:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
JoinInfo * jinfo);
/*
- * find_join_rels
+ * make_new_rels_by_joins
* Find all possible joins for each of the outer join relations in
* 'outer_rels'. A rel node is created for each possible join relation,
* and the resulting list of nodes is returned. If at all possible, only
* Returns a list of rel nodes corresponding to the new join relations.
*/
List *
-find_join_rels(Query *root, List *outer_rels)
+make_new_rels_by_joins(Query *root, List *outer_rels)
{
List *joins = NIL;
List *join_list = NIL;
if (!(joins = find_clause_joins(root, outer_rel, outer_rel->joininfo)))
{
+ /*
+ * Oops, we have a relation that is not joined to any other
+ * relation. Cartesian product time.
+ */
if (BushyPlanFlag)
joins = find_clauseless_joins(outer_rel, outer_rels);
else
{
if (rel != NULL)
join_list = lappend(join_list, rel);
- rel = init_join_rel(get_base_rel(root, lfirsti(other_rels)),
+ rel = init_join_rel(get_base_rel(root,
+ lfirsti(other_rels)),
outer_rel,
joininfo);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.31 1999/02/13 23:16:23 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.32 1999/02/14 04:56:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/elog.h"
-static List *prune_joinrel(RelOptInfo *rel, List *other_rels);
+static List *merge_rel_with_same_relids(RelOptInfo *rel, List *other_rels);
/*
- * prune_joinrels
+ * merge_rels_with_same_relids
* Removes any redundant relation entries from a list of rel nodes
* 'rel_list'. Obviously, the first relation can't be a duplicate.
*
*
*/
void
-prune_joinrels(List *rel_list)
+merge_rels_with_same_relids(List *rel_list)
{
List *i;
* deleted
*/
foreach(i, rel_list)
- lnext(i) = prune_joinrel((RelOptInfo *) lfirst(i), lnext(i));
+ lnext(i) = merge_rel_with_same_relids((RelOptInfo *) lfirst(i), lnext(i));
}
/*
- * prune_joinrel
+ * merge_rel_with_same_relids
* Prunes those relations from 'other_rels' that are redundant with
* 'rel'. A relation is redundant if it is built up of the same
* relations as 'rel'. Paths for the redundant relation are merged into
*
*/
static List *
-prune_joinrel(RelOptInfo *rel, List *other_rels)
+merge_rel_with_same_relids(RelOptInfo *rel, List *other_rels)
{
List *i = NIL;
List *result = NIL;
{
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
- rel_list2 = prune_joinrel(rel, rel_list2);
+ rel_list2 = merge_rel_with_same_relids(rel, rel_list2);
}
return append(rel_list1, rel_list2);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.23 1999/02/13 23:16:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.24 1999/02/14 04:56:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*****************************************************************************/
/*
- * init_join_info
+ * set_joininfo_mergeable_hashable
* Set the MergeJoinable or HashJoinable field for every joininfo node
- * (within a rel node) and the MergeJoinOrder or HashJoinOp field for
+ * (within a rel node) and the mergejoinorder or hashjoinop field for
* each restrictinfo node(within a joininfo node) for all relations in a
* query.
*
* Returns nothing.
*/
void
-init_join_info(List *rel_list)
+set_joininfo_mergeable_hashable(List *rel_list)
{
List *x,
*y,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.31 1999/02/13 23:16:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.32 1999/02/14 04:56:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
else
return (Plan *) scan;
}
- break;
+ break;
default:
return (Plan *) NULL;
}
add_restrict_and_join_to_rels(root, qual);
add_missing_vars_to_tlist(root, flat_tlist);
- /*
- * Find all possible scan and join paths. Mark all the clauses and
- * relations that can be processed using special join methods, then do
- * the exhaustive path search.
- */
- init_join_info(root->base_rel_list);
+ set_joininfo_mergeable_hashable(root->base_rel_list);
final_rel_list = find_paths(root, root->base_rel_list);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: paths.h,v 1.15 1999/02/13 23:21:50 momjian Exp $
+ * $Id: paths.h,v 1.16 1999/02/14 04:56:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* joinpath.h
* routines to create join paths
*/
-extern void find_all_join_paths(Query *root, List *joinrels);
+extern void update_rels_pathlist_for_joins(Query *root, List *joinrels);
/*
* joinrels.h
* routines to determine which relations to join
*/
-extern List *find_join_rels(Query *root, List *outer_rels);
+extern List *make_new_rels_by_joins(Query *root, List *outer_rels);
extern void add_new_joininfos(Query *root, List *joinrels, List *outerrels);
extern List *final_join_rels(List *join_rel_list);
/*
* prototypes for path/prune.c
*/
-extern void prune_joinrels(List *rel_list);
+extern void merge_rels_with_same_relids(List *rel_list);
extern void rels_set_cheapest(List *rel_list);
extern List *merge_joinrels(List *rel_list1, List *rel_list2);
extern List *prune_oldrels(List *old_rels);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.21 1999/02/13 23:21:50 momjian Exp $
+ * $Id: planmain.h,v 1.22 1999/02/14 04:56:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern void make_var_only_tlist(Query *root, List *tlist);
extern void add_restrict_and_join_to_rels(Query *root, List *clauses);
-extern void init_join_info(List *rel_list);
+extern void set_joininfo_mergeable_hashable(List *rel_list);
extern void add_missing_vars_to_tlist(Query *root, List *tlist);
/*
-/*-------------------------------------------------------------------------
+/*-------------------------------------------------------------------------
*
- * version.h.in--
+ * version.h.in
* this file contains the interface to version.c.
* Also some parameters.
*
- * $Header: /cvsroot/pgsql/src/include/Attic/version.h.in,v 1.4 1998/12/25 02:20:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/include/Attic/version.h.in,v 1.5 1999/02/14 04:56:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
.\" This is -*-nroff-*-
.\" XXX standard disclaimer belongs here....
-.\" $Header: /cvsroot/pgsql/src/man/Attic/set.l,v 1.13 1999/02/02 20:30:18 momjian Exp $
+.\" $Header: /cvsroot/pgsql/src/man/Attic/set.l,v 1.14 1999/02/14 04:57:02 momjian Exp $
.TH SET SQL 05/14/97 PostgreSQL PostgreSQL
.SH NAME
set - set run-time parameters for session
.IR GEQO
enables or disables the genetic optimizer algorithm. This algorithm is
.IR on
-by default, which used GEQO for statements of six or more tables and indexes.
+by default, which used GEQO for statements of six or more tables.
Set the
.IR Programmer's Guide
for more information.
.PP
.nf
--
---Use GEQO for statements with 4 or more tables and indexes
+--Use GEQO for statements with 4 or more tables
--
set GEQO to 'on=4'
--
projects / postgresql.git / commitdiff