pgindent file.
This commit is contained in:
Bruce Momjian
parent
2ee522954d
commit
692a65e6ff
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.33 1999/01/25 18:02:18 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.34 1999/01/26 05:57:14 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -916,195 +916,195 @@ del_agg_clause(Node *clause)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/***S*H***/
|
||||
/***S*H***/
|
||||
/* check_having_qual_for_vars takes the the havingQual and the actual targetlist as arguments
|
||||
* and recursively scans the havingQual for attributes that are not included in the targetlist
|
||||
* yet. Attributes contained in the havingQual but not in the targetlist show up with queries
|
||||
* like:
|
||||
* SELECT sid
|
||||
* like:
|
||||
* SELECT sid
|
||||
* FROM part
|
||||
* GROUP BY sid
|
||||
* HAVING MIN(pid) > 1; (pid is used but never selected for!!!).
|
||||
* HAVING MIN(pid) > 1; (pid is used but never selected for!!!).
|
||||
* To be able to handle queries like that correctly we have to extend the actual targetlist
|
||||
* (which will be the one used for the GROUP node later on) by these attributes. */
|
||||
* (which will be the one used for the GROUP node later on) by these attributes. */
|
||||
List *
|
||||
check_having_qual_for_vars(Node *clause, List *targetlist_so_far)
|
||||
{
|
||||
List *t;
|
||||
List *t;
|
||||
|
||||
|
||||
if (IsA(clause, Var))
|
||||
{
|
||||
RelOptInfo tmp_rel;
|
||||
|
||||
if (IsA(clause, Var))
|
||||
{
|
||||
RelOptInfo tmp_rel;
|
||||
|
||||
tmp_rel.targetlist = targetlist_so_far;
|
||||
|
||||
/*
|
||||
* Ha! A Var node!
|
||||
*/
|
||||
|
||||
/* Check if the VAR is already contained in the targetlist */
|
||||
if (tlist_member((Var *)clause, (List *)targetlist_so_far) == NULL)
|
||||
{
|
||||
add_tl_element(&tmp_rel, (Var *)clause);
|
||||
}
|
||||
|
||||
return tmp_rel.targetlist;
|
||||
}
|
||||
|
||||
else if (is_funcclause(clause) || not_clause(clause) ||
|
||||
or_clause(clause) || and_clause(clause))
|
||||
{
|
||||
|
||||
/*
|
||||
* This is a function. Recursively call this routine for its
|
||||
* arguments...
|
||||
*/
|
||||
foreach(t, ((Expr *) clause)->args)
|
||||
{
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
tmp_rel.targetlist = targetlist_so_far;
|
||||
|
||||
/*
|
||||
* Ha! A Var node!
|
||||
*/
|
||||
|
||||
/* Check if the VAR is already contained in the targetlist */
|
||||
if (tlist_member((Var *) clause, (List *) targetlist_so_far) == NULL)
|
||||
add_tl_element(&tmp_rel, (Var *) clause);
|
||||
|
||||
return tmp_rel.targetlist;
|
||||
}
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else if (IsA(clause, Aggref))
|
||||
{
|
||||
targetlist_so_far =
|
||||
check_having_qual_for_vars(((Aggref *) clause)->target, targetlist_so_far);
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else if (IsA(clause, ArrayRef))
|
||||
{
|
||||
ArrayRef *aref = (ArrayRef *) clause;
|
||||
|
||||
/*
|
||||
* This is an arrayref. Recursively call this routine for its
|
||||
* expression and its index expression...
|
||||
*/
|
||||
foreach(t, aref->refupperindexpr)
|
||||
|
||||
else if (is_funcclause(clause) || not_clause(clause) ||
|
||||
or_clause(clause) || and_clause(clause))
|
||||
{
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
|
||||
/*
|
||||
* This is a function. Recursively call this routine for its
|
||||
* arguments...
|
||||
*/
|
||||
foreach(t, ((Expr *) clause)->args)
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
return targetlist_so_far;
|
||||
}
|
||||
foreach(t, aref->reflowerindexpr)
|
||||
else if (IsA(clause, Aggref))
|
||||
{
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
targetlist_so_far =
|
||||
check_having_qual_for_vars(((Aggref *) clause)->target, targetlist_so_far);
|
||||
return targetlist_so_far;
|
||||
}
|
||||
targetlist_so_far = check_having_qual_for_vars(aref->refexpr, targetlist_so_far);
|
||||
targetlist_so_far = check_having_qual_for_vars(aref->refassgnexpr, targetlist_so_far);
|
||||
|
||||
return targetlist_so_far;
|
||||
}
|
||||
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)
|
||||
targetlist_so_far = check_having_qual_for_vars(left, targetlist_so_far);
|
||||
if (right != (Node *) NULL)
|
||||
targetlist_so_far = check_having_qual_for_vars(right, targetlist_so_far);
|
||||
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else if (IsA(clause, Param) || IsA(clause, Const))
|
||||
{
|
||||
/* do nothing! */
|
||||
return targetlist_so_far;
|
||||
}
|
||||
/* If we get to a sublink, then we only have to check the lefthand side of the expression
|
||||
* to see if there are any additional VARs */
|
||||
else if (IsA(clause, SubLink))
|
||||
{
|
||||
foreach(t,((List *)((SubLink *)clause)->lefthand))
|
||||
else if (IsA(clause, ArrayRef))
|
||||
{
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
ArrayRef *aref = (ArrayRef *) clause;
|
||||
|
||||
/*
|
||||
* This is an arrayref. Recursively call this routine for its
|
||||
* expression and its index expression...
|
||||
*/
|
||||
foreach(t, aref->refupperindexpr)
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
foreach(t, aref->reflowerindexpr)
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
targetlist_so_far = check_having_qual_for_vars(aref->refexpr, targetlist_so_far);
|
||||
targetlist_so_far = check_having_qual_for_vars(aref->refassgnexpr, targetlist_so_far);
|
||||
|
||||
return targetlist_so_far;
|
||||
}
|
||||
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)
|
||||
targetlist_so_far = check_having_qual_for_vars(left, targetlist_so_far);
|
||||
if (right != (Node *) NULL)
|
||||
targetlist_so_far = check_having_qual_for_vars(right, targetlist_so_far);
|
||||
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else if (IsA(clause, Param) ||IsA(clause, Const))
|
||||
{
|
||||
/* do nothing! */
|
||||
return targetlist_so_far;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we get to a sublink, then we only have to check the lefthand
|
||||
* side of the expression to see if there are any additional VARs
|
||||
*/
|
||||
else if (IsA(clause, SubLink))
|
||||
{
|
||||
foreach(t, ((List *) ((SubLink *) clause)->lefthand))
|
||||
targetlist_so_far = check_having_qual_for_vars(lfirst(t), targetlist_so_far);
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
/*
|
||||
* Ooops! we can not handle that!
|
||||
*/
|
||||
elog(ERROR, "check_having_qual_for_vars: Can not handle this having_qual! %d\n",
|
||||
nodeTag(clause));
|
||||
return NIL;
|
||||
}
|
||||
return targetlist_so_far;
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* Ooops! we can not handle that!
|
||||
*/
|
||||
elog(ERROR, "check_having_qual_for_vars: Can not handle this having_qual! %d\n",
|
||||
nodeTag(clause));
|
||||
return NIL;
|
||||
}
|
||||
}
|
||||
|
||||
/* check_having_qual_for_aggs takes the havingQual, the targetlist and the groupClause
|
||||
/* check_having_qual_for_aggs takes the havingQual, the targetlist and the groupClause
|
||||
* as arguments and scans the havingQual recursively for aggregates. If an aggregate is
|
||||
* found it is attached to a list and returned by the function. (All the returned lists
|
||||
* found it is attached to a list and returned by the function. (All the returned lists
|
||||
* are concenated to result_plan->aggs in planner.c:union_planner() */
|
||||
List *
|
||||
check_having_qual_for_aggs(Node *clause, List *subplanTargetList, List *groupClause)
|
||||
{
|
||||
List *t, *l1;
|
||||
List *t,
|
||||
*l1;
|
||||
List *agg_list = NIL;
|
||||
|
||||
int contained_in_group_clause = 0;
|
||||
|
||||
int contained_in_group_clause = 0;
|
||||
|
||||
|
||||
if (IsA(clause, Var))
|
||||
{
|
||||
TargetEntry *subplanVar;
|
||||
|
||||
/*
|
||||
* Ha! A Var node!
|
||||
*/
|
||||
subplanVar = match_varid((Var *) clause, subplanTargetList);
|
||||
|
||||
/*
|
||||
* Change the varno & varattno fields of the var node to point to the resdom->resno
|
||||
* fields of the subplan (lefttree)
|
||||
*/
|
||||
((Var *) clause)->varattno = subplanVar->resdom->resno;
|
||||
TargetEntry *subplanVar;
|
||||
|
||||
return NIL;
|
||||
/*
|
||||
* Ha! A Var node!
|
||||
*/
|
||||
subplanVar = match_varid((Var *) clause, subplanTargetList);
|
||||
|
||||
/*
|
||||
* Change the varno & varattno fields of the var node to point to
|
||||
* the resdom->resno fields of the subplan (lefttree)
|
||||
*/
|
||||
((Var *) clause)->varattno = subplanVar->resdom->resno;
|
||||
|
||||
return NIL;
|
||||
|
||||
}
|
||||
/***S*H***/
|
||||
else if (is_funcclause(clause) || not_clause(clause) ||
|
||||
or_clause(clause) || and_clause(clause))
|
||||
/***S*H***/
|
||||
else if (is_funcclause(clause) || not_clause(clause) ||
|
||||
or_clause(clause) || and_clause(clause))
|
||||
{
|
||||
int new_length=0, old_length=0;
|
||||
|
||||
int new_length = 0,
|
||||
old_length = 0;
|
||||
|
||||
/*
|
||||
* This is a function. Recursively call this routine for its
|
||||
* arguments... (i.e. for AND, OR, ... clauses!)
|
||||
*/
|
||||
foreach(t, ((Expr *) clause)->args)
|
||||
{
|
||||
old_length=length((List *)agg_list);
|
||||
old_length = length((List *) agg_list);
|
||||
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
|
||||
/* The arguments of OR or AND clauses are comparisons or relations
|
||||
* and because we are in the havingQual there must be at least one operand
|
||||
* using an aggregate function. If so, we will find it and the length of the
|
||||
* agg_list will be increased after the above call to
|
||||
* check_having_qual_for_aggs. If there are no aggregates used, the query
|
||||
* could have been formulated using the 'where' clause */
|
||||
if(((new_length=length((List *)agg_list)) == old_length) || (new_length == 0))
|
||||
{
|
||||
elog(ERROR,"This could have been done in a where clause!!");
|
||||
return NIL;
|
||||
}
|
||||
/*
|
||||
* The arguments of OR or AND clauses are comparisons or
|
||||
* relations and because we are in the havingQual there must
|
||||
* be at least one operand using an aggregate function. If so,
|
||||
* we will find it and the length of the agg_list will be
|
||||
* increased after the above call to
|
||||
* check_having_qual_for_aggs. If there are no aggregates
|
||||
* used, the query could have been formulated using the
|
||||
* 'where' clause
|
||||
*/
|
||||
if (((new_length = length((List *) agg_list)) == old_length) || (new_length == 0))
|
||||
{
|
||||
elog(ERROR, "This could have been done in a where clause!!");
|
||||
return NIL;
|
||||
}
|
||||
}
|
||||
return agg_list;
|
||||
}
|
||||
else if (IsA(clause, Aggref))
|
||||
{
|
||||
return lcons(clause,
|
||||
check_having_qual_for_aggs(((Aggref *) clause)->target, subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(((Aggref *) clause)->target, subplanTargetList,
|
||||
groupClause));
|
||||
}
|
||||
else if (IsA(clause, ArrayRef))
|
||||
{
|
||||
|
|
@ -1117,21 +1117,21 @@ check_having_qual_for_aggs(Node *clause, List *subplanTargetList, List *groupCla
|
|||
foreach(t, aref->refupperindexpr)
|
||||
{
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
}
|
||||
foreach(t, aref->reflowerindexpr)
|
||||
{
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(lfirst(t), subplanTargetList,
|
||||
groupClause));
|
||||
}
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(aref->refexpr, subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(aref->refexpr, subplanTargetList,
|
||||
groupClause));
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(aref->refassgnexpr, subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(aref->refassgnexpr, subplanTargetList,
|
||||
groupClause));
|
||||
|
||||
return agg_list;
|
||||
}
|
||||
|
|
@ -1147,92 +1147,102 @@ check_having_qual_for_aggs(Node *clause, List *subplanTargetList, List *groupCla
|
|||
|
||||
if (left != (Node *) NULL)
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(left, subplanTargetList,
|
||||
groupClause));
|
||||
check_having_qual_for_aggs(left, subplanTargetList,
|
||||
groupClause));
|
||||
if (right != (Node *) NULL)
|
||||
agg_list = nconc(agg_list,
|
||||
check_having_qual_for_aggs(right, subplanTargetList,
|
||||
groupClause));
|
||||
groupClause));
|
||||
|
||||
return agg_list;
|
||||
}
|
||||
else if (IsA(clause, Param) || IsA(clause, Const))
|
||||
else if (IsA(clause, Param) ||IsA(clause, Const))
|
||||
{
|
||||
/* do nothing! */
|
||||
return NIL;
|
||||
}
|
||||
/* This is for Sublinks which show up as EXPR nodes. All the other EXPR nodes
|
||||
* (funcclauses, and_clauses, or_clauses) were caught above */
|
||||
|
||||
/*
|
||||
* This is for Sublinks which show up as EXPR nodes. All the other
|
||||
* EXPR nodes (funcclauses, and_clauses, or_clauses) were caught above
|
||||
*/
|
||||
else if (IsA(clause, Expr))
|
||||
{
|
||||
/* Only the lefthand side of the sublink has to be checked for aggregates
|
||||
* to be attached to result_plan->aggs (see planner.c:union_planner() )
|
||||
*/
|
||||
foreach(t,((List *)((SubLink *)((SubPlan *)
|
||||
((Expr *)clause)->oper)->sublink)->lefthand))
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t),
|
||||
subplanTargetList, groupClause));
|
||||
}
|
||||
{
|
||||
|
||||
/* The first argument of ...->oper has also to be checked */
|
||||
{
|
||||
List *tmp_ptr;
|
||||
|
||||
foreach(tmp_ptr, ((SubLink *)((SubPlan *)
|
||||
((Expr *)clause)->oper)->sublink)->oper)
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs((Node *)lfirst(((Expr *)
|
||||
lfirst(tmp_ptr))->args),
|
||||
subplanTargetList, groupClause));
|
||||
/*
|
||||
* Only the lefthand side of the sublink has to be checked for
|
||||
* aggregates to be attached to result_plan->aggs (see
|
||||
* planner.c:union_planner() )
|
||||
*/
|
||||
foreach(t, ((List *) ((SubLink *) ((SubPlan *)
|
||||
((Expr *) clause)->oper)->sublink)->lefthand))
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t),
|
||||
subplanTargetList, groupClause));
|
||||
}
|
||||
}
|
||||
|
||||
/* All arguments to the Sublink node are attributes from outside used within
|
||||
* the sublink. Here we have to check that only attributes that is grouped for
|
||||
* are used! */
|
||||
foreach(t,((Expr *)clause)->args)
|
||||
{
|
||||
contained_in_group_clause = 0;
|
||||
|
||||
foreach(l1,groupClause)
|
||||
{
|
||||
if (tlist_member(lfirst(t),lcons(((GroupClause *)lfirst(l1))->entry,NIL)) !=
|
||||
NULL)
|
||||
{
|
||||
contained_in_group_clause=1;
|
||||
}
|
||||
}
|
||||
|
||||
/* If the use of the attribute is allowed (i.e. it is in the groupClause)
|
||||
* we have to adjust the varnos and varattnos */
|
||||
if (contained_in_group_clause)
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t),
|
||||
subplanTargetList, groupClause));
|
||||
}
|
||||
else
|
||||
{
|
||||
elog(ERROR,"You must group by the attribute used from outside!");
|
||||
return NIL;
|
||||
}
|
||||
}
|
||||
return agg_list;
|
||||
}
|
||||
/* The first argument of ...->oper has also to be checked */
|
||||
{
|
||||
List *tmp_ptr;
|
||||
|
||||
foreach(tmp_ptr, ((SubLink *) ((SubPlan *)
|
||||
((Expr *) clause)->oper)->sublink)->oper)
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs((Node *) lfirst(((Expr *)
|
||||
lfirst(tmp_ptr))->args),
|
||||
subplanTargetList, groupClause));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* All arguments to the Sublink node are attributes from outside
|
||||
* used within the sublink. Here we have to check that only
|
||||
* attributes that is grouped for are used!
|
||||
*/
|
||||
foreach(t, ((Expr *) clause)->args)
|
||||
{
|
||||
contained_in_group_clause = 0;
|
||||
|
||||
foreach(l1, groupClause)
|
||||
{
|
||||
if (tlist_member(lfirst(t), lcons(((GroupClause *) lfirst(l1))->entry, NIL)) !=
|
||||
NULL)
|
||||
contained_in_group_clause = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the use of the attribute is allowed (i.e. it is in the
|
||||
* groupClause) we have to adjust the varnos and varattnos
|
||||
*/
|
||||
if (contained_in_group_clause)
|
||||
{
|
||||
agg_list =
|
||||
nconc(agg_list,
|
||||
check_having_qual_for_aggs(lfirst(t),
|
||||
subplanTargetList, groupClause));
|
||||
}
|
||||
else
|
||||
{
|
||||
elog(ERROR, "You must group by the attribute used from outside!");
|
||||
return NIL;
|
||||
}
|
||||
}
|
||||
return agg_list;
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* Ooops! we can not handle that!
|
||||
*/
|
||||
elog(ERROR, "check_having_qual_for_aggs: Can not handle this having_qual! %d\n",
|
||||
nodeTag(clause));
|
||||
return NIL;
|
||||
}
|
||||
{
|
||||
|
||||
/*
|
||||
* Ooops! we can not handle that!
|
||||
*/
|
||||
elog(ERROR, "check_having_qual_for_aggs: Can not handle this having_qual! %d\n",
|
||||
nodeTag(clause));
|
||||
return NIL;
|
||||
}
|
||||
}
|
||||
/***S*H***/ /* End */
|
||||
|
||||
/***S*H***//* End */
|
||||
|
|
|
|||
Loading…
Reference in New Issue