1
0
mirror of https://github.com/postgres/postgres.git synced 2025-07-11 10:01:57 +03:00

pgindent run.

This commit is contained in:
Bruce Momjian
2003-08-04 00:43:34 +00:00
parent 63354a0228
commit 089003fb46
554 changed files with 24888 additions and 21245 deletions

View File

@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.149 2003/07/25 00:01:07 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.150 2003/08/04 00:43:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -40,9 +40,9 @@ static bool use_physical_tlist(RelOptInfo *rel);
static void disuse_physical_tlist(Plan *plan, Path *path);
static Join *create_join_plan(Query *root, JoinPath *best_path);
static Append *create_append_plan(Query *root, AppendPath *best_path);
static Result *create_result_plan(Query *root, ResultPath *best_path);
static Material *create_material_plan(Query *root, MaterialPath *best_path);
static Plan *create_unique_plan(Query *root, UniquePath *best_path);
static Result *create_result_plan(Query *root, ResultPath * best_path);
static Material *create_material_plan(Query *root, MaterialPath * best_path);
static Plan *create_unique_plan(Query *root, UniquePath * best_path);
static SeqScan *create_seqscan_plan(Path *best_path, List *tlist,
List *scan_clauses);
static IndexScan *create_indexscan_plan(Query *root, IndexPath *best_path,
@ -63,9 +63,9 @@ static void fix_indxqual_references(List *indexquals, IndexPath *index_path,
List **fixed_indexquals,
List **recheck_indexquals);
static void fix_indxqual_sublist(List *indexqual,
Relids baserelids, int baserelid,
IndexOptInfo *index,
List **fixed_quals, List **recheck_quals);
Relids baserelids, int baserelid,
IndexOptInfo *index,
List **fixed_quals, List **recheck_quals);
static Node *fix_indxqual_operand(Node *node, int baserelid,
IndexOptInfo *index,
Oid *opclass);
@ -98,9 +98,9 @@ static MergeJoin *make_mergejoin(List *tlist,
Plan *lefttree, Plan *righttree,
JoinType jointype);
static Sort *make_sort(Query *root, List *tlist, Plan *lefttree, int numCols,
AttrNumber *sortColIdx, Oid *sortOperators);
AttrNumber *sortColIdx, Oid *sortOperators);
static Sort *make_sort_from_pathkeys(Query *root, Plan *lefttree,
Relids relids, List *pathkeys);
Relids relids, List *pathkeys);
/*
@ -148,7 +148,7 @@ create_plan(Query *root, Path *best_path)
break;
case T_Material:
plan = (Plan *) create_material_plan(root,
(MaterialPath *) best_path);
(MaterialPath *) best_path);
break;
case T_Unique:
plan = (Plan *) create_unique_plan(root,
@ -192,12 +192,12 @@ create_scan_plan(Query *root, Path *best_path)
Scan *plan;
/*
* For table scans, rather than using the relation targetlist (which is
* only those Vars actually needed by the query), we prefer to generate a
* tlist containing all Vars in order. This will allow the executor to
* optimize away projection of the table tuples, if possible. (Note that
* planner.c may replace the tlist we generate here, forcing projection to
* occur.)
* For table scans, rather than using the relation targetlist (which
* is only those Vars actually needed by the query), we prefer to
* generate a tlist containing all Vars in order. This will allow the
* executor to optimize away projection of the table tuples, if
* possible. (Note that planner.c may replace the tlist we generate
* here, forcing projection to occur.)
*/
if (use_physical_tlist(rel))
{
@ -274,8 +274,8 @@ build_relation_tlist(RelOptInfo *rel)
FastListInit(&tlist);
foreach(v, FastListValue(&rel->reltargetlist))
{
/* Do we really need to copy here? Not sure */
Var *var = (Var *) copyObject(lfirst(v));
/* Do we really need to copy here? Not sure */
Var *var = (Var *) copyObject(lfirst(v));
FastAppend(&tlist, create_tl_element(var, resdomno));
resdomno++;
@ -294,22 +294,24 @@ use_physical_tlist(RelOptInfo *rel)
int i;
/*
* Currently, can't do this for subquery or function scans. (This
* is mainly because we don't have an equivalent of build_physical_tlist
* Currently, can't do this for subquery or function scans. (This is
* mainly because we don't have an equivalent of build_physical_tlist
* for them; worth adding?)
*/
if (rel->rtekind != RTE_RELATION)
return false;
/*
* Can't do it with inheritance cases either (mainly because Append
* doesn't project).
*/
if (rel->reloptkind != RELOPT_BASEREL)
return false;
/*
* Can't do it if any system columns are requested, either. (This could
* possibly be fixed but would take some fragile assumptions in setrefs.c,
* I think.)
* Can't do it if any system columns are requested, either. (This
* could possibly be fixed but would take some fragile assumptions in
* setrefs.c, I think.)
*/
for (i = rel->min_attr; i <= 0; i++)
{
@ -325,7 +327,7 @@ use_physical_tlist(RelOptInfo *rel)
*
* If the plan node immediately above a scan would prefer to get only
* needed Vars and not a physical tlist, it must call this routine to
* undo the decision made by use_physical_tlist(). Currently, Hash, Sort,
* undo the decision made by use_physical_tlist(). Currently, Hash, Sort,
* and Material nodes want this, so they don't have to store useless columns.
*/
static void
@ -441,7 +443,7 @@ create_append_plan(Query *root, AppendPath *best_path)
* Returns a Plan node.
*/
static Result *
create_result_plan(Query *root, ResultPath *best_path)
create_result_plan(Query *root, ResultPath * best_path)
{
Result *plan;
List *tlist;
@ -473,7 +475,7 @@ create_result_plan(Query *root, ResultPath *best_path)
* Returns a Plan node.
*/
static Material *
create_material_plan(Query *root, MaterialPath *best_path)
create_material_plan(Query *root, MaterialPath * best_path)
{
Material *plan;
Plan *subplan;
@ -498,7 +500,7 @@ create_material_plan(Query *root, MaterialPath *best_path)
* Returns a Plan node.
*/
static Plan *
create_unique_plan(Query *root, UniquePath *best_path)
create_unique_plan(Query *root, UniquePath * best_path)
{
Plan *plan;
Plan *subplan;
@ -509,9 +511,9 @@ create_unique_plan(Query *root, UniquePath *best_path)
subplan = create_plan(root, best_path->subpath);
/*
* If the subplan came from an IN subselect (currently always the case),
* we need to instantiate the correct output targetlist for the subselect,
* rather than using the flattened tlist.
* If the subplan came from an IN subselect (currently always the
* case), we need to instantiate the correct output targetlist for the
* subselect, rather than using the flattened tlist.
*/
sub_targetlist = NIL;
foreach(l, root->in_info_list)
@ -530,8 +532,8 @@ create_unique_plan(Query *root, UniquePath *best_path)
/*
* Transform list of plain Vars into targetlist
*/
List *newtlist = NIL;
int resno = 1;
List *newtlist = NIL;
int resno = 1;
foreach(l, sub_targetlist)
{
@ -547,12 +549,13 @@ create_unique_plan(Query *root, UniquePath *best_path)
newtlist = lappend(newtlist, tle);
resno++;
}
/*
* If the top plan node can't do projections, we need to add a
* Result node to help it along.
*
* Currently, the only non-projection-capable plan type
* we can see here is Append.
* Currently, the only non-projection-capable plan type we can see
* here is Append.
*/
if (IsA(subplan, Append))
subplan = (Plan *) make_result(newtlist, NULL, subplan);
@ -564,16 +567,16 @@ create_unique_plan(Query *root, UniquePath *best_path)
if (best_path->use_hash)
{
int numGroupCols = length(my_tlist);
long numGroups;
int numGroupCols = length(my_tlist);
long numGroups;
AttrNumber *groupColIdx;
int i;
int i;
numGroups = (long) Min(best_path->rows, (double) LONG_MAX);
groupColIdx = (AttrNumber *) palloc(numGroupCols * sizeof(AttrNumber));
for (i = 0; i < numGroupCols; i++)
groupColIdx[i] = i+1;
groupColIdx[i] = i + 1;
plan = (Plan *) make_agg(root,
my_tlist,
@ -700,9 +703,7 @@ create_indexscan_plan(Query *root,
FastListInit(&orclauses);
foreach(orclause, indxqual)
{
FastAppend(&orclauses, make_ands_explicit(lfirst(orclause)));
}
indxqual_or_expr = make_orclause(FastListValue(&orclauses));
qpqual = set_difference(scan_clauses, makeList1(indxqual_or_expr));
@ -861,9 +862,9 @@ create_nestloop_plan(Query *root,
/*
* An index is being used to reduce the number of tuples scanned
* in the inner relation. If there are join clauses being used
* with the index, we may remove those join clauses from the list of
* clauses that have to be checked as qpquals at the join node ---
* but only if there's just one indexscan in the inner path
* with the index, we may remove those join clauses from the list
* of clauses that have to be checked as qpquals at the join node
* --- but only if there's just one indexscan in the inner path
* (otherwise, several different sets of clauses are being ORed
* together).
*
@ -873,13 +874,14 @@ create_nestloop_plan(Query *root,
* been put in the same joininfo list.
*
* This would be a waste of time if the indexpath was an ordinary
* indexpath and not a special innerjoin path. We will skip it in
* that case since indexjoinclauses is NIL in an ordinary indexpath.
* indexpath and not a special innerjoin path. We will skip it in
* that case since indexjoinclauses is NIL in an ordinary
* indexpath.
*/
IndexPath *innerpath = (IndexPath *) best_path->innerjoinpath;
List *indexjoinclauses = innerpath->indexjoinclauses;
if (length(indexjoinclauses) == 1) /* single indexscan? */
if (length(indexjoinclauses) == 1) /* single indexscan? */
{
joinrestrictclauses =
select_nonredundant_join_clauses(root,
@ -947,11 +949,11 @@ create_mergejoin_plan(Query *root,
joinclauses = set_difference(joinclauses, mergeclauses);
/*
* Rearrange mergeclauses, if needed, so that the outer variable
* is always on the left.
* Rearrange mergeclauses, if needed, so that the outer variable is
* always on the left.
*/
mergeclauses = get_switched_clauses(best_path->path_mergeclauses,
best_path->jpath.outerjoinpath->parent->relids);
best_path->jpath.outerjoinpath->parent->relids);
/*
* Create explicit sort nodes for the outer and inner join paths if
@ -964,7 +966,7 @@ create_mergejoin_plan(Query *root,
outer_plan = (Plan *)
make_sort_from_pathkeys(root,
outer_plan,
best_path->jpath.outerjoinpath->parent->relids,
best_path->jpath.outerjoinpath->parent->relids,
best_path->outersortkeys);
}
@ -974,7 +976,7 @@ create_mergejoin_plan(Query *root,
inner_plan = (Plan *)
make_sort_from_pathkeys(root,
inner_plan,
best_path->jpath.innerjoinpath->parent->relids,
best_path->jpath.innerjoinpath->parent->relids,
best_path->innersortkeys);
}
@ -1030,21 +1032,19 @@ create_hashjoin_plan(Query *root,
joinclauses = set_difference(joinclauses, hashclauses);
/*
* Rearrange hashclauses, if needed, so that the outer variable
* is always on the left.
* Rearrange hashclauses, if needed, so that the outer variable is
* always on the left.
*/
hashclauses = get_switched_clauses(best_path->path_hashclauses,
best_path->jpath.outerjoinpath->parent->relids);
best_path->jpath.outerjoinpath->parent->relids);
/*
* Extract the inner hash keys (right-hand operands of the hashclauses)
* to put in the Hash node.
* Extract the inner hash keys (right-hand operands of the
* hashclauses) to put in the Hash node.
*/
innerhashkeys = NIL;
foreach(hcl, hashclauses)
{
innerhashkeys = lappend(innerhashkeys, get_rightop(lfirst(hcl)));
}
/* We don't want any excess columns in the hashed tuples */
disuse_physical_tlist(inner_plan, best_path->jpath.innerjoinpath);
@ -1362,7 +1362,7 @@ order_qual_clauses(Query *root, List *clauses)
FastListInit(&withsubplans);
foreach(l, clauses)
{
Node *clause = lfirst(l);
Node *clause = lfirst(l);
if (contain_subplans(clause))
FastAppend(&withsubplans, clause);
@ -1507,8 +1507,8 @@ make_subqueryscan(List *qptlist,
/*
* Cost is figured here for the convenience of prepunion.c. Note this
* is only correct for the case where qpqual is empty; otherwise caller
* should overwrite cost with a better estimate.
* is only correct for the case where qpqual is empty; otherwise
* caller should overwrite cost with a better estimate.
*/
copy_plan_costsize(plan, subplan);
plan->total_cost += cpu_tuple_cost * subplan->plan_rows;
@ -1709,7 +1709,7 @@ make_sort(Query *root, List *tlist, Plan *lefttree, int numCols,
* once as a sort key column; if so, the extra mentions are redundant.
*
* Caller is assumed to have allocated the arrays large enough for the
* max possible number of columns. Return value is the new column count.
* max possible number of columns. Return value is the new column count.
*/
static int
add_sort_column(AttrNumber colIdx, Oid sortOp,
@ -1777,8 +1777,8 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
/*
* We can sort by any one of the sort key items listed in this
* sublist. For now, we take the first one that corresponds to an
* available Var in the tlist. If there isn't any, use the
* first one that is an expression in the input's vars.
* available Var in the tlist. If there isn't any, use the first
* one that is an expression in the input's vars.
*
* XXX if we have a choice, is there any way of figuring out which
* might be cheapest to execute? (For example, int4lt is likely
@ -1805,17 +1805,19 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
}
if (!j)
elog(ERROR, "could not find pathkey item to sort");
/*
* Do we need to insert a Result node?
*
* Currently, the only non-projection-capable plan type
* we can see here is Append.
* Currently, the only non-projection-capable plan type we can
* see here is Append.
*/
if (IsA(lefttree, Append))
{
tlist = copyObject(tlist);
lefttree = (Plan *) make_result(tlist, NULL, lefttree);
}
/*
* Add resjunk entry to input's tlist
*/
@ -1827,8 +1829,9 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
tlist = lappend(tlist,
makeTargetEntry(resdom,
(Expr *) pathkey->key));
lefttree->targetlist = tlist; /* just in case NIL before */
lefttree->targetlist = tlist; /* just in case NIL before */
}
/*
* The column might already be selected as a sort key, if the
* pathkeys contain duplicate entries. (This can happen in
@ -1836,7 +1839,7 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
* var, for example.) So enter it only once in the sort arrays.
*/
numsortkeys = add_sort_column(resdom->resno, pathkey->sortop,
numsortkeys, sortColIdx, sortOperators);
numsortkeys, sortColIdx, sortOperators);
}
Assert(numsortkeys > 0);
@ -1881,10 +1884,11 @@ make_sort_from_sortclauses(Query *root, List *tlist,
/*
* Check for the possibility of duplicate order-by clauses --- the
* parser should have removed 'em, but no point in sorting redundantly.
* parser should have removed 'em, but no point in sorting
* redundantly.
*/
numsortkeys = add_sort_column(resdom->resno, sortcl->sortop,
numsortkeys, sortColIdx, sortOperators);
numsortkeys, sortColIdx, sortOperators);
}
Assert(numsortkeys > 0);
@ -1938,10 +1942,11 @@ make_sort_from_groupcols(Query *root,
/*
* Check for the possibility of duplicate group-by clauses --- the
* parser should have removed 'em, but no point in sorting redundantly.
* parser should have removed 'em, but no point in sorting
* redundantly.
*/
numsortkeys = add_sort_column(resdom->resno, grpcl->sortop,
numsortkeys, sortColIdx, sortOperators);
numsortkeys, sortColIdx, sortOperators);
grpno++;
}
@ -1973,7 +1978,7 @@ make_material(List *tlist, Plan *lefttree)
* materialize_finished_plan: stick a Material node atop a completed plan
*
* There are a couple of places where we want to attach a Material node
* after completion of subquery_planner(). This currently requires hackery.
* after completion of subquery_planner(). This currently requires hackery.
* Since subquery_planner has already run SS_finalize_plan on the subplan
* tree, we have to kluge up parameter lists for the Material node.
* Possibly this could be fixed by postponing SS_finalize_plan processing
@ -2032,8 +2037,8 @@ make_agg(Query *root, List *tlist, List *qual,
plan->total_cost = agg_path.total_cost;
/*
* We will produce a single output tuple if not grouping,
* and a tuple per group otherwise.
* We will produce a single output tuple if not grouping, and a tuple
* per group otherwise.
*/
if (aggstrategy == AGG_PLAIN)
plan->plan_rows = 1;
@ -2041,10 +2046,10 @@ make_agg(Query *root, List *tlist, List *qual,
plan->plan_rows = numGroups;
/*
* We also need to account for the cost of evaluation of the qual
* (ie, the HAVING clause) and the tlist. Note that cost_qual_eval
* doesn't charge anything for Aggref nodes; this is okay since
* they are really comparable to Vars.
* We also need to account for the cost of evaluation of the qual (ie,
* the HAVING clause) and the tlist. Note that cost_qual_eval doesn't
* charge anything for Aggref nodes; this is okay since they are
* really comparable to Vars.
*
* See notes in grouping_planner about why this routine and make_group
* are the only ones in this file that worry about tlist eval cost.
@ -2100,13 +2105,13 @@ make_group(Query *root,
/*
* We also need to account for the cost of evaluation of the tlist.
*
* XXX this double-counts the cost of evaluation of any expressions
* used for grouping, since in reality those will have been evaluated
* at a lower plan level and will only be copied by the Group node.
* Worth fixing?
* XXX this double-counts the cost of evaluation of any expressions used
* for grouping, since in reality those will have been evaluated at a
* lower plan level and will only be copied by the Group node. Worth
* fixing?
*
* See notes in grouping_planner about why this routine and make_agg
* are the only ones in this file that worry about tlist eval cost.
* See notes in grouping_planner about why this routine and make_agg are
* the only ones in this file that worry about tlist eval cost.
*/
cost_qual_eval(&qual_cost, tlist);
plan->startup_cost += qual_cost.startup;
@ -2139,15 +2144,15 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
/*
* Charge one cpu_operator_cost per comparison per input tuple. We
* assume all columns get compared at most of the tuples. (XXX probably
* this is an overestimate.)
* assume all columns get compared at most of the tuples. (XXX
* probably this is an overestimate.)
*/
plan->total_cost += cpu_operator_cost * plan->plan_rows * numCols;
/*
* plan->plan_rows is left as a copy of the input subplan's plan_rows;
* ie, we assume the filter removes nothing. The caller must alter this
* if he has a better idea.
* ie, we assume the filter removes nothing. The caller must alter
* this if he has a better idea.
*/
plan->targetlist = tlist;