open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clean up routines in setrefs.c by replacing individual tree

Browse Source 
walking logic with expression_tree_walker/mutator calls.
REL7_0_PATCHES
Tom Lane 26 years ago
parent 6bc601b648
commit ecef2caae9
2 changed files with 157 additions and 551 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 702
      src/backend/optimizer/plan/setrefs.c
  2. 6
      src/include/optimizer/planmain.h

702
src/backend/optimizer/plan/setrefs.c
Unescape View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.53 1999/07/16 04:59:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.54 1999/08/09 00:56:05 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -15,8 +15,6 @@
#include "postgres.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
@ -24,22 +22,40 @@
#include "optimizer/tlist.h"
#include "optimizer/var.h"
typedef struct {
List *outer_tlist;
List *inner_tlist;
} replace_joinvar_refs_context;
typedef struct {
Index subvarno;
List *subplanTargetList;
} replace_vars_with_subplan_refs_context;
typedef struct {
List *groupClause;
List *targetList;
} check_having_for_ungrouped_vars_context;
static void set_join_tlist_references(Join *join);
static void set_nonamescan_tlist_references(SeqScan *nonamescan);
static void set_noname_tlist_references(Noname *noname);
static Node *replace_clause_joinvar_refs(Node *clause,
List *outer_tlist,
List *inner_tlist);
static Var *replace_joinvar_refs(Var *var,
List *outer_tlist,
List *inner_tlist);
static Node *replace_joinvar_refs(Node *clause,
List *outer_tlist,
List *inner_tlist);
static Node *replace_joinvar_refs_mutator(Node *node,
replace_joinvar_refs_context *context);
static List *tlist_noname_references(Oid nonameid, List *tlist);
static bool OperandIsInner(Node *opnd, int inner_relid);
static List *pull_agg_clause(Node *clause);
static void set_result_tlist_references(Result *resultNode);
static void replace_vars_with_subplan_refs(Node *clause,
Index subvarno,
List *subplanTargetList);
Index subvarno,
List *subplanTargetList);
static bool replace_vars_with_subplan_refs_walker(Node *node,
replace_vars_with_subplan_refs_context *context);
static List *pull_agg_clause(Node *clause);
static bool pull_agg_clause_walker(Node *node, List **listptr);
static bool check_having_for_ungrouped_vars_walker(Node *node,
check_having_for_ungrouped_vars_context *context);
/*****************************************************************************
*
@ -107,12 +123,12 @@ set_join_tlist_references(Join *join)
foreach(entry, qptlist)
{
TargetEntry *xtl = (TargetEntry *) lfirst(entry);
Node *joinvar = replace_clause_joinvar_refs(xtl->expr,
outer_tlist,
inner_tlist);
Node *joinexpr = replace_joinvar_refs(xtl->expr,
outer_tlist,
inner_tlist);
new_join_targetlist = lappend(new_join_targetlist,
makeTargetEntry(xtl->resdom, joinvar));
makeTargetEntry(xtl->resdom, joinexpr));
}
((Plan *) join)->targetlist = new_join_targetlist;
@ -173,7 +189,7 @@ set_noname_tlist_references(Noname *noname)
* Creates a new set of join clauses by changing the varno/varattno
* values of variables in the clauses to reference target list values
* from the outer and inner join relation target lists.
* This is just an external interface for replace_clause_joinvar_refs.
* This is just an external interface for replace_joinvar_refs.
*
* 'clauses' is the list of join clauses
* 'outer_tlist' is the target list of the outer join relation
@ -188,291 +204,75 @@ join_references(List *clauses,
List *outer_tlist,
List *inner_tlist)
{
return (List *) replace_clause_joinvar_refs((Node *) clauses,
outer_tlist,
inner_tlist);
return (List *) replace_joinvar_refs((Node *) clauses,
outer_tlist,
inner_tlist);
}
/*
* index_outerjoin_references
* Given a list of join clauses, replace the operand corresponding to the
* outer relation in the join with references to the corresponding target
* list element in 'outer_tlist' (the outer is rather obscurely
* identified as the side that doesn't contain a var whose varno equals
* 'inner_relid').
*
* As a side effect, the operator is replaced by the regproc id.
*
* 'inner_indxqual' is the list of join clauses (so-called because they
* are used as qualifications for the inner (inbex) scan of a nestloop)
*
* Returns the new list of clauses.
*
*/
List *
index_outerjoin_references(List *inner_indxqual,
List *outer_tlist,
Index inner_relid)
{
List *t_list = NIL;
Expr *temp = NULL;
List *t_clause = NIL;
Expr *clause = NULL;
foreach(t_clause, inner_indxqual)
{
clause = lfirst(t_clause);
/*
* if inner scan on the right.
*/
if (OperandIsInner((Node *) get_rightop(clause), inner_relid))
{
Var *joinvar = (Var *)
replace_clause_joinvar_refs((Node *) get_leftop(clause),
outer_tlist,
NIL);
temp = make_opclause(replace_opid((Oper *) ((Expr *) clause)->oper),
joinvar,
get_rightop(clause));
t_list = lappend(t_list, temp);
}
else
{
/* inner scan on left */
Var *joinvar = (Var *)
replace_clause_joinvar_refs((Node *) get_rightop(clause),
outer_tlist,
NIL);
temp = make_opclause(replace_opid((Oper *) ((Expr *) clause)->oper),
get_leftop(clause),
joinvar);
t_list = lappend(t_list, temp);
}
}
return t_list;
}
/*
* replace_clause_joinvar_refs
* replace_joinvar_refs
*
* Replaces all variables within a join clause with a new var node
* whose varno/varattno fields contain a reference to a target list
* element from either the outer or inner join relation.
*
* Returns a suitably modified copy of the join clause;
* the original is not modified (and must not be!)
*
* Side effect: also runs fix_opids on the modified join clause.
* Really ought to make that happen in a uniform, consistent place...
*
* 'clause' is the join clause
* 'outer_tlist' is the target list of the outer join relation
* 'inner_tlist' is the target list of the inner join relation
*
* Returns the new join clause.
* NB: it is critical that the original clause structure not be modified!
* The changes must be applied to a copy.
*
* XXX the current implementation does not copy unchanged primitive
* nodes; they remain shared with the original. Is this safe?
*/
static Node *
replace_clause_joinvar_refs(Node *clause,
List *outer_tlist,
List *inner_tlist)
replace_joinvar_refs(Node *clause,
List *outer_tlist,
List *inner_tlist)
{
if (clause == NULL)
return NULL;
if (IsA(clause, Var))
{
Var *temp = replace_joinvar_refs((Var *) clause,
outer_tlist, inner_tlist);
replace_joinvar_refs_context context;
if (temp != NULL)
return (Node *) temp;
else
return clause;
}
else if (single_node(clause))
return clause;
else if (and_clause(clause))
{
return (Node *) make_andclause((List *)
replace_clause_joinvar_refs((Node *) ((Expr *) clause)->args,
outer_tlist,
inner_tlist));
}
else if (or_clause(clause))
{
return (Node *) make_orclause((List *)
replace_clause_joinvar_refs((Node *) ((Expr *) clause)->args,
outer_tlist,
inner_tlist));
}
else if (IsA(clause, ArrayRef))
{
ArrayRef *oldnode = (ArrayRef *) clause;
ArrayRef *newnode = makeNode(ArrayRef);
newnode->refattrlength = oldnode->refattrlength;
newnode->refelemlength = oldnode->refelemlength;
newnode->refelemtype = oldnode->refelemtype;
newnode->refelembyval = oldnode->refelembyval;
newnode->refupperindexpr = (List *)
replace_clause_joinvar_refs((Node *) oldnode->refupperindexpr,
outer_tlist,
inner_tlist);
newnode->reflowerindexpr = (List *)
replace_clause_joinvar_refs((Node *) oldnode->reflowerindexpr,
outer_tlist,
inner_tlist);
newnode->refexpr =
replace_clause_joinvar_refs(oldnode->refexpr,
outer_tlist,
inner_tlist);
newnode->refassgnexpr =
replace_clause_joinvar_refs(oldnode->refassgnexpr,
outer_tlist,
inner_tlist);
return (Node *) newnode;
}
else if (is_funcclause(clause))
{
return (Node *) make_funcclause(
(Func *) ((Expr *) clause)->oper,
(List *) replace_clause_joinvar_refs(
(Node *) ((Expr *) clause)->args,
outer_tlist,
inner_tlist));
}
else if (not_clause(clause))
{
return (Node *) make_notclause((Expr *)
replace_clause_joinvar_refs(
(Node *) get_notclausearg((Expr *) clause),
outer_tlist,
inner_tlist));
}
else if (is_opclause(clause))
{
return (Node *) make_opclause(
replace_opid((Oper *) ((Expr *) clause)->oper),
(Var *) replace_clause_joinvar_refs(
(Node *) get_leftop((Expr *) clause),
outer_tlist,
inner_tlist),
(Var *) replace_clause_joinvar_refs(
(Node *) get_rightop((Expr *) clause),
outer_tlist,
inner_tlist));
}
else if (IsA(clause, List))
{
List *t_list = NIL;
List *subclause;
foreach(subclause, (List *) clause)
{
t_list = lappend(t_list,
replace_clause_joinvar_refs(lfirst(subclause),
outer_tlist,
inner_tlist));
}
return (Node *) t_list;
}
else if (is_subplan(clause))
{
/* This is a tad wasteful of space, but it works... */
Expr *newclause = (Expr *) copyObject(clause);
newclause->args = (List *)
replace_clause_joinvar_refs((Node *) newclause->args,
outer_tlist,
inner_tlist);
((SubPlan *) newclause->oper)->sublink->oper = (List *)
replace_clause_joinvar_refs(
(Node *) ((SubPlan *) newclause->oper)->sublink->oper,
outer_tlist,
inner_tlist);
return (Node *) newclause;
}
else if (IsA(clause, CaseExpr))
{
CaseExpr *oldnode = (CaseExpr *) clause;
CaseExpr *newnode = makeNode(CaseExpr);
newnode->casetype = oldnode->casetype;
newnode->arg = oldnode->arg; /* XXX should always be null
* anyway ... */
newnode->args = (List *)
replace_clause_joinvar_refs((Node *) oldnode->args,
outer_tlist,
inner_tlist);
newnode->defresult =
replace_clause_joinvar_refs(oldnode->defresult,
outer_tlist,
inner_tlist);
return (Node *) newnode;
}
else if (IsA(clause, CaseWhen))
{
CaseWhen *oldnode = (CaseWhen *) clause;
CaseWhen *newnode = makeNode(CaseWhen);
newnode->expr =
replace_clause_joinvar_refs(oldnode->expr,
outer_tlist,
inner_tlist);
newnode->result =
replace_clause_joinvar_refs(oldnode->result,
outer_tlist,
inner_tlist);
return (Node *) newnode;
}
else
{
elog(ERROR, "replace_clause_joinvar_refs: unsupported clause %d",
nodeTag(clause));
return NULL;
}
context.outer_tlist = outer_tlist;
context.inner_tlist = inner_tlist;
return (Node *) fix_opids((List *)
replace_joinvar_refs_mutator(clause, &context));
}
static Var *
replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist)
static Node *
replace_joinvar_refs_mutator(Node *node,
replace_joinvar_refs_context *context)
{
Resdom *outer_resdom;
outer_resdom = tlist_member(var, outer_tlist);
if (outer_resdom != NULL && IsA(outer_resdom, Resdom))
{
return (makeVar(OUTER,
outer_resdom->resno,
var->vartype,
var->vartypmod,
0,
var->varnoold,
var->varoattno));
}
else
{
Resdom *inner_resdom;
inner_resdom = tlist_member(var, inner_tlist);
if (inner_resdom != NULL && IsA(inner_resdom, Resdom))
{
return (makeVar(INNER,
inner_resdom->resno,
var->vartype,
var->vartypmod,
0,
var->varnoold,
var->varoattno));
}
}
return (Var *) NULL;
if (node == NULL)
return NULL;
if (IsA(node, Var))
{
Var *var = (Var *) node;
Resdom *resdom = tlist_member(var, context->outer_tlist);
if (resdom != NULL && IsA(resdom, Resdom))
return (Node *) makeVar(OUTER,
resdom->resno,
var->vartype,
var->vartypmod,
0,
var->varnoold,
var->varoattno);
resdom = tlist_member(var, context->inner_tlist);
if (resdom != NULL && IsA(resdom, Resdom))
return (Node *) makeVar(INNER,
resdom->resno,
var->vartype,
var->vartypmod,
0,
var->varnoold,
var->varoattno);
/* Var not in either tlist, return an unmodified copy. */
return copyObject(node);
}
return expression_tree_mutator(node,
replace_joinvar_refs_mutator,
(void *) context);
}
/*
@ -494,15 +294,14 @@ tlist_noname_references(Oid nonameid,
List *tlist)
{
List *t_list = NIL;
TargetEntry *noname = (TargetEntry *) NULL;
TargetEntry *xtl = NULL;
List *entry;
foreach(entry, tlist)
{
TargetEntry *xtl = lfirst(entry);
AttrNumber oattno;
TargetEntry *noname;
xtl = lfirst(entry);
if (IsA(get_expr(xtl), Var))
oattno = ((Var *) xtl->expr)->varoattno;
else
@ -531,7 +330,7 @@ tlist_noname_references(Oid nonameid,
*
* NOTE:
* 1) we ignore the right tree! (in the current implementation
* it is always nil
* it is always nil)
* 2) this routine will probably *NOT* work with nested dot
* fields....
*/
@ -601,131 +400,52 @@ replace_vars_with_subplan_refs(Node *clause,
Index subvarno,
List *subplanTargetList)
{
List *t;
replace_vars_with_subplan_refs_context context;
if (clause == NULL)
return;
if (IsA(clause, Var))
{
context.subvarno = subvarno;
context.subplanTargetList = subplanTargetList;
replace_vars_with_subplan_refs_walker(clause, &context);
}
static bool
replace_vars_with_subplan_refs_walker(Node *node,
replace_vars_with_subplan_refs_context *context)
{
if (node == NULL)
return false;
if (IsA(node, Var))
{
/*
* Ha! A Var node!
*
* It could be that this varnode has been created by make_groupplan
* and is already set up to reference the subplan target list. We
* recognize that case by varno = 1, varnoold = -1, varattno =
* varoattno, and varlevelsup = 0. (Probably ought to have an
* explicit flag, but this should do for now.)
*/
Var *var = (Var *) clause;
Var *var = (Var *) node;
TargetEntry *subplanVar;
if (var->varno == (Index) 1 &&
var->varnoold == ((Index) -1) &&
var->varattno == var->varoattno &&
var->varlevelsup == 0)
return; /* OK to leave it alone */
return false; /* OK to leave it alone */
/* Otherwise it had better be in the subplan list. */
subplanVar = match_varid(var, subplanTargetList);
subplanVar = match_varid(var, context->subplanTargetList);
if (!subplanVar)
elog(ERROR, "replace_vars_with_subplan_refs: variable not in target list");
/*
* Change the varno & varattno fields of the var node.
*/
var->varno = subvarno;
var->varno = context->subvarno;
var->varattno = subplanVar->resdom->resno;
return false;
}
else if (single_node(clause))
{
/* do nothing! */
}
else if (IsA(clause, Iter))
replace_vars_with_subplan_refs(((Iter *) clause)->iterexpr,
subvarno, subplanTargetList);
else if (is_subplan(clause))
{
foreach(t, ((Expr *) clause)->args)
replace_vars_with_subplan_refs(lfirst(t),
subvarno, subplanTargetList);
foreach(t, ((SubPlan *) ((Expr *) clause)->oper)->sublink->oper)
replace_vars_with_subplan_refs(lfirst(((Expr *) lfirst(t))->args),
subvarno, subplanTargetList);
}
else if (IsA(clause, Expr))
{
/*
* Recursively scan the arguments of an expression. NOTE: this
* must come after is_subplan() case since subplan is a kind of
* Expr node.
*/
foreach(t, ((Expr *) clause)->args)
replace_vars_with_subplan_refs(lfirst(t),
subvarno, subplanTargetList);
}
else if (IsA(clause, Aggref))
replace_vars_with_subplan_refs(((Aggref *) clause)->target,
subvarno, subplanTargetList);
else if (IsA(clause, ArrayRef))
{
ArrayRef *aref = (ArrayRef *) clause;
foreach(t, aref->refupperindexpr)
replace_vars_with_subplan_refs(lfirst(t),
subvarno, subplanTargetList);
foreach(t, aref->reflowerindexpr)
replace_vars_with_subplan_refs(lfirst(t),
subvarno, subplanTargetList);
replace_vars_with_subplan_refs(aref->refexpr,
subvarno, subplanTargetList);
replace_vars_with_subplan_refs(aref->refassgnexpr,
subvarno, subplanTargetList);
}
else if (case_clause(clause))
{
foreach(t, ((CaseExpr *) clause)->args)
{
CaseWhen *when = (CaseWhen *) lfirst(t);
replace_vars_with_subplan_refs(when->expr,
subvarno, subplanTargetList);
replace_vars_with_subplan_refs(when->result,
subvarno, subplanTargetList);
}
replace_vars_with_subplan_refs(((CaseExpr *) clause)->defresult,
subvarno, subplanTargetList);
}
else
{
elog(ERROR, "replace_vars_with_subplan_refs: Cannot handle node type %d",
nodeTag(clause));
}
}
static bool
OperandIsInner(Node *opnd, int inner_relid)
{
/*
* Can be the inner scan if its a varnode or a function and the
* inner_relid is equal to the varnode's var number or in the case of
* a function the first argument's var number (all args in a
* functional index are from the same relation).
*/
if (IsA(opnd, Var) &&
(inner_relid == ((Var *) opnd)->varno))
return true;
if (is_funcclause(opnd))
{
List *firstArg = lfirst(((Expr *) opnd)->args);
if (IsA(firstArg, Var) &&
(inner_relid == ((Var *) firstArg)->varno))
return true;
}
return false;
return expression_tree_walker(node,
replace_vars_with_subplan_refs_walker,
(void *) context);
}
/*****************************************************************************
@ -787,83 +507,35 @@ set_agg_tlist_references(Agg *aggNode)
}
/*
* Make a list of all Aggref nodes contained in the given expression.
* pull_agg_clause
* Recursively pulls all Aggref nodes from an expression clause.
*
* Returns list of Aggref nodes found. Note the nodes themselves are not
* copied, only referenced.
*/
static List *
pull_agg_clause(Node *clause)
{
List *agg_list = NIL;
List *t;
if (clause == NULL)
return NIL;
else if (single_node(clause))
return NIL;
else if (IsA(clause, Iter))
return pull_agg_clause(((Iter *) clause)->iterexpr);
else if (is_subplan(clause))
{
SubLink *sublink = ((SubPlan *) ((Expr *) clause)->oper)->sublink;
List *result = NIL;
/*
* Only the lefthand side of the sublink should be checked for
* aggregates to be attached to the aggs list
*/
foreach(t, sublink->lefthand)
agg_list = nconc(pull_agg_clause(lfirst(t)), agg_list);
/* The first argument of ...->oper has also to be checked */
foreach(t, sublink->oper)
agg_list = nconc(pull_agg_clause(lfirst(t)), agg_list);
}
else if (IsA(clause, Expr))
{
/*
* Recursively scan the arguments of an expression. NOTE: this
* must come after is_subplan() case since subplan is a kind of
* Expr node.
*/
foreach(t, ((Expr *) clause)->args)
agg_list = nconc(pull_agg_clause(lfirst(t)), agg_list);
}
else if (IsA(clause, Aggref))
{
return lcons(clause,
pull_agg_clause(((Aggref *) clause)->target));
}
else if (IsA(clause, ArrayRef))
{
ArrayRef *aref = (ArrayRef *) clause;
foreach(t, aref->refupperindexpr)
agg_list = nconc(pull_agg_clause(lfirst(t)), agg_list);
foreach(t, aref->reflowerindexpr)
agg_list = nconc(pull_agg_clause(lfirst(t)), agg_list);
agg_list = nconc(pull_agg_clause(aref->refexpr), agg_list);
agg_list = nconc(pull_agg_clause(aref->refassgnexpr), agg_list);
}
else if (case_clause(clause))
{
foreach(t, ((CaseExpr *) clause)->args)
{
CaseWhen *when = (CaseWhen *) lfirst(t);
pull_agg_clause_walker(clause, &result);
return result;
}
agg_list = nconc(agg_list, pull_agg_clause(when->expr));
agg_list = nconc(agg_list, pull_agg_clause(when->result));
}
agg_list = nconc(pull_agg_clause(((CaseExpr *) clause)->defresult),
agg_list);
}
else
static bool
pull_agg_clause_walker(Node *node, List **listptr)
{
if (node == NULL)
return false;
if (IsA(node, Aggref))
{
elog(ERROR, "pull_agg_clause: Cannot handle node type %d",
nodeTag(clause));
*listptr = lappend(*listptr, node);
return false;
}
return agg_list;
return expression_tree_walker(node, pull_agg_clause_walker,
(void *) listptr);
}
/*
* check_having_for_ungrouped_vars takes the havingQual and the list of
* GROUP BY clauses and checks for subplans in the havingQual that are being
@ -882,45 +554,43 @@ void
check_having_for_ungrouped_vars(Node *clause, List *groupClause,
List *targetList)
{
List *t;
if (clause == NULL)
return;
check_having_for_ungrouped_vars_context context;
if (IsA(clause, Var))
{
context.groupClause = groupClause;
context.targetList = targetList;
check_having_for_ungrouped_vars_walker(clause, &context);
}
/*
* Ignore vars elsewhere in the having clause, since the parser
* already checked 'em.
*/
}
else if (single_node(clause))
{
/* ignore */
}
else if (IsA(clause, Iter))
{
check_having_for_ungrouped_vars(((Iter *) clause)->iterexpr,
groupClause, targetList);
}
else if (is_subplan(clause))
static bool
check_having_for_ungrouped_vars_walker(Node *node,
check_having_for_ungrouped_vars_context *context)
{
if (node == NULL)
return false;
/*
* We can ignore Vars other than in subplan args lists,
* since the parser already checked 'em.
*/
if (is_subplan(node))
{
/*
* The args list of the subplan node represents attributes from
* outside passed into the sublink.
*/
foreach(t, ((Expr *) clause)->args)
List *t;
foreach(t, ((Expr *) node)->args)
{
Node *thisarg = lfirst(t);
bool contained_in_group_clause = false;
List *gl;
foreach(gl, groupClause)
foreach(gl, context->groupClause)
{
if (var_equal(lfirst(t),
get_groupclause_expr((GroupClause *)
lfirst(gl), targetList)))
Var *groupexpr = get_groupclause_expr(lfirst(gl),
context->targetList);
if (var_equal((Var *) thisarg, groupexpr))
{
contained_in_group_clause = true;
break;
@ -931,69 +601,7 @@ check_having_for_ungrouped_vars(Node *clause, List *groupClause,
elog(ERROR, "Sub-SELECT in HAVING clause must use only GROUPed attributes from outer SELECT");
}
}
else if (IsA(clause, Expr))
{
/*
* Recursively scan the arguments of an expression. NOTE: this
* must come after is_subplan() case since subplan is a kind of
* Expr node.
*/
foreach(t, ((Expr *) clause)->args)
check_having_for_ungrouped_vars(lfirst(t), groupClause,
targetList);
}
else if (IsA(clause, List))
{
/*
* Recursively scan AND subclauses (see NOTE above).
*/
foreach(t, ((List *) clause))
check_having_for_ungrouped_vars(lfirst(t), groupClause,
targetList);
}
else if (IsA(clause, Aggref))
{
check_having_for_ungrouped_vars(((Aggref *) clause)->target,
groupClause, targetList);
}
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)
check_having_for_ungrouped_vars(lfirst(t), groupClause,
targetList);
foreach(t, aref->reflowerindexpr)
check_having_for_ungrouped_vars(lfirst(t), groupClause,
targetList);
check_having_for_ungrouped_vars(aref->refexpr, groupClause,
targetList);
check_having_for_ungrouped_vars(aref->refassgnexpr, groupClause,
targetList);
}
else if (case_clause(clause))
{
foreach(t, ((CaseExpr *) clause)->args)
{
CaseWhen *when = (CaseWhen *) lfirst(t);
check_having_for_ungrouped_vars(when->expr, groupClause,
targetList);
check_having_for_ungrouped_vars(when->result, groupClause,
targetList);
}
check_having_for_ungrouped_vars(((CaseExpr *) clause)->defresult,
groupClause, targetList);
}
else
{
elog(ERROR, "check_having_for_ungrouped_vars: Cannot handle node type %d",
nodeTag(clause));
}
return expression_tree_walker(node,
check_having_for_ungrouped_vars_walker,
(void *) context);
}

6
src/include/optimizer/planmain.h
Unescape View File

@ -6,7 +6,7 @@
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: planmain.h,v 1.29 1999/07/15 15:21:22 momjian Exp $
* $Id: planmain.h,v 1.30 1999/08/09 00:56:04 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -49,9 +49,7 @@ extern void add_missing_vars_to_tlist(Query *root, List *tlist);
*/
extern void set_tlist_references(Plan *plan);
extern List *join_references(List *clauses, List *outer_tlist,
List *inner_tlist);
extern List *index_outerjoin_references(List *inner_indxqual,
List *outer_tlist, Index inner_relid);
List *inner_tlist);
extern void replace_tlist_with_subplan_refs(List *tlist,
Index subvarno,
List *subplanTargetList);

Write Preview
Loading…
Cancel
Save