database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-13 16:22:44 +03:00
Code Activity

pgindent run before 6.3 release, with Thomas' requested changes.

Browse Source
This commit is contained in:
Bruce Momjian
1998-02-26 04:46:47 +00:00
parent 757bf69a2e
commit a32450a585
430 changed files with 12390 additions and 10292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
src/backend/optimizer/plan/createplan.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.26 1998/02/13 03:36:54 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.27 1998/02/26 04:32:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -46,33 +46,44 @@
static List *switch_outer(List *clauses);
static Scan *create_scan_node(Path *best_path, List *tlist);
static Join *create_join_node(JoinPath *best_path, List *tlist);
static SeqScan *create_seqscan_node(Path *best_path, List *tlist,
static SeqScan *
create_seqscan_node(Path *best_path, List *tlist,
List *scan_clauses);
static IndexScan *create_indexscan_node(IndexPath *best_path, List *tlist,
static IndexScan *
create_indexscan_node(IndexPath *best_path, List *tlist,
List *scan_clauses);
static NestLoop *create_nestloop_node(JoinPath *best_path, List *tlist,
static NestLoop *
create_nestloop_node(JoinPath *best_path, List *tlist,
List *clauses, Plan *outer_node, List *outer_tlist,
Plan *inner_node, List *inner_tlist);
static MergeJoin *create_mergejoin_node(MergePath *best_path, List *tlist,
static MergeJoin *
create_mergejoin_node(MergePath *best_path, List *tlist,
List *clauses, Plan *outer_node, List *outer_tlist,
Plan *inner_node, List *inner_tlist);
static HashJoin *create_hashjoin_node(HashPath *best_path, List *tlist,
static HashJoin *
create_hashjoin_node(HashPath *best_path, List *tlist,
List *clauses, Plan *outer_node, List *outer_tlist,
Plan *inner_node, List *inner_tlist);
static Node *fix_indxqual_references(Node *clause, Path *index_path);
static Temp *make_temp(List *tlist, List *keys, Oid *operators,
static Temp *
make_temp(List *tlist, List *keys, Oid *operators,
Plan *plan_node, int temptype);
static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
static IndexScan *
make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
List *indxid, List *indxqual, Cost cost);
static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
static NestLoop *
make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
Plan *righttree);
static HashJoin *make_hashjoin(List *tlist, List *qpqual,
static HashJoin *
make_hashjoin(List *tlist, List *qpqual,
List *hashclauses, Plan *lefttree, Plan *righttree);
static Hash *make_hash(List *tlist, Var *hashkey, Plan *lefttree);
static MergeJoin *make_mergesort(List *tlist, List *qpqual,
static MergeJoin *
make_mergesort(List *tlist, List *qpqual,
List *mergeclauses, Oid opcode, Oid *rightorder,
Oid *leftorder, Plan *righttree, Plan *lefttree);
static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
static Material *
make_material(List *tlist, Oid tempid, Plan *lefttree,
int keycount);
/*
@@ -90,7 +101,7 @@ static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
*
* Returns the optimal(?) access plan.
*/
Plan *
Plan *
create_plan(Path *best_path)
{
List *tlist;
@@ -931,7 +942,7 @@ make_seqscan(List *qptlist,
SeqScan *node = makeNode(SeqScan);
Plan *plan = &node->plan;
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = qptlist;
plan->qual = qpqual;
@@ -949,7 +960,7 @@ make_indexscan(List *qptlist,
Index scanrelid,
List *indxid,
List *indxqual,
Cost cost)
Cost cost)
{
IndexScan *node = makeNode(IndexScan);
Plan *plan = &node->scan.plan;
@@ -978,8 +989,8 @@ make_nestloop(List *qptlist,
NestLoop *node = makeNode(NestLoop);
Plan *plan = &node->join;
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = qptlist;
plan->qual = qpqual;
@@ -1000,8 +1011,8 @@ make_hashjoin(List *tlist,
HashJoin *node = makeNode(HashJoin);
Plan *plan = &node->join;
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->cost = 0.0;
plan->state = (EState *) NULL;
plan->targetlist = tlist;
@@ -1023,7 +1034,7 @@ make_hash(List *tlist, Var *hashkey, Plan *lefttree)
Hash *node = makeNode(Hash);
Plan *plan = &node->plan;
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = 0.0;
plan->state = (EState *) NULL;
plan->targetlist = tlist;
@@ -1051,8 +1062,8 @@ make_mergesort(List *tlist,
MergeJoin *node = makeNode(MergeJoin);
Plan *plan = &node->join;
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0) +
(righttree ? righttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = tlist;
plan->qual = qpqual;
@@ -1066,13 +1077,13 @@ make_mergesort(List *tlist,
return (node);
}
Sort *
Sort *
make_sort(List *tlist, Oid tempid, Plan *lefttree, int keycount)
{
Sort *node = makeNode(Sort);
Plan *plan = &node->plan;
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = tlist;
plan->qual = NIL;
@@ -1093,7 +1104,7 @@ make_material(List *tlist,
Material *node = makeNode(Material);
Plan *plan = &node->plan;
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = tlist;
plan->qual = NIL;
@@ -1105,12 +1116,12 @@ make_material(List *tlist,
return (node);
}
Agg *
Agg *
make_agg(List *tlist, Plan *lefttree)
{
Agg *node = makeNode(Agg);
node->plan.cost = (lefttree ? lefttree->cost : 0);
node->plan.cost = (lefttree ? lefttree->cost : 0);
node->plan.state = (EState *) NULL;
node->plan.qual = NULL;
node->plan.targetlist = tlist;
@@ -1121,7 +1132,7 @@ make_agg(List *tlist, Plan *lefttree)
return (node);
}
Group *
Group *
make_group(List *tlist,
bool tuplePerGroup,
int ngrp,
@@ -1130,7 +1141,7 @@ make_group(List *tlist,
{
Group *node = makeNode(Group);
node->plan.cost = (lefttree ? lefttree->plan.cost : 0);
node->plan.cost = (lefttree ? lefttree->plan.cost : 0);
node->plan.state = (EState *) NULL;
node->plan.qual = NULL;
node->plan.targetlist = tlist;
@@ -1151,13 +1162,13 @@ make_group(List *tlist,
* or "*"
*/
Unique *
Unique *
make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
{
Unique *node = makeNode(Unique);
Plan *plan = &node->plan;
plan->cost = (lefttree ? lefttree->cost : 0);
plan->cost = (lefttree ? lefttree->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = tlist;
plan->qual = NIL;
@@ -1175,7 +1186,7 @@ make_unique(List *tlist, Plan *lefttree, char *uniqueAttr)
}
#ifdef NOT_USED
List *
List *
generate_fjoin(List *tlist)
{
List tlistP;
@@ -1228,5 +1239,5 @@ generate_fjoin(List *tlist)
return newTlist;
return tlist; /* do nothing for now - ay 10/94 */
}
#endif
#endif

48
src/backend/optimizer/plan/planmain.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.19 1998/02/13 03:36:57 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.20 1998/02/26 04:32:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -64,7 +64,7 @@ make_groupPlan(List **tlist, bool tuplePerGroup,
*
* Returns a query plan.
*/
Plan *
Plan *
query_planner(Query *root,
int command_type,
List *tlist,
@@ -74,18 +74,18 @@ query_planner(Query *root,
List *var_only_tlist = NIL;
List *level_tlist = NIL;
Plan *subplan = NULL;
if ( PlannerQueryLevel > 1 )
if (PlannerQueryLevel > 1)
{
/* should copy be made ? */
tlist = (List *) SS_replace_correlation_vars ((Node*)tlist);
qual = (List *) SS_replace_correlation_vars ((Node*)qual);
tlist = (List *) SS_replace_correlation_vars((Node *) tlist);
qual = (List *) SS_replace_correlation_vars((Node *) qual);
}
if (root->hasSubLinks)
qual = (List *) SS_process_sublinks ((Node*) qual);
qual = (List *) SS_process_sublinks((Node *) qual);
qual = cnfify((Expr *) qual, true);
/*
* A command without a target list or qualification is an error,
* except for "delete foo".
@@ -158,7 +158,7 @@ query_planner(Query *root,
if (constant_qual != NULL)
{
return ((Plan *) make_result(tlist,
(Node *) constant_qual,
(Node *) constant_qual,
(Plan *) scan));
}
else
@@ -187,10 +187,10 @@ query_planner(Query *root,
*/
if (constant_qual)
{
subplan = (Plan *)make_result((!root->hasAggs && !root->groupClause)
? tlist : subplan->targetlist,
(Node *) constant_qual,
subplan);
subplan = (Plan *) make_result((!root->hasAggs && !root->groupClause)
? tlist : subplan->targetlist,
(Node *) constant_qual,
subplan);
/*
* Change all varno's of the Result's node target list.
@@ -200,6 +200,7 @@ query_planner(Query *root,
return subplan;
}
/*
* fix up the flattened target list of the plan root node so that
* expressions are evaluated. this forces expression evaluations that
@@ -213,15 +214,16 @@ query_planner(Query *root,
* aggregates fixing only other entries (i.e. - GroupBy-ed and so
* fixed by make_groupPlan). - vadim 04/05/97
*/
else
{
else
{
if (!root->hasAggs && !root->groupClause)
subplan->targetlist = flatten_tlist_vars(tlist,
subplan->targetlist);
subplan->targetlist);
return subplan;
}
}
#ifdef NOT_USED
/*
* Destructively modify the query plan's targetlist to add fjoin lists
* to flatten functions that return sets of base types
@@ -330,7 +332,7 @@ make_result(List *tlist,
#ifdef NOT_USED
tlist = generate_fjoin(tlist);
#endif
plan->cost = (subplan ? subplan->cost : 0);
plan->cost = (subplan ? subplan->cost : 0);
plan->state = (EState *) NULL;
plan->targetlist = tlist;
plan->lefttree = subplan;
@@ -379,9 +381,9 @@ make_groupPlan(List **tlist,
*/
foreach(sl, sort_tlist)
{
Resdom *resdom = NULL;
TargetEntry *te = (TargetEntry *) lfirst(sl);
int keyno = 0;
Resdom *resdom = NULL;
TargetEntry *te = (TargetEntry *) lfirst(sl);
int keyno = 0;
foreach(gl, groupClause)
{

67
src/backend/optimizer/plan/planner.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.22 1998/02/13 03:36:59 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.23 1998/02/26 04:32:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -49,7 +49,8 @@
#include "executor/executor.h"
static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
extern Plan *make_groupPlan(List **tlist, bool tuplePerGroup,
extern Plan *
make_groupPlan(List **tlist, bool tuplePerGroup,
List *groupClause, Plan *subplan);
/*****************************************************************************
@@ -58,27 +59,27 @@ extern Plan *make_groupPlan(List **tlist, bool tuplePerGroup,
*
*****************************************************************************/
Plan*
Plan *
planner(Query *parse)
{
Plan *result_plan;
PlannerQueryLevel = 1;
PlannerVarParam = NULL;
PlannerParamVar = NULL;
PlannerInitPlan = NULL;
PlannerPlanId = 0;
result_plan = union_planner (parse);
Assert (PlannerQueryLevel == 1);
if ( PlannerPlanId > 0 )
result_plan = union_planner(parse);
Assert(PlannerQueryLevel == 1);
if (PlannerPlanId > 0)
{
result_plan->initPlan = PlannerInitPlan;
(void) SS_finalize_plan (result_plan);
(void) SS_finalize_plan(result_plan);
}
result_plan->nParamExec = length (PlannerParamVar);
result_plan->nParamExec = length(PlannerParamVar);
return (result_plan);
}
@@ -91,7 +92,7 @@ planner(Query *parse)
* Returns a query plan.
*
*/
Plan *
Plan *
union_planner(Query *parse)
{
List *tlist = parse->targetList;
@@ -100,7 +101,7 @@ union_planner(Query *parse)
Plan *result_plan = (Plan *) NULL;
Index rt_index;
if (parse->unionClause)
{
@@ -112,7 +113,7 @@ union_planner(Query *parse)
parse->rtable);
}
else if ((rt_index =
first_inherit_rt_entry(rangetable)) != -1)
first_inherit_rt_entry(rangetable)) != -1)
{
result_plan = (Plan *) plan_inherit_queries(parse, rt_index);
/* XXX do we need to do this? bjm 12/19/97 */
@@ -123,27 +124,27 @@ union_planner(Query *parse)
}
else
{
List **vpm = NULL;
List **vpm = NULL;
tlist = preprocess_targetlist(tlist,
parse->commandType,
parse->resultRelation,
parse->rtable);
if ( parse->rtable != NULL )
if (parse->rtable != NULL)
{
vpm = (List **) palloc (length (parse->rtable) * sizeof (List*));
memset (vpm, 0, length (parse->rtable) * sizeof (List*));
vpm = (List **) palloc(length(parse->rtable) * sizeof(List *));
memset(vpm, 0, length(parse->rtable) * sizeof(List *));
}
PlannerVarParam = lcons (vpm, PlannerVarParam);
PlannerVarParam = lcons(vpm, PlannerVarParam);
result_plan = query_planner(parse,
parse->commandType,
tlist,
(List*) parse->qual);
PlannerVarParam = lnext (PlannerVarParam);
if ( vpm != NULL )
pfree (vpm);
(List *) parse->qual);
PlannerVarParam = lnext(PlannerVarParam);
if (vpm != NULL)
pfree(vpm);
}
/*
* If we have a GROUP BY clause, insert a group node (with the
* appropriate sort node.)
@@ -161,10 +162,10 @@ union_planner(Query *parse)
tuplePerGroup = parse->hasAggs;
result_plan =
make_groupPlan( &tlist,
tuplePerGroup,
parse->groupClause,
result_plan);
make_groupPlan(&tlist,
tuplePerGroup,
parse->groupClause,
result_plan);
}
@@ -173,14 +174,14 @@ union_planner(Query *parse)
*/
if (parse->hasAggs)
{
result_plan = (Plan *)make_agg(tlist, result_plan);
result_plan = (Plan *) make_agg(tlist, result_plan);
/*
* set the varno/attno entries to the appropriate references to
* the result tuple of the subplans.
*/
((Agg *)result_plan)->aggs =
set_agg_tlist_references((Agg *)result_plan);
((Agg *) result_plan)->aggs =
set_agg_tlist_references((Agg *) result_plan);
}
/*

74
src/backend/optimizer/plan/setrefs.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.18 1998/02/13 03:37:02 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.19 1998/02/26 04:32:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -36,9 +36,11 @@
static void set_join_tlist_references(Join *join);
static void set_tempscan_tlist_references(SeqScan *tempscan);
static void set_temp_tlist_references(Temp *temp);
static List *replace_clause_joinvar_refs(Expr *clause,
static List *
replace_clause_joinvar_refs(Expr *clause,
List *outer_tlist, List *inner_tlist);
static List *replace_subclause_joinvar_refs(List *clauses,
static List *
replace_subclause_joinvar_refs(List *clauses,
List *outer_tlist, List *inner_tlist);
static Var *replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist);
static List *tlist_temp_references(Oid tempid, List *tlist);
@@ -216,7 +218,7 @@ set_temp_tlist_references(Temp *temp)
* Returns the new join clauses.
*
*/
List *
List *
join_references(List *clauses,
List *outer_tlist,
List *inner_tlist)
@@ -242,7 +244,7 @@ join_references(List *clauses,
* Returns the new list of clauses.
*
*/
List *
List *
index_outerjoin_references(List *inner_indxqual,
List *outer_tlist,
Index inner_relid)
@@ -407,19 +409,19 @@ replace_clause_joinvar_refs(Expr *clause,
}
else if (is_subplan(clause))
{
((Expr*) clause)->args =
replace_subclause_joinvar_refs(((Expr*) clause)->args,
outer_tlist,
inner_tlist);
((SubPlan*) ((Expr*) clause)->oper)->sublink->oper =
replace_subclause_joinvar_refs(((SubPlan*) ((Expr*) clause)->oper)->sublink->oper,
outer_tlist,
inner_tlist);
return ((List*) clause);
((Expr *) clause)->args =
replace_subclause_joinvar_refs(((Expr *) clause)->args,
outer_tlist,
inner_tlist);
((SubPlan *) ((Expr *) clause)->oper)->sublink->oper =
replace_subclause_joinvar_refs(((SubPlan *) ((Expr *) clause)->oper)->sublink->oper,
outer_tlist,
inner_tlist);
return ((List *) clause);
}
/* shouldn't reach here */
elog (ERROR, "replace_clause_joinvar_refs: unsupported clause %d",
nodeTag (clause));
elog(ERROR, "replace_clause_joinvar_refs: unsupported clause %d",
nodeTag(clause));
return NULL;
}
@@ -612,7 +614,7 @@ replace_result_clause(Node *clause,
}
else if (is_funcclause(clause))
{
List *subExpr;
List *subExpr;
/*
* This is a function. Recursively call this routine for its
@@ -627,7 +629,7 @@ replace_result_clause(Node *clause,
else if (IsA(clause, ArrayRef))
{
ArrayRef *aref = (ArrayRef *) clause;
/*
* This is an arrayref. Recursively call this routine for its
* expression and its index expression...
@@ -647,18 +649,18 @@ replace_result_clause(Node *clause,
}
else if (is_opclause(clause))
{
Node *subNode;
Node *subNode;
/*
* This is an operator. Recursively call this routine for both its
* left and right operands
*/
subNode = (Node *)get_leftop((Expr *) clause);
subNode = (Node *) get_leftop((Expr *) clause);
replace_result_clause(subNode, subplanTargetList);
subNode = (Node *) get_rightop((Expr *) clause);
replace_result_clause(subNode, subplanTargetList);
}
else if (IsA(clause, Param) || IsA(clause, Const))
else if (IsA(clause, Param) ||IsA(clause, Const))
{
/* do nothing! */
}
@@ -730,7 +732,7 @@ set_agg_tlist_references(Agg *aggNode)
TargetEntry *tle = lfirst(tl);
aggreg_list = nconc(
replace_agg_clause(tle->expr, subplanTargetList),aggreg_list);
replace_agg_clause(tle->expr, subplanTargetList), aggreg_list);
}
return aggreg_list;
}
@@ -739,7 +741,7 @@ static List *
replace_agg_clause(Node *clause, List *subplanTargetList)
{
List *t;
List *agg_list = NIL;
List *agg_list = NIL;
if (IsA(clause, Var))
{
@@ -760,6 +762,7 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
}
else if (is_funcclause(clause))
{
/*
* This is a function. Recursively call this routine for its
* arguments...
@@ -767,19 +770,19 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
foreach(t, ((Expr *) clause)->args)
{
agg_list = nconc(agg_list,
replace_agg_clause(lfirst(t), subplanTargetList));
replace_agg_clause(lfirst(t), subplanTargetList));
}
return agg_list;
}
else if (IsA(clause, Aggreg))
{
return lcons(clause,
replace_agg_clause(((Aggreg *) clause)->target, subplanTargetList));
replace_agg_clause(((Aggreg *) clause)->target, subplanTargetList));
}
else if (IsA(clause, ArrayRef))
{
ArrayRef *aref = (ArrayRef *) clause;
/*
* This is an arrayref. Recursively call this routine for its
* expression and its index expression...
@@ -787,35 +790,36 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
foreach(t, aref->refupperindexpr)
{
agg_list = nconc(agg_list,
replace_agg_clause(lfirst(t), subplanTargetList));
replace_agg_clause(lfirst(t), subplanTargetList));
}
foreach(t, aref->reflowerindexpr)
{
agg_list = nconc(agg_list,
replace_agg_clause(lfirst(t), subplanTargetList));
replace_agg_clause(lfirst(t), subplanTargetList));
}
agg_list = nconc(agg_list,
replace_agg_clause(aref->refexpr, subplanTargetList));
replace_agg_clause(aref->refexpr, subplanTargetList));
agg_list = nconc(agg_list,
replace_agg_clause(aref->refassgnexpr, subplanTargetList));
replace_agg_clause(aref->refassgnexpr, subplanTargetList));
return agg_list;
}
else if (is_opclause(clause))
{
/*
* This is an operator. Recursively call this routine for both its
* left and right operands
*/
Node *left = (Node *) get_leftop((Expr *) clause);
Node *right = (Node *) get_rightop((Expr *) clause);
if (left != (Node *) NULL)
agg_list = nconc(agg_list,
replace_agg_clause(left, subplanTargetList));
replace_agg_clause(left, subplanTargetList));
if (right != (Node *) NULL)
agg_list = nconc(agg_list,
replace_agg_clause(right, subplanTargetList));
replace_agg_clause(right, subplanTargetList));
return agg_list;
}
@@ -840,7 +844,8 @@ replace_agg_clause(Node *clause, List *subplanTargetList)
* Remove the Agg nodes from the target list
* We do this so inheritance only does aggregates in the upper node
*/
void del_agg_tlist_references(List *tlist)
void
del_agg_tlist_references(List *tlist)
{
List *tl;
@@ -863,6 +868,7 @@ del_agg_clause(Node *clause)
}
else if (is_funcclause(clause))
{
/*
* This is a function. Recursively call this routine for its
* arguments...

619
src/backend/optimizer/plan/subselect.c
View File

@@ -26,61 +26,61 @@
#include "optimizer/var.h"
#include "optimizer/cost.h"
int PlannerQueryLevel; /* level of current query */
List *PlannerVarParam; /* correlation Vars to Param mapper */
List *PlannerParamVar; /* to get Var from Param->paramid */
List *PlannerInitPlan; /* init subplans for current query */
int PlannerPlanId;
int PlannerQueryLevel; /* level of current query */
List *PlannerVarParam; /* correlation Vars to Param mapper */
List *PlannerParamVar; /* to get Var from Param->paramid */
List *PlannerInitPlan; /* init subplans for current query */
int PlannerPlanId;
static int
_new_param (Var *var, int varlevel)
_new_param(Var *var, int varlevel)
{
List *last;
int i = 0;
if ( PlannerParamVar == NULL )
List *last;
int i = 0;
if (PlannerParamVar == NULL)
last = PlannerParamVar = makeNode(List);
else
{
for (last = PlannerParamVar; ; )
for (last = PlannerParamVar;;)
{
i++;
if ( lnext(last) == NULL )
if (lnext(last) == NULL)
break;
last = lnext(last);
}
lnext(last) = makeNode(List);
last = lnext(last);
}
lnext(last) = NULL;
lfirst(last) = makeVar (var->varno, var->varattno, var->vartype,
var->vartypmod, varlevel, var->varnoold, var->varoattno);
lfirst(last) = makeVar(var->varno, var->varattno, var->vartype,
var->vartypmod, varlevel, var->varnoold, var->varoattno);
return (i);
}
static Param*
_replace_var (Var *var)
static Param *
_replace_var(Var *var)
{
List **rt = (List**) nth (var->varlevelsup, PlannerVarParam);
List *vpe = rt[var->varno - 1];
Param *retval;
int i;
if ( vpe == NULL )
List **rt = (List **) nth(var->varlevelsup, PlannerVarParam);
List *vpe = rt[var->varno - 1];
Param *retval;
int i;
if (vpe == NULL)
{
vpe = rt[var->varno - 1] = makeNode(List);
lfirsti(vpe) = -1;
lnext(vpe) = NULL;
}
for (i = 1; ; i++)
for (i = 1;; i++)
{
if ( i == var->varattno )
if (i == var->varattno)
break;
if ( lnext(vpe) == NULL )
if (lnext(vpe) == NULL)
{
lnext(vpe) = makeNode(List);
vpe = lnext(vpe);
@@ -90,381 +90,385 @@ _replace_var (Var *var)
else
vpe = lnext(vpe);
}
if ( (i = lfirsti(vpe)) < 0 ) /* parameter is not assigned */
if ((i = lfirsti(vpe)) < 0) /* parameter is not assigned */
{
i = _new_param (var, PlannerQueryLevel - var->varlevelsup);
i = _new_param(var, PlannerQueryLevel - var->varlevelsup);
}
retval = makeNode(Param);
retval->paramkind = PARAM_EXEC;
retval->paramid = (AttrNumber) i;
retval->paramtype = var->vartype;
return (retval);
}
static Node*
_make_subplan (SubLink *slink)
static Node *
_make_subplan(SubLink *slink)
{
SubPlan *node = makeNode (SubPlan);
SubPlan *node = makeNode(SubPlan);
Plan *plan;
List *lst;
Node *result;
List *saved_ip = PlannerInitPlan;
PlannerInitPlan = NULL;
PlannerQueryLevel++; /* we becomes child */
node->plan = plan = union_planner ((Query*) slink->subselect);
/*
* Assign subPlan, extParam and locParam to plan nodes.
* At the moment, SS_finalize_plan doesn't handle initPlan-s
* and so we assigne them to the topmost plan node and take
* care about its extParam too.
node->plan = plan = union_planner((Query *) slink->subselect);
/*
* Assign subPlan, extParam and locParam to plan nodes. At the moment,
* SS_finalize_plan doesn't handle initPlan-s and so we assigne them
* to the topmost plan node and take care about its extParam too.
*/
(void) SS_finalize_plan (plan);
(void) SS_finalize_plan(plan);
plan->initPlan = PlannerInitPlan;
/* Get extParam from InitPlan-s */
foreach (lst, PlannerInitPlan)
foreach(lst, PlannerInitPlan)
{
List *lp;
foreach (lp, ((SubPlan*) lfirst (lst))->plan->extParam)
List *lp;
foreach(lp, ((SubPlan *) lfirst(lst))->plan->extParam)
{
if ( !intMember (lfirsti(lp), plan->extParam) )
plan->extParam = lappendi (plan->extParam, lfirsti(lp));
if (!intMember(lfirsti(lp), plan->extParam))
plan->extParam = lappendi(plan->extParam, lfirsti(lp));
}
}
/* and now we are parent again */
PlannerInitPlan = saved_ip;
PlannerQueryLevel--;
node->plan_id = PlannerPlanId++;
node->rtable = ((Query*) slink->subselect)->rtable;
node->rtable = ((Query *) slink->subselect)->rtable;
node->sublink = slink;
slink->subselect = NULL; /* cool ?! */
/* make parParam list */
foreach (lst, plan->extParam)
foreach(lst, plan->extParam)
{
Var *var = nth (lfirsti(lst), PlannerParamVar);
if ( var->varlevelsup == PlannerQueryLevel )
node->parParam = lappendi (node->parParam, lfirsti(lst));
Var *var = nth(lfirsti(lst), PlannerParamVar);
if (var->varlevelsup == PlannerQueryLevel)
node->parParam = lappendi(node->parParam, lfirsti(lst));
}
/*
* Un-correlated or undirect correlated plans of EXISTS or EXPR
* types can be used as initPlans...
/*
* Un-correlated or undirect correlated plans of EXISTS or EXPR types
* can be used as initPlans...
*/
if ( node->parParam == NULL && slink->subLinkType == EXPR_SUBLINK )
if (node->parParam == NULL && slink->subLinkType == EXPR_SUBLINK)
{
int i = 0;
int i = 0;
/* transform right side of all sublink Oper-s into Param */
foreach (lst, slink->oper)
foreach(lst, slink->oper)
{
List *rside = lnext(((Expr*) lfirst(lst))->args);
TargetEntry *te = nth (i, plan->targetlist);
Var *var = makeVar (0, 0, te->resdom->restype,
te->resdom->restypmod,
PlannerQueryLevel, 0, 0);
Param *prm = makeNode(Param);
List *rside = lnext(((Expr *) lfirst(lst))->args);
TargetEntry *te = nth(i, plan->targetlist);
Var *var = makeVar(0, 0, te->resdom->restype,
te->resdom->restypmod,
PlannerQueryLevel, 0, 0);
Param *prm = makeNode(Param);
prm->paramkind = PARAM_EXEC;
prm->paramid = (AttrNumber) _new_param (var, PlannerQueryLevel);
prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
prm->paramtype = var->vartype;
lfirst(rside) = prm;
node->setParam = lappendi (node->setParam, prm->paramid);
pfree (var);
node->setParam = lappendi(node->setParam, prm->paramid);
pfree(var);
i++;
}
PlannerInitPlan = lappend (PlannerInitPlan, node);
if ( i > 1 )
result = (Node*) ((slink->useor) ? make_orclause (slink->oper) :
make_andclause (slink->oper));
PlannerInitPlan = lappend(PlannerInitPlan, node);
if (i > 1)
result = (Node *) ((slink->useor) ? make_orclause(slink->oper) :
make_andclause(slink->oper));
else
result = (Node*) lfirst (slink->oper);
result = (Node *) lfirst(slink->oper);
}
else if ( node->parParam == NULL && slink->subLinkType == EXISTS_SUBLINK )
else if (node->parParam == NULL && slink->subLinkType == EXISTS_SUBLINK)
{
Var *var = makeVar (0, 0, BOOLOID, -1, PlannerQueryLevel, 0, 0);
Var *var = makeVar(0, 0, BOOLOID, -1, PlannerQueryLevel, 0, 0);
Param *prm = makeNode(Param);
prm->paramkind = PARAM_EXEC;
prm->paramid = (AttrNumber) _new_param (var, PlannerQueryLevel);
prm->paramid = (AttrNumber) _new_param(var, PlannerQueryLevel);
prm->paramtype = var->vartype;
node->setParam = lappendi (node->setParam, prm->paramid);
pfree (var);
PlannerInitPlan = lappend (PlannerInitPlan, node);
result = (Node*) prm;
node->setParam = lappendi(node->setParam, prm->paramid);
pfree(var);
PlannerInitPlan = lappend(PlannerInitPlan, node);
result = (Node *) prm;
}
else /* make expression of SUBPLAN type */
else
/* make expression of SUBPLAN type */
{
Expr *expr = makeNode (Expr);
List *args = NULL;
int i = 0;
Expr *expr = makeNode(Expr);
List *args = NULL;
int i = 0;
expr->typeOid = BOOLOID;
expr->opType = SUBPLAN_EXPR;
expr->oper = (Node*) node;
/*
* Make expr->args from parParam. Left sides of sublink Oper-s
* are handled by optimizer directly...
* Also, transform right side of sublink Oper-s into Const.
expr->oper = (Node *) node;
/*
* Make expr->args from parParam. Left sides of sublink Oper-s are
* handled by optimizer directly... Also, transform right side of
* sublink Oper-s into Const.
*/
foreach (lst, node->parParam)
foreach(lst, node->parParam)
{
Var *var = nth (lfirsti (lst), PlannerParamVar);
var = (Var*) copyObject (var);
Var *var = nth(lfirsti(lst), PlannerParamVar);
var = (Var *) copyObject(var);
var->varlevelsup = 0;
args = lappend (args, var);
args = lappend(args, var);
}
foreach (lst, slink->oper)
foreach(lst, slink->oper)
{
List *rside = lnext(((Expr*) lfirst(lst))->args);
TargetEntry *te = nth (i, plan->targetlist);
Const *con = makeConst (te->resdom->restype,
0, 0, true, 0, 0, 0);
List *rside = lnext(((Expr *) lfirst(lst))->args);
TargetEntry *te = nth(i, plan->targetlist);
Const *con = makeConst(te->resdom->restype,
0, 0, true, 0, 0, 0);
lfirst(rside) = con;
i++;
}
expr->args = args;
result = (Node*) expr;
result = (Node *) expr;
}
return (result);
}
static List *
set_unioni (List *l1, List *l2)
set_unioni(List *l1, List *l2)
{
if (l1 == NULL)
return (l2);
if (l2 == NULL)
return (l1);
return (nconc (l1, set_differencei (l2, l1)));
return (nconc(l1, set_differencei(l2, l1)));
}
static List *
_finalize_primnode (void *expr, List **subplan)
_finalize_primnode(void *expr, List **subplan)
{
List *result = NULL;
if ( expr == NULL )
List *result = NULL;
if (expr == NULL)
return (NULL);
if (IsA (expr, Param))
if (IsA(expr, Param))
{
if ( ((Param*) expr)->paramkind == PARAM_EXEC )
return (lconsi (((Param*) expr)->paramid, (List*) NULL));
if (((Param *) expr)->paramkind == PARAM_EXEC)
return (lconsi(((Param *) expr)->paramid, (List *) NULL));
}
else if (single_node(expr))
return (NULL);
else if (IsA (expr, List))
else if (IsA(expr, List))
{
List *le;
foreach (le, (List*) expr)
result = set_unioni (result,
_finalize_primnode (lfirst(le), subplan));
List *le;
foreach(le, (List *) expr)
result = set_unioni(result,
_finalize_primnode(lfirst(le), subplan));
}
else if (IsA (expr, Iter))
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));
else if (IsA (expr, Aggreg))
return (_finalize_primnode (((Aggreg *) expr)->target, subplan));
else if (IsA (expr, ArrayRef))
else if (IsA(expr, Iter))
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));
else if (IsA(expr, Aggreg))
return (_finalize_primnode(((Aggreg *) expr)->target, subplan));
else if (IsA(expr, ArrayRef))
{
result = _finalize_primnode (((ArrayRef*) expr)->refupperindexpr, subplan);
result = set_unioni (result,
_finalize_primnode (((ArrayRef *) expr)->reflowerindexpr, subplan));
result = set_unioni (result,
_finalize_primnode (((ArrayRef *) expr)->refexpr, subplan));
result = set_unioni (result,
_finalize_primnode (((ArrayRef *) expr)->refassgnexpr, subplan));
result = _finalize_primnode(((ArrayRef *) expr)->refupperindexpr, subplan);
result = set_unioni(result,
_finalize_primnode(((ArrayRef *) expr)->reflowerindexpr, subplan));
result = set_unioni(result,
_finalize_primnode(((ArrayRef *) expr)->refexpr, subplan));
result = set_unioni(result,
_finalize_primnode(((ArrayRef *) expr)->refassgnexpr, subplan));
}
else if (IsA (expr, TargetEntry))
return (_finalize_primnode (((TargetEntry*) expr)->expr, subplan));
else if (is_subplan (expr))
else if (IsA(expr, TargetEntry))
return (_finalize_primnode(((TargetEntry *) expr)->expr, subplan));
else if (is_subplan(expr))
{
List *lst;
*subplan = lappend (*subplan, ((Expr*) expr)->oper);
foreach (lst, ((SubPlan*) ((Expr*) expr)->oper)->plan->extParam)
List *lst;
*subplan = lappend(*subplan, ((Expr *) expr)->oper);
foreach(lst, ((SubPlan *) ((Expr *) expr)->oper)->plan->extParam)
{
Var *var = nth (lfirsti(lst), PlannerParamVar);
if ( var->varlevelsup < PlannerQueryLevel &&
!intMember (lfirsti(lst), result) )
result = lappendi (result, lfirsti(lst));
Var *var = nth(lfirsti(lst), PlannerParamVar);
if (var->varlevelsup < PlannerQueryLevel &&
!intMember(lfirsti(lst), result))
result = lappendi(result, lfirsti(lst));
}
}
else
elog (ERROR, "_finalize_primnode: can't handle node %d",
nodeTag (expr));
elog(ERROR, "_finalize_primnode: can't handle node %d",
nodeTag(expr));
return (result);
}
Node *
SS_replace_correlation_vars (Node *expr)
SS_replace_correlation_vars(Node *expr)
{
if ( expr == NULL )
if (expr == NULL)
return (NULL);
if (IsA (expr, List))
if (IsA(expr, List))
{
List *le;
foreach (le, (List*) expr)
lfirst(le) = SS_replace_correlation_vars ((Node*) lfirst(le));
List *le;
foreach(le, (List *) expr)
lfirst(le) = SS_replace_correlation_vars((Node *) lfirst(le));
}
else if (IsA (expr, Var))
else if (IsA(expr, Var))
{
if ( ((Var*) expr)->varlevelsup > 0 )
if (((Var *) expr)->varlevelsup > 0)
{
Assert (((Var*) expr)->varlevelsup < PlannerQueryLevel);
expr = (Node*) _replace_var ((Var*) expr);
Assert(((Var *) expr)->varlevelsup < PlannerQueryLevel);
expr = (Node *) _replace_var((Var *) expr);
}
}
else if (IsA (expr, Iter))
else if (IsA(expr, Iter))
{
((Iter*) expr)->iterexpr =
SS_replace_correlation_vars(((Iter*) expr)->iterexpr);
((Iter *) expr)->iterexpr =
SS_replace_correlation_vars(((Iter *) expr)->iterexpr);
}
else if (single_node(expr))
return (expr);
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
not_clause (expr) || is_funcclause(expr))
((Expr *) expr)->args = (List*)
SS_replace_correlation_vars ((Node*) ((Expr *) expr)->args);
else if (IsA (expr, Aggreg))
((Aggreg *) expr)->target =
SS_replace_correlation_vars ((Node*) ((Aggreg *) expr)->target);
else if (IsA (expr, ArrayRef))
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
not_clause(expr) || is_funcclause(expr))
((Expr *) expr)->args = (List *)
SS_replace_correlation_vars((Node *) ((Expr *) expr)->args);
else if (IsA(expr, Aggreg))
((Aggreg *) expr)->target =
SS_replace_correlation_vars((Node *) ((Aggreg *) expr)->target);
else if (IsA(expr, ArrayRef))
{
((ArrayRef *) expr)->refupperindexpr = (List*)
SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->refupperindexpr);
((ArrayRef *) expr)->reflowerindexpr = (List*)
SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->reflowerindexpr);
((ArrayRef *) expr)->refexpr =
SS_replace_correlation_vars ((Node*) ((ArrayRef *) expr)->refexpr);
((ArrayRef *) expr)->refassgnexpr =
SS_replace_correlation_vars (((ArrayRef *) expr)->refassgnexpr);
((ArrayRef *) expr)->refupperindexpr = (List *)
SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->refupperindexpr);
((ArrayRef *) expr)->reflowerindexpr = (List *)
SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->reflowerindexpr);
((ArrayRef *) expr)->refexpr =
SS_replace_correlation_vars((Node *) ((ArrayRef *) expr)->refexpr);
((ArrayRef *) expr)->refassgnexpr =
SS_replace_correlation_vars(((ArrayRef *) expr)->refassgnexpr);
}
else if (IsA (expr, TargetEntry))
((TargetEntry*) expr)->expr =
SS_replace_correlation_vars ((Node*) ((TargetEntry*) expr)->expr);
else if (IsA (expr, SubLink))
else if (IsA(expr, TargetEntry))
((TargetEntry *) expr)->expr =
SS_replace_correlation_vars((Node *) ((TargetEntry *) expr)->expr);
else if (IsA(expr, SubLink))
{
List *le;
foreach (le, ((SubLink*) expr)->oper) /* left sides only */
List *le;
foreach(le, ((SubLink *) expr)->oper) /* left sides only */
{
List *oparg = ((Expr*) lfirst (le))->args;
lfirst (oparg) = (List*)
SS_replace_correlation_vars ((Node*) lfirst (oparg));
List *oparg = ((Expr *) lfirst(le))->args;
lfirst(oparg) = (List *)
SS_replace_correlation_vars((Node *) lfirst(oparg));
}
((SubLink*) expr)->lefthand = (List*)
SS_replace_correlation_vars ((Node*) ((SubLink*) expr)->lefthand);
((SubLink *) expr)->lefthand = (List *)
SS_replace_correlation_vars((Node *) ((SubLink *) expr)->lefthand);
}
else
elog (NOTICE, "SS_replace_correlation_vars: can't handle node %d",
nodeTag (expr));
elog(NOTICE, "SS_replace_correlation_vars: can't handle node %d",
nodeTag(expr));
return (expr);
}
Node*
SS_process_sublinks (Node *expr)
Node *
SS_process_sublinks(Node *expr)
{
if ( expr == NULL )
if (expr == NULL)
return (NULL);
if (IsA (expr, List))
if (IsA(expr, List))
{
List *le;
foreach (le, (List*) expr)
lfirst(le) = SS_process_sublinks ((Node*) lfirst(le));
List *le;
foreach(le, (List *) expr)
lfirst(le) = SS_process_sublinks((Node *) lfirst(le));
}
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
not_clause (expr) || is_funcclause(expr))
((Expr *) expr)->args = (List*)
SS_process_sublinks ((Node*) ((Expr *) expr)->args);
else if (IsA (expr, SubLink)) /* got it! */
expr = _make_subplan ((SubLink*) expr);
else if (or_clause(expr) || and_clause(expr) || is_opclause(expr) ||
not_clause(expr) || is_funcclause(expr))
((Expr *) expr)->args = (List *)
SS_process_sublinks((Node *) ((Expr *) expr)->args);
else if (IsA(expr, SubLink))/* got it! */
expr = _make_subplan((SubLink *) expr);
return (expr);
}
List*
SS_finalize_plan (Plan *plan)
List *
SS_finalize_plan(Plan *plan)
{
List *extParam = NULL;
List *locParam = NULL;
List *subPlan = NULL;
List *param_list;
List *lst;
if ( plan == NULL )
List *extParam = NULL;
List *locParam = NULL;
List *subPlan = NULL;
List *param_list;
List *lst;
if (plan == NULL)
return (NULL);
param_list = _finalize_primnode (plan->targetlist, &subPlan);
Assert (subPlan == NULL);
param_list = _finalize_primnode(plan->targetlist, &subPlan);
Assert(subPlan == NULL);
switch (nodeTag(plan))
{
case T_Result:
param_list = set_unioni (param_list,
_finalize_primnode (((Result*) plan)->resconstantqual, &subPlan));
param_list = set_unioni(param_list,
_finalize_primnode(((Result *) plan)->resconstantqual, &subPlan));
break;
case T_Append:
foreach (lst, ((Append*) plan)->unionplans)
param_list = set_unioni (param_list,
SS_finalize_plan ((Plan*) lfirst (lst)));
foreach(lst, ((Append *) plan)->unionplans)
param_list = set_unioni(param_list,
SS_finalize_plan((Plan *) lfirst(lst)));
break;
case T_IndexScan:
param_list = set_unioni (param_list,
_finalize_primnode (((IndexScan*) plan)->indxqual, &subPlan));
Assert (subPlan == NULL);
param_list = set_unioni(param_list,
_finalize_primnode(((IndexScan *) plan)->indxqual, &subPlan));
Assert(subPlan == NULL);
break;
case T_MergeJoin:
param_list = set_unioni (param_list,
_finalize_primnode (((MergeJoin*) plan)->mergeclauses, &subPlan));
Assert (subPlan == NULL);
param_list = set_unioni(param_list,
_finalize_primnode(((MergeJoin *) plan)->mergeclauses, &subPlan));
Assert(subPlan == NULL);
break;
case T_HashJoin:
param_list = set_unioni (param_list,
_finalize_primnode (((HashJoin*) plan)->hashclauses, &subPlan));
Assert (subPlan == NULL);
param_list = set_unioni(param_list,
_finalize_primnode(((HashJoin *) plan)->hashclauses, &subPlan));
Assert(subPlan == NULL);
break;
case T_Hash:
param_list = set_unioni (param_list,
_finalize_primnode (((Hash*) plan)->hashkey, &subPlan));
Assert (subPlan == NULL);
param_list = set_unioni(param_list,
_finalize_primnode(((Hash *) plan)->hashkey, &subPlan));
Assert(subPlan == NULL);
break;
case T_Agg:
param_list = set_unioni (param_list,
_finalize_primnode (((Agg*) plan)->aggs, &subPlan));
Assert (subPlan == NULL);
param_list = set_unioni(param_list,
_finalize_primnode(((Agg *) plan)->aggs, &subPlan));
Assert(subPlan == NULL);
break;
case T_SeqScan:
case T_NestLoop:
case T_Material:
@@ -476,74 +480,75 @@ SS_finalize_plan (Plan *plan)
elog(ERROR, "SS_finalize_plan: node %d unsupported", nodeTag(plan));
return (NULL);
}
param_list = set_unioni (param_list, _finalize_primnode (plan->qual, &subPlan));
param_list = set_unioni (param_list, SS_finalize_plan (plan->lefttree));
param_list = set_unioni (param_list, SS_finalize_plan (plan->righttree));
foreach (lst, param_list)
param_list = set_unioni(param_list, _finalize_primnode(plan->qual, &subPlan));
param_list = set_unioni(param_list, SS_finalize_plan(plan->lefttree));
param_list = set_unioni(param_list, SS_finalize_plan(plan->righttree));
foreach(lst, param_list)
{
Var *var = nth (lfirsti(lst), PlannerParamVar);
if ( var->varlevelsup < PlannerQueryLevel )
extParam = lappendi (extParam, lfirsti(lst));
else if ( var->varlevelsup > PlannerQueryLevel )
elog (ERROR, "SS_finalize_plan: plan shouldn't reference subplan' variable");
Var *var = nth(lfirsti(lst), PlannerParamVar);
if (var->varlevelsup < PlannerQueryLevel)
extParam = lappendi(extParam, lfirsti(lst));
else if (var->varlevelsup > PlannerQueryLevel)
elog(ERROR, "SS_finalize_plan: plan shouldn't reference subplan' variable");
else
{
Assert (var->varno == 0 && var->varattno == 0);
locParam = lappendi (locParam, lfirsti(lst));
Assert(var->varno == 0 && var->varattno == 0);
locParam = lappendi(locParam, lfirsti(lst));
}
}
plan->extParam = extParam;
plan->locParam = locParam;
plan->subPlan = subPlan;
return (param_list);
}
List *SS_pull_subplan (void *expr);
List *SS_pull_subplan(void *expr);
List *
SS_pull_subplan (void *expr)
SS_pull_subplan(void *expr)
{
List *result = NULL;
if ( expr == NULL || single_node(expr) )
List *result = NULL;
if (expr == NULL || single_node(expr))
return (NULL);
if (IsA (expr, List))
if (IsA(expr, List))
{
List *le;
foreach (le, (List*) expr)
result = nconc (result, SS_pull_subplan (lfirst(le)));
List *le;
foreach(le, (List *) expr)
result = nconc(result, SS_pull_subplan(lfirst(le)));
}
else if (IsA (expr, Iter))
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));
else if (IsA (expr, Aggreg))
return (SS_pull_subplan (((Aggreg *) expr)->target));
else if (IsA (expr, ArrayRef))
else if (IsA(expr, Iter))
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));
else if (IsA(expr, Aggreg))
return (SS_pull_subplan(((Aggreg *) expr)->target));
else if (IsA(expr, ArrayRef))
{
result = SS_pull_subplan (((ArrayRef*) expr)->refupperindexpr);
result = nconc (result,
SS_pull_subplan (((ArrayRef *) expr)->reflowerindexpr));
result = nconc (result,
SS_pull_subplan (((ArrayRef *) expr)->refexpr));
result = nconc (result,
SS_pull_subplan (((ArrayRef *) expr)->refassgnexpr));
result = SS_pull_subplan(((ArrayRef *) expr)->refupperindexpr);
result = nconc(result,
SS_pull_subplan(((ArrayRef *) expr)->reflowerindexpr));
result = nconc(result,
SS_pull_subplan(((ArrayRef *) expr)->refexpr));
result = nconc(result,
SS_pull_subplan(((ArrayRef *) expr)->refassgnexpr));
}
else if (IsA (expr, TargetEntry))
return (SS_pull_subplan (((TargetEntry*) expr)->expr));
else if (is_subplan (expr))
return (lcons (((Expr*) expr)->oper, NULL));
else if (IsA(expr, TargetEntry))
return (SS_pull_subplan(((TargetEntry *) expr)->expr));
else if (is_subplan(expr))
return (lcons(((Expr *) expr)->oper, NULL));
else
elog (ERROR, "SS_pull_subplan: can't handle node %d",
nodeTag (expr));
elog(ERROR, "SS_pull_subplan: can't handle node %d",
nodeTag(expr));
return (result);
}