*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.39 1998/12/04 15:33:19 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.40 1999/01/24 00:28:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int execConstLen;
/* static functions decls */
-static Datum ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull);
+static Datum ExecEvalAggref(Aggref *agg, ExprContext *econtext, bool *isNull);
static Datum ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
bool *isNull, bool *isDone);
static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
/* ----------------------------------------------------------------
- * ExecEvalAggreg
+ * ExecEvalAggref
*
* Returns a Datum whose value is the value of the precomputed
* aggregate found in the given expression context.
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull)
+ExecEvalAggref(Aggref *agg, ExprContext *econtext, bool *isNull)
{
*isNull = econtext->ecxt_nulls[agg->aggno];
return econtext->ecxt_values[agg->aggno];
isNull,
isDone);
break;
- case T_Aggreg:
- retDatum = (Datum) ExecEvalAggreg((Aggreg *) expression,
+ case T_Aggref:
+ retDatum = (Datum) ExecEvalAggref((Aggref *) expression,
econtext,
isNull);
break;
FmgrInfo finalfn;
} AggFuncInfo;
-static Datum aggGetAttr(TupleTableSlot *tuple, Aggreg *agg, bool *isNull);
+static Datum aggGetAttr(TupleTableSlot *tuple, Aggref *agg, bool *isNull);
/* ---------------------------------------
{
AggState *aggstate;
EState *estate;
- Aggreg **aggregates;
+ Aggref **aggregates;
Plan *outerPlan;
int i,
nagg;
nagg = length(node->aggs);
- aggregates = (Aggreg **) palloc(sizeof(Aggreg *) * nagg);
+ aggregates = (Aggref **) palloc(sizeof(Aggref *) * nagg);
/* take List* and make it an array that can be quickly indexed */
alist = node->aggs;
for (i = 0; i < nagg; i++)
{
- Aggreg *agg;
+ Aggref *agg;
char *aggname;
HeapTuple aggTuple;
Form_pg_aggregate aggp;
*/
static Datum
aggGetAttr(TupleTableSlot *slot,
- Aggreg *agg,
+ Aggref *agg,
bool *isNull)
{
Datum result;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.53 1999/01/21 22:55:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.54 1999/01/24 00:28:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* ----------------
- * _copyAggreg
+ * _copyAggref
* ----------------
*/
-static Aggreg *
-_copyAggreg(Aggreg *from)
+static Aggref *
+_copyAggref(Aggref *from)
{
- Aggreg *newnode = makeNode(Aggreg);
+ Aggref *newnode = makeNode(Aggref);
/* ----------------
* copy remainder of node
case T_ArrayRef:
retval = _copyArrayRef(from);
break;
- case T_Aggreg:
- retval = _copyAggreg(from);
+ case T_Aggref:
+ retval = _copyAggref(from);
break;
case T_SubLink:
retval = _copySubLink(from);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.60 1999/01/21 16:08:36 vadim Exp $
+ * $Id: outfuncs.c,v 1.61 1999/01/24 00:28:20 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
}
/*
- * Aggreg
+ * Aggref
*/
static void
-_outAggreg(StringInfo str, Aggreg *node)
+_outAggref(StringInfo str, Aggref *node)
{
appendStringInfo(str,
" AGGREG :aggname %s :basetype %u :aggtype %u :target ",
case T_Const:
_outConst(str, obj);
break;
- case T_Aggreg:
- _outAggreg(str, obj);
+ case T_Aggref:
+ _outAggref(str, obj);
break;
case T_SubLink:
_outSubLink(str, obj);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.42 1999/01/21 16:08:37 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.43 1999/01/24 00:28:20 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
}
/* ----------------
- * _readAggreg
+ * _readAggref
*
- * Aggreg is a subclass of Node
+ * Aggref is a subclass of Node
* ----------------
*/
-static Aggreg *
-_readAggreg()
+static Aggref *
+_readAggref()
{
- Aggreg *local_node;
+ Aggref *local_node;
char *token;
int length;
- local_node = makeNode(Aggreg);
+ local_node = makeNode(Aggref);
token = lsptok(NULL, &length); /* eat :aggname */
token = lsptok(NULL, &length); /* get aggname */
else if (!strncmp(token, "SORT", length))
return_value = _readSort();
else if (!strncmp(token, "AGGREG", length))
- return_value = _readAggreg();
+ return_value = _readAggref();
else if (!strncmp(token, "SUBLINK", length))
return_value = _readSubLink();
else if (!strncmp(token, "AGG", length))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.31 1999/01/23 23:28:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.32 1999/01/24 00:28:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
((Var *) clause)->varno = (Index) OUTER;
((Var *) clause)->varattno = subplanVar->resdom->resno;
}
- else if (IsA(clause, Aggreg))
- replace_result_clause(((Aggreg *) clause)->target, subplanTargetList);
+ else if (IsA(clause, Aggref))
+ replace_result_clause(((Aggref *) clause)->target, subplanTargetList);
else if (is_funcclause(clause))
{
List *subExpr;
* changes the target list of an Agg node so that it points to
* the tuples returned by its left tree subplan.
*
- * We now also generate a linked list of Aggreg pointers for Agg.
+ * We now also generate a linked list of Aggref pointers for Agg.
*
*/
List *
}
return agg_list;
}
- else if (IsA(clause, Aggreg))
+ else if (IsA(clause, Aggref))
{
return lcons(clause,
- replace_agg_clause(((Aggreg *) clause)->target, subplanTargetList));
+ replace_agg_clause(((Aggref *) clause)->target, subplanTargetList));
}
else if (IsA(clause, ArrayRef))
{
foreach(t, ((Expr *) clause)->args)
lfirst(t) = del_agg_clause(lfirst(t));
}
- else if (IsA(clause, Aggreg))
+ else if (IsA(clause, Aggref))
{
/* here is the real action, to remove the Agg node */
- return del_agg_clause(((Aggreg *) clause)->target);
+ return del_agg_clause(((Aggref *) clause)->target);
}
else if (IsA(clause, ArrayRef))
}
return targetlist_so_far;
}
- else if (IsA(clause, Aggreg))
+ else if (IsA(clause, Aggref))
{
targetlist_so_far =
- check_having_qual_for_vars(((Aggreg *) clause)->target, targetlist_so_far);
+ check_having_qual_for_vars(((Aggref *) clause)->target, targetlist_so_far);
return targetlist_so_far;
}
else if (IsA(clause, ArrayRef))
}
return agg_list;
}
- else if (IsA(clause, Aggreg))
+ else if (IsA(clause, Aggref))
{
return lcons(clause,
- check_having_qual_for_aggs(((Aggreg *) clause)->target, subplanTargetList,
+ check_having_qual_for_aggs(((Aggref *) clause)->target, subplanTargetList,
groupClause));
}
else if (IsA(clause, ArrayRef))
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, Aggref))
+ return _finalize_primnode(((Aggref *) expr)->target, subplan);
else if (IsA(expr, ArrayRef))
{
result = _finalize_primnode(((ArrayRef *) expr)->refupperindexpr, subplan);
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, Aggref))
+ ((Aggref *) expr)->target =
+ SS_replace_correlation_vars((Node *) ((Aggref *) expr)->target);
else if (IsA(expr, ArrayRef))
{
((ArrayRef *) expr)->refupperindexpr = (List *)
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, Aggref))
+ return SS_pull_subplan(((Aggref *) expr)->target);
else if (IsA(expr, ArrayRef))
{
result = SS_pull_subplan(((ArrayRef *) expr)->refupperindexpr);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.26 1998/12/04 15:34:14 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.27 1999/01/24 00:28:21 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
agg_clause(Node *clause)
{
return
- (clause != NULL && nodeTag(clause) == T_Aggreg);
+ (clause != NULL && nodeTag(clause) == T_Aggref);
}
/*****************************************************************************
fix_opid((Node *) get_rightop((Expr *) clause));
}
else if (agg_clause(clause))
- fix_opid(((Aggreg *) clause)->target);
+ fix_opid(((Aggref *) clause)->target);
else if (is_subplan(clause) &&
((SubPlan *) ((Expr *) clause)->oper)->sublink->subLinkType != EXISTS_SUBLINK)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.21 1998/12/04 15:34:15 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.22 1999/01/24 00:28:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return ((Node *) make_funcclause((Func *) expr->oper, temp_result));
}
- else if (IsA(tlistentry, Aggreg))
+ else if (IsA(tlistentry, Aggref))
{
return tlistentry;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.14 1998/12/04 15:34:15 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.15 1999/01/24 00:28:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
retval = nconc(retval,
pull_var_clause(lfirst(((Expr *) lfirst(temp))->args)));
}
- else if (IsA(clause, Aggreg))
- retval = pull_var_clause(((Aggreg *) clause)->target);
+ else if (IsA(clause, Aggref))
+ retval = pull_var_clause(((Aggref *) clause)->target);
else if (IsA(clause, ArrayRef))
{
List *temp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.61 1999/01/22 19:35:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.62 1999/01/24 00:28:23 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.15 1998/12/08 06:18:56 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.16 1999/01/24 00:28:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* contain_agg_clause--
- * Recursively find aggreg nodes from a clause.
+ * Recursively find aggref nodes from a clause.
*
* Returns true if any aggregate found.
*/
{
if (clause == NULL)
return FALSE;
- else if (IsA(clause, Aggreg))
+ else if (IsA(clause, Aggref))
return TRUE;
else if (IsA(clause, Iter))
return contain_agg_clause(((Iter *) clause)->iterexpr);
List *gl;
if (expr == NULL || IsA(expr, Const) ||
- IsA(expr, Param) || IsA(expr, Aggreg) ||
+ IsA(expr, Param) || IsA(expr, Aggref) ||
IsA(expr, SubLink)) /* can't handle currently !!! */
return TRUE;
}
}
- if (IsA(expr, Aggreg))
+ if (IsA(expr, Aggref))
return TRUE;
if (IsA(expr, Expr))
}
-Aggreg *
+Aggref *
ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
List *target, int precedence)
{
Oid vartype;
Oid xfn1;
Form_pg_aggregate aggform;
- Aggreg *aggreg;
+ Aggref *aggref;
HeapTuple theAggTuple;
bool usenulls = false;
}
}
- aggreg = makeNode(Aggreg);
- aggreg->aggname = pstrdup(aggname);
- aggreg->basetype = aggform->aggbasetype;
- aggreg->aggtype = fintype;
+ aggref = makeNode(Aggref);
+ aggref->aggname = pstrdup(aggname);
+ aggref->basetype = aggform->aggbasetype;
+ aggref->aggtype = fintype;
- aggreg->target = lfirst(target);
+ aggref->target = lfirst(target);
if (usenulls)
- aggreg->usenulls = true;
+ aggref->usenulls = true;
pstate->p_hasAggs = true;
- return aggreg;
+ return aggref;
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.38 1998/12/13 23:56:43 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.39 1999/01/24 00:28:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
case T_ArrayRef:
type = ((ArrayRef *) expr)->refelemtype;
break;
- case T_Aggreg:
- type = ((Aggreg *) expr)->aggtype;
+ case T_Aggref:
+ type = ((Aggref *) expr)->aggtype;
break;
case T_Param:
type = ((Param *) expr)->paramtype;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.32 1998/12/13 23:56:44 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.33 1999/01/24 00:28:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
switch (nodeTag(expr))
{
- case T_Aggreg:
- return (char *) ((Aggreg *) expr)->aggname;
+ case T_Aggref:
+ return (char *) ((Aggref *) expr)->aggname;
case T_Expr:
if (((Expr *) expr)->opType == FUNC_EXPR)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.14 1998/10/02 16:27:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.15 1999/01/24 00:28:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
sublevels_up);
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggref *agg = (Aggref *) node;
return nodeThisLockWasTriggered(agg->target, varno, attnum,
sublevels_up);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.29 1999/01/21 16:08:48 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.30 1999/01/24 00:28:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
bool *instead_flag);
static bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up);
static bool attribute_used(Node *node, int rt_index, int attno, int sublevels_up);
-static void modifyAggregUplevel(Node *node);
-static void modifyAggregChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up);
-static void modifyAggregDropQual(Node **nodePtr, Node *orignode, Expr *expr);
-static SubLink *modifyAggregMakeSublink(Expr *origexp, Query *parsetree);
-static void modifyAggregQual(Node **nodePtr, Query *parsetree);
+static void modifyAggrefUplevel(Node *node);
+static void modifyAggrefChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up);
+static void modifyAggrefDropQual(Node **nodePtr, Node *orignode, Expr *expr);
+static SubLink *modifyAggrefMakeSublink(Expr *origexp, Query *parsetree);
+static void modifyAggrefQual(Node **nodePtr, Query *parsetree);
static Query *fireRIRrules(Query *parsetree);
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
return rangeTableEntry_used(
(Node *)(agg->target),
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
return attribute_used(
(Node *)(agg->target),
/*
- * modifyAggregUplevel -
+ * modifyAggrefUplevel -
* In the newly created sublink for an aggregate column used in
* the qualification, we must adjust the varlevelsup in all the
* var nodes.
*/
static void
-modifyAggregUplevel(Node *node)
+modifyAggrefUplevel(Node *node)
{
if (node == NULL)
return;
{
TargetEntry *tle = (TargetEntry *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(tle->expr));
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(agg->target));
}
break;
{
Expr *exp = (Expr *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(exp->args));
}
break;
{
Iter *iter = (Iter *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(iter->iterexpr));
}
break;
{
ArrayRef *ref = (ArrayRef *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(ref->refupperindexpr));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(ref->reflowerindexpr));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(ref->refexpr));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(ref->refassgnexpr));
}
break;
List *l;
foreach (l, (List *)node)
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)lfirst(l));
}
break;
{
SubLink *sub = (SubLink *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(sub->lefthand));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(sub->oper));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(sub->subselect));
}
break;
{
Query *qry = (Query *)node;
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(qry->targetList));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(qry->qual));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(qry->havingQual));
- modifyAggregUplevel(
+ modifyAggrefUplevel(
(Node *)(qry->groupClause));
}
break;
default:
- elog(NOTICE, "unknown node tag %d in modifyAggregUplevel()", nodeTag(node));
+ elog(NOTICE, "unknown node tag %d in modifyAggrefUplevel()", nodeTag(node));
elog(NOTICE, "Node is: %s", nodeToString(node));
break;
/*
- * modifyAggregChangeVarnodes -
+ * modifyAggrefChangeVarnodes -
* Change the var nodes in a sublink created for an aggregate column
* used in the qualification that is subject of the aggregate
* function to point to the correct local RTE.
*/
static void
-modifyAggregChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up)
+modifyAggrefChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up)
{
Node *node = *nodePtr;
{
TargetEntry *tle = (TargetEntry *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(tle->expr)),
rt_index,
new_index,
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(agg->target)),
rt_index,
new_index,
{
GroupClause *grp = (GroupClause *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(grp->entry)),
rt_index,
new_index,
{
Expr *exp = (Expr *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(exp->args)),
rt_index,
new_index,
{
Iter *iter = (Iter *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(iter->iterexpr)),
rt_index,
new_index,
{
ArrayRef *ref = (ArrayRef *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(ref->refupperindexpr)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(ref->reflowerindexpr)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(ref->refexpr)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(ref->refassgnexpr)),
rt_index,
new_index,
List *l;
foreach (l, (List *)node)
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&lfirst(l)),
rt_index,
new_index,
{
SubLink *sub = (SubLink *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(sub->lefthand)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(sub->oper)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(sub->subselect)),
rt_index,
new_index,
{
Query *qry = (Query *)node;
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(qry->targetList)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(qry->qual)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(qry->havingQual)),
rt_index,
new_index,
sublevels_up);
- modifyAggregChangeVarnodes(
+ modifyAggrefChangeVarnodes(
(Node **)(&(qry->groupClause)),
rt_index,
new_index,
break;
default:
- elog(NOTICE, "unknown node tag %d in modifyAggregChangeVarnodes()", nodeTag(node));
+ elog(NOTICE, "unknown node tag %d in modifyAggrefChangeVarnodes()", nodeTag(node));
elog(NOTICE, "Node is: %s", nodeToString(node));
break;
/*
- * modifyAggregDropQual -
- * remove the pure aggreg clase from a qualification
+ * modifyAggrefDropQual -
+ * remove the pure aggref clase from a qualification
*/
static void
-modifyAggregDropQual(Node **nodePtr, Node *orignode, Expr *expr)
+modifyAggrefDropQual(Node **nodePtr, Node *orignode, Expr *expr)
{
Node *node = *nodePtr;
case T_Var:
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
- Aggreg *oagg = (Aggreg *)orignode;
+ Aggref *agg = (Aggref *)node;
+ Aggref *oagg = (Aggref *)orignode;
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(agg->target)),
(Node *)(oagg->target),
expr);
*nodePtr = (Node *)ctrue;
}
else
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(this_expr->args)),
(Node *)(orig_expr->args),
expr);
Iter *iter = (Iter *)node;
Iter *oiter = (Iter *)orignode;
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(iter->iterexpr)),
(Node *)(oiter->iterexpr),
expr);
ArrayRef *ref = (ArrayRef *)node;
ArrayRef *oref = (ArrayRef *)orignode;
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(ref->refupperindexpr)),
(Node *)(oref->refupperindexpr),
expr);
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(ref->reflowerindexpr)),
(Node *)(oref->reflowerindexpr),
expr);
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(ref->refexpr)),
(Node *)(oref->refexpr),
expr);
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(ref->refassgnexpr)),
(Node *)(oref->refassgnexpr),
expr);
int li = 0;
foreach (l, (List *)node) {
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(lfirst(l))),
(Node *)nth(li, ol),
expr);
SubLink *sub = (SubLink *)node;
SubLink *osub = (SubLink *)orignode;
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(sub->subselect)),
(Node *)(osub->subselect),
expr);
Query *qry = (Query *)node;
Query *oqry = (Query *)orignode;
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(qry->qual)),
(Node *)(oqry->qual),
expr);
- modifyAggregDropQual(
+ modifyAggrefDropQual(
(Node **)(&(qry->havingQual)),
(Node *)(oqry->havingQual),
expr);
break;
default:
- elog(NOTICE, "unknown node tag %d in modifyAggregDropQual()", nodeTag(node));
+ elog(NOTICE, "unknown node tag %d in modifyAggrefDropQual()", nodeTag(node));
elog(NOTICE, "Node is: %s", nodeToString(node));
break;
/*
- * modifyAggregMakeSublink -
+ * modifyAggrefMakeSublink -
* Create a sublink node for a qualification expression that
* uses an aggregate column of a view
*/
static SubLink *
-modifyAggregMakeSublink(Expr *origexp, Query *parsetree)
+modifyAggrefMakeSublink(Expr *origexp, Query *parsetree)
{
SubLink *sublink;
Query *subquery;
Node *subqual;
RangeTblEntry *rte;
- Aggreg *aggreg;
+ Aggref *aggref;
Var *target;
TargetEntry *tle;
Resdom *resdom;
Expr *exp = copyObject(origexp);
- if (nodeTag(nth(0, exp->args)) == T_Aggreg)
+ if (nodeTag(nth(0, exp->args)) == T_Aggref)
{
- if (nodeTag(nth(1, exp->args)) == T_Aggreg)
+ if (nodeTag(nth(1, exp->args)) == T_Aggref)
elog(ERROR, "rewrite: comparision of 2 aggregate columns not supported");
else
elog(ERROR, "rewrite: aggregate column of view must be at rigth side in qual");
}
- aggreg = (Aggreg *)nth(1, exp->args);
- target = (Var *)(aggreg->target);
+ aggref = (Aggref *)nth(1, exp->args);
+ target = (Var *)(aggref->target);
rte = (RangeTblEntry *)nth(target->varno - 1, parsetree->rtable);
tle = makeNode(TargetEntry);
resdom = makeNode(Resdom);
- aggreg->usenulls = TRUE;
+ aggref->usenulls = TRUE;
resdom->resno = 1;
resdom->restype = ((Oper *)(exp->oper))->opresulttype;
resdom->resjunk = 0;
tle->resdom = resdom;
- tle->expr = (Node *)aggreg;
+ tle->expr = (Node *)aggref;
subqual = copyObject(parsetree->qual);
- modifyAggregDropQual((Node **)&subqual, (Node *)parsetree->qual, origexp);
+ modifyAggrefDropQual((Node **)&subqual, (Node *)parsetree->qual, origexp);
sublink = makeNode(SubLink);
sublink->subLinkType = EXPR_SUBLINK;
subquery->unionClause = NULL;
- modifyAggregUplevel((Node *)sublink);
+ modifyAggrefUplevel((Node *)sublink);
- modifyAggregChangeVarnodes((Node **)&(sublink->lefthand), target->varno,
+ modifyAggrefChangeVarnodes((Node **)&(sublink->lefthand), target->varno,
1, target->varlevelsup);
- modifyAggregChangeVarnodes((Node **)&(sublink->oper), target->varno,
+ modifyAggrefChangeVarnodes((Node **)&(sublink->oper), target->varno,
1, target->varlevelsup);
- modifyAggregChangeVarnodes((Node **)&(sublink->subselect), target->varno,
+ modifyAggrefChangeVarnodes((Node **)&(sublink->subselect), target->varno,
1, target->varlevelsup);
return sublink;
/*
- * modifyAggregQual -
+ * modifyAggrefQual -
* Search for qualification expressions that contain aggregate
* functions and substiture them by sublinks. These expressions
* originally come from qualifications that use aggregate columns
* of a view.
*/
static void
-modifyAggregQual(Node **nodePtr, Query *parsetree)
+modifyAggrefQual(Node **nodePtr, Query *parsetree)
{
Node *node = *nodePtr;
{
GroupClause *grp = (GroupClause *)node;
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(grp->entry)),
parsetree);
}
if (length(exp->args) != 2) {
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(exp->args)),
parsetree);
break;
}
- if (nodeTag(nth(0, exp->args)) != T_Aggreg &&
- nodeTag(nth(1, exp->args)) != T_Aggreg) {
+ if (nodeTag(nth(0, exp->args)) != T_Aggref &&
+ nodeTag(nth(1, exp->args)) != T_Aggref) {
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(exp->args)),
parsetree);
break;
}
- sub = modifyAggregMakeSublink(exp,
+ sub = modifyAggrefMakeSublink(exp,
parsetree);
*nodePtr = (Node *)sub;
/* We're calling recursively,
* and this routine knows how to handle lists
* so let it do the work to handle the WHEN clauses... */
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(((CaseExpr *)node)->args)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(((CaseExpr *)node)->defresult)),
parsetree);
}
case T_CaseWhen:
{
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(((CaseWhen *)node)->expr)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(((CaseWhen *)node)->result)),
parsetree);
}
{
Iter *iter = (Iter *)node;
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(iter->iterexpr)),
parsetree);
}
{
ArrayRef *ref = (ArrayRef *)node;
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(ref->refupperindexpr)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(ref->reflowerindexpr)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(ref->refexpr)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(ref->refassgnexpr)),
parsetree);
}
List *l;
foreach (l, (List *)node)
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(lfirst(l))),
parsetree);
}
{
SubLink *sub = (SubLink *)node;
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(sub->subselect)),
(Query *)(sub->subselect));
}
{
Query *qry = (Query *)node;
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(qry->qual)),
parsetree);
- modifyAggregQual(
+ modifyAggrefQual(
(Node **)(&(qry->havingQual)),
parsetree);
}
break;
default:
- elog(NOTICE, "unknown node tag %d in modifyAggregQual()", nodeTag(node));
+ elog(NOTICE, "unknown node tag %d in modifyAggrefQual()", nodeTag(node));
elog(NOTICE, "Node is: %s", nodeToString(node));
break;
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
apply_RIR_adjust_sublevel(
(Node *)(agg->target),
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
apply_RIR_view(
(Node **)(&(agg->target)),
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
fireRIRonSubselect(
(Node *)(agg->target));
}
fireRIRonSubselect((Node *) parsetree);
- modifyAggregQual((Node **) &(parsetree->qual), parsetree);
+ modifyAggrefQual((Node **) &(parsetree->qual), parsetree);
return parsetree;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.24 1999/01/18 00:09:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.25 1999/01/24 00:28:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
OffsetVarNodes(
(Node *)(agg->target),
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *)node;
+ Aggref *agg = (Aggref *)node;
ChangeVarNodes(
(Node *)(agg->target),
ResolveNew(info, targetlist, &((TargetEntry *) node)->expr,
sublevels_up);
break;
- case T_Aggreg:
- ResolveNew(info, targetlist, &((Aggreg *) node)->target,
+ case T_Aggref:
+ ResolveNew(info, targetlist, &((Aggref *) node)->target,
sublevels_up);
break;
case T_Expr:
sublevels_up);
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggref *agg = (Aggref *) node;
nodeHandleRIRAttributeRule(&agg->target, rtable, targetlist,
rt_index, attr_num, modified, badsql,
rt_index, modified, sublevels_up);
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggref *agg = (Aggref *) node;
nodeHandleViewRule(&(agg->target), rtable, targetlist,
rt_index, modified, sublevels_up);
* out of it's tuple
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.6 1998/10/26 01:01:35 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.7 1999/01/24 00:28:32 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggref *agg = (Aggref *) node;
strcat(buf, "\"");
strcat(buf, agg->aggname);
}
break;
- case T_Aggreg:
+ case T_Aggref:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggref *agg = (Aggref *) node;
return check_if_rte_used(rt_index,
(Node *) (agg->target), sup);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.34 1999/01/21 16:08:53 vadim Exp $
+ * $Id: nodes.h,v 1.35 1999/01/24 00:28:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
T_Oper,
T_Const,
T_Param,
- T_Aggreg,
+ T_Aggref,
T_SubLink,
T_Func,
T_Array,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.23 1998/09/01 04:36:47 momjian Exp $
+ * $Id: primnodes.h,v 1.24 1999/01/24 00:28:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} Func;
/* ----------------
- * Aggreg
+ * Aggref
* aggname - name of the aggregate
* basetype - base type Oid of the aggregate
* aggtype - type Oid of final result of the aggregate
* aggno - index to ecxt_values
* ----------------
*/
-typedef struct Aggreg
+typedef struct Aggref
{
NodeTag type;
char *aggname;
Node *target;
int aggno;
bool usenulls;
-} Aggreg;
+} Aggref;
/* ----------------
* SubLink
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_agg.h,v 1.7 1998/09/01 04:37:29 momjian Exp $
+ * $Id: parse_agg.h,v 1.8 1999/01/24 00:28:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
+extern void AddAggToParseState(ParseState *pstate, Aggref *aggref);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
-extern Aggreg *ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
+extern Aggref *ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
List *target, int precedence);
extern void agg_error(char *caller, char *aggname, Oid basetypeID);
projects / postgresql.git / commitdiff