for (i = 0; i < nagg; i++)
{
AttrNumber attnum;
- int2 attlen;
+ int2 attlen = 0;
Datum newVal = (Datum) NULL;
AggFuncInfo *aggfns = &aggFuncInfo[i];
Datum args[2];
newVal = ExecEvalExpr(aggregates[i]->target, econtext,
&isNull, &isDone);
break;
+ case T_Const:
+ tagnode = NULL;
+ econtext->ecxt_scantuple = outerslot;
+ newVal = ExecEvalExpr(aggregates[i]->target, econtext,
+ &isNull, &isDone);
+ break;
default:
elog(WARN, "ExecAgg: Bad Agg->Target for Agg %d", i);
}
- if (isNull)
+ if (isNull && !aggregates[i]->usenulls)
continue; /* ignore this tuple for this agg */
if (aggfns->xfn1)
{
if (noInitValue[i])
{
- int byVal;
+ int byVal = 0;
/*
* value1 and value2 has not been initialized. This is
* a copy of it since the tuple from which it came
* will be freed on the next iteration of the scan
*/
- if (tagnode != NULL)
- {
- FunctionCachePtr fcache_ptr;
-
- if (nodeTag(tagnode) == T_Func)
- fcache_ptr = ((Func *) tagnode)->func_fcache;
- else
- fcache_ptr = ((Oper *) tagnode)->op_fcache;
- attlen = fcache_ptr->typlen;
- byVal = fcache_ptr->typbyval;
- }
- else
+ switch (nodeTag(aggregates[i]->target))
{
- attnum = ((Var *) aggregates[i]->target)->varattno;
- attlen = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attlen;
- byVal = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attbyval;
+ case T_Var:
+ attnum = ((Var *) aggregates[i]->target)->varattno;
+ attlen = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attlen;
+ byVal = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attbyval;
+
+ break;
+ case T_Expr:
+ {
+ FunctionCachePtr fcache_ptr;
+
+ if (nodeTag(tagnode) == T_Func)
+ fcache_ptr = ((Func *) tagnode)->func_fcache;
+ else
+ fcache_ptr = ((Oper *) tagnode)->op_fcache;
+ attlen = fcache_ptr->typlen;
+ byVal = fcache_ptr->typbyval;
+
+ break;
+ }
+ case T_Const:
+ attlen = ((Const *) aggregates[i]->target)->constlen;
+ byVal = ((Const *) aggregates[i]->target)->constbyval;
+
+ break;
+ default:
+ elog(WARN, "ExecAgg: Bad Agg->Target for Agg %d", i);
}
if (attlen == -1)
{
value1[i] = newVal;
else
memmove((char *) (value1[i]), (char *) newVal, attlen);
- /* value1[i] = newVal; */
noInitValue[i] = 0;
nulls[i] = 0;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.26 1997/12/24 06:05:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.27 1998/01/04 04:31:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
newnode->aggname = pstrdup(from->aggname);
newnode->basetype = from->basetype;
newnode->aggtype = from->aggtype;
+ newnode->usenulls = from->usenulls;
Node_Copy(from, newnode, target);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.82 1998/01/01 05:44:53 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.83 1998/01/04 04:31:08 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*
* ...however, recursive addattr and rename supported. make special
* cases for these.
- *
- * XXX i believe '*' should be the default behavior, but...
*/
opt_inh_star: '*' { $$ = TRUE; }
| /*EMPTY*/ { $$ = FALSE; }
}
| name '(' '*' ')'
{
+ /* cheap hack for aggregate (eg. count) */
FuncCall *n = makeNode(FuncCall);
- Ident *star = makeNode(Ident);
+ A_Const *star = makeNode(A_Const);
- /* cheap hack for aggregate (eg. count) */
- star->name = "oid";
+ star->val.type = T_String;
+ star->val.val.str = "";
n->funcname = $1;
n->args = lcons(star, NIL);
$$ = (Node *)n;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.4 1997/12/22 05:42:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.5 1998/01/04 04:31:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
#include "catalog/pg_aggregate.h"
+#include "catalog/pg_type.h"
#include "nodes/nodeFuncs.h"
#include "nodes/primnodes.h"
#include "nodes/relation.h"
#include "optimizer/clauses.h"
#include "parser/parse_agg.h"
+#include "parser/parse_expr.h"
#include "parser/parse_node.h"
#include "parser/parse_target.h"
#include "utils/syscache.h"
+#include "utils/lsyscache.h"
static bool contain_agg_clause(Node *clause);
static bool exprIsAggOrGroupCol(Node *expr, List *groupClause);
Aggreg *
-ParseAgg(char *aggname, Oid basetype, Node *target)
+ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
+ List *target, int precedence)
{
Oid fintype;
Oid vartype;
Form_pg_aggregate aggform;
Aggreg *aggreg;
HeapTuple theAggTuple;
-
+ bool usenulls = false;
+
theAggTuple = SearchSysCacheTuple(AGGNAME, PointerGetDatum(aggname),
ObjectIdGetDatum(basetype),
0, 0);
elog(WARN, "aggregate %s does not exist", aggname);
}
+ /*
+ * We do a major hack for count(*) here.
+ *
+ * Count(*) poses several problems. First, we need a field that is
+ * guaranteed to be in the range table, and unique. Using a constant
+ * causes the optimizer to properly remove the aggragate from any
+ * elements of the query.
+ * Using just 'oid', which can not be null, in the parser fails on:
+ *
+ * select count(*) from tab1, tab2 -- oid is not unique
+ * select count(*) from viewtable -- views don't have real oids
+ *
+ * So, for an aggregate with parameter '*', we use the first valid
+ * range table entry, and pick the first column from the table.
+ * We set a flag to count nulls, because we could have nulls in
+ * that column.
+ */
+
+ if (nodeTag(lfirst(target)) == T_Const)
+ {
+ Const *con = (Const *)lfirst(target);
+
+ if (con->consttype == UNKNOWNOID && VARSIZE(con->constvalue) == VARHDRSZ)
+ {
+ Attr *attr = makeNode(Attr);
+ List *rtable, *rlist;
+ RangeTblEntry *first_valid_rte;
+
+ Assert(lnext(target) == NULL);
+
+ if (pstate->p_is_rule)
+ rtable = lnext(lnext(pstate->p_rtable));
+ else
+ rtable = pstate->p_rtable;
+
+ first_valid_rte = NULL;
+ foreach(rlist, rtable)
+ {
+ RangeTblEntry *rte = lfirst(rlist);
+
+ /* only entries on outer(non-function?) scope */
+ if (!rte->inFromCl && rte != pstate->p_target_rangetblentry)
+ continue;
+
+ first_valid_rte =rte;
+ break;
+ }
+ if (first_valid_rte == NULL)
+ elog(WARN, "Can't find column to do aggregate(*) on.");
+
+ attr->relname = first_valid_rte->refname;
+ attr->attrs = lcons(makeString(
+ get_attname(first_valid_rte->relid,1)),NIL);
+
+ lfirst(target) = transformExpr(pstate, (Node *) attr, precedence);
+ usenulls = true;
+ }
+ }
+
aggform = (Form_pg_aggregate) GETSTRUCT(theAggTuple);
fintype = aggform->aggfinaltype;
xfn1 = aggform->aggtransfn1;
- if (nodeTag(target) != T_Var && nodeTag(target) != T_Expr)
- elog(WARN, "parser: aggregate can only be applied on an attribute or expression");
-
+
/* only aggregates with transfn1 need a base type */
if (OidIsValid(xfn1))
{
basetype = aggform->aggbasetype;
- if (nodeTag(target) == T_Var)
- vartype = ((Var *) target)->vartype;
+ if (nodeTag(lfirst(target)) == T_Var)
+ vartype = ((Var *) lfirst(target))->vartype;
else
- vartype = ((Expr *) target)->typeOid;
+ vartype = ((Expr *) lfirst(target))->typeOid;
if (basetype != vartype)
{
aggreg->basetype = aggform->aggbasetype;
aggreg->aggtype = fintype;
- aggreg->target = target;
+ aggreg->target = lfirst(target);
+ if (usenulls)
+ aggreg->usenulls = true;
return aggreg;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.3 1997/11/26 03:42:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.4 1998/01/04 04:31:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
Node *
-ParseFunc(ParseState *pstate, char *funcname, List *fargs, int *curr_resno)
+ParseFunc(ParseState *pstate, char *funcname, List *fargs,
+ int *curr_resno, int precedence)
{
Oid rettype = (Oid) 0;
Oid argrelid = (Oid) 0;
*/
if ((get_attnum(argrelid, funcname) == InvalidAttrNumber)
&& strcmp(funcname, "*"))
- {
elog(WARN, "Functions on sets are not yet supported");
- }
}
if (retval)
ObjectIdGetDatum(basetype),
0, 0))
{
- Aggreg *aggreg = ParseAgg(funcname, basetype, lfirst(fargs));
+ Aggreg *aggreg = ParseAgg(pstate, funcname, basetype,
+ fargs, precedence);
AddAggToParseState(pstate, aggreg);
return (Node *) aggreg;
else
{
funcnode->func_tlist = setup_tlist(funcname, argrelid);
- rettype = attnameTypeId(argrelid, funcname);
+ rettype = get_atttype(argrelid, get_attnum(argrelid, funcname));
}
}
if (attno < 0)
elog(WARN, "cannot reference attribute '%s' of tuple params/return values for functions", attname);
- typeid = attnameTypeId(relid, attname);
+ typeid = get_atttype(relid, attno);
resnode = makeResdom(1,
typeid,
typeLen(typeidType(typeid)),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.3 1997/11/26 03:42:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.4 1998/01/04 04:31:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (rd->rd_att->attrs[attid - 1]->attnelems);
}
-Oid
-attnameTypeId(Oid relid, char *attrname)
-{
- int attid;
- Oid vartype;
- Relation rd;
-
- rd = heap_open(relid);
- if (!RelationIsValid(rd))
- {
- rd = heap_openr(typeidTypeName(relid));
- if (!RelationIsValid(rd))
- elog(WARN, "cannot compute type of att %s for relid %d",
- attrname, relid);
- }
-
- attid = attnameAttNum(rd, attrname); /* could elog(WARN) and never return */
-
- vartype = attnumTypeId(rd, attid);
-
- /*
- * close relation we're done with it now
- */
- heap_close(rd);
-
- return (vartype);
-}
-
/* given attribute id, return type of that attribute */
/* XXX Special case for pseudo-attributes is a hack */
Oid
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.3 1997/11/26 03:42:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.4 1998/01/04 04:31:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Target item is fully specified: ie.
* relation.attribute
*/
- result = handleNestedDots(pstate, att, &pstate->p_last_resno);
+ result = handleNestedDots(pstate, att, &pstate->p_last_resno,EXPR_COLUMN_FIRST);
handleTargetColname(pstate, &res->name, att->relname, attrname);
if (att->indirection != NIL)
{
att->relname = pstrdup(RelationGetRelationName(rd)->data);
att->attrs = lcons(makeString(colname), NIL);
target_expr = (Expr *) handleNestedDots(pstate, att,
- &pstate->p_last_resno);
+ &pstate->p_last_resno,
+ EXPR_COLUMN_FIRST);
while (ar != NIL)
{
A_Indices *ind = lfirst(ar);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.5 1997/09/08 21:46:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.6 1998/01/04 04:31:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
nodeThisLockWasTriggered(tle->expr, varno, attnum);
}
break;
+ case T_Aggreg:
+ {
+ Aggreg *agg = (Aggreg *) node;
+
+ return
+ nodeThisLockWasTriggered(agg->target, varno, attnum);
+ }
+ break;
case T_List:
{
List *l;
AttrNumber attnum,
Query *parsetree)
{
- return
- (nodeThisLockWasTriggered(parsetree->qual, varno, attnum) ||
- nodeThisLockWasTriggered((Node *) parsetree->targetList,
- varno, attnum));
+ int i;
+
+ if (nodeThisLockWasTriggered(parsetree->qual, varno, attnum))
+ return true;
+
+ if (nodeThisLockWasTriggered((Node *) parsetree->targetList, varno, attnum))
+ return true;
+
+ for(i=0; i < parsetree->qry_numAgg; i++)
+ if (nodeThisLockWasTriggered(parsetree->qry_aggs[i]->target,
+ varno, attnum))
+ return true;
+ return false;
+
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.6 1997/09/08 21:46:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.7 1998/01/04 04:31:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
*instead_flag = TRUE;
FixResdomTypes(parsetree->targetList);
+
return lcons(parsetree, NIL);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.8 1997/09/18 20:21:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.9 1998/01/04 04:31:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
OffsetVarNodes(tle->expr, offset);
}
break;
+ case T_Aggreg:
+ {
+ Aggreg *agg = (Aggreg *) node;
+
+ OffsetVarNodes(agg->target, offset);
+ }
+ break;
case T_Expr:
{
Expr *expr = (Expr *) node;
ChangeVarNodes(tle->expr, old_varno, new_varno);
}
break;
+ case T_Aggreg:
+ {
+ Aggreg *agg = (Aggreg *) node;
+
+ ChangeVarNodes(agg->target, old_varno, new_varno);
+ }
+ break;
case T_Expr:
{
Expr *expr = (Expr *) node;
case T_TargetEntry:
ResolveNew(info, targetlist, &((TargetEntry *) node)->expr);
break;
+ case T_Aggreg:
+ ResolveNew(info, targetlist, &((Aggreg *) node)->target);
+ break;
case T_Expr:
ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)));
break;
rt_index, attr_num, modified, badsql);
}
break;
+ case T_Aggreg:
+ {
+ Aggreg *agg = (Aggreg *) node;
+
+ nodeHandleRIRAttributeRule(&agg->target, rtable, targetlist,
+ rt_index, attr_num, modified, badsql);
+ }
+ break;
case T_Expr:
{
Expr *expr = (Expr *) node;
int *modified,
int *badsql)
{
+ int i;
+
nodeHandleRIRAttributeRule((Node **) (&(parsetree->targetList)), rtable,
targetlist, rt_index, attr_num,
modified, badsql);
nodeHandleRIRAttributeRule(&parsetree->qual, rtable, targetlist,
rt_index, attr_num, modified, badsql);
+ for(i=0; i < parsetree->qry_numAgg; i++)
+ nodeHandleRIRAttributeRule(&parsetree->qry_aggs[i]->target, rtable,
+ targetlist, rt_index, attr_num, modified, badsql);
}
rt_index, modified);
}
break;
+ case T_Aggreg:
+ {
+ Aggreg *agg = (Aggreg *) node;
+
+ nodeHandleViewRule(&(agg->target), rtable, targetlist,
+ rt_index, modified);
+ }
+ break;
case T_Expr:
{
Expr *expr = (Expr *) node;
int rt_index,
int *modified)
{
+ int i;
+
nodeHandleViewRule(&parsetree->qual, rtable, targetlist, rt_index,
modified);
nodeHandleViewRule((Node **) (&(parsetree->targetList)), rtable, targetlist,
rt_index, modified);
+ for(i=0; i < parsetree->qry_numAgg; i++)
+ nodeHandleViewRule(&parsetree->qry_aggs[i]->target, rtable, targetlist, rt_index,
+ modified);
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.11 1997/09/08 21:52:58 momjian Exp $
+ * $Id: primnodes.h,v 1.12 1998/01/04 04:31:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* aggname - name of the aggregate
* basetype - base type Oid of the aggregate
* aggtype - type Oid of final result of the aggregate
- * query - XXX comment me
- * target - XXX comment me
+ * target - attribute or expression we are aggregating on
+ * aggno - index to ecxt_values
* ----------------
*/
typedef struct Aggreg
{
NodeTag type;
char *aggname;
- Oid basetype; /* base type of the aggregate */
- Oid aggtype; /* type of final result */
- Node *target; /* attribute to aggreg on */
- int aggno; /* index to ecxt_values */
+ Oid basetype;
+ Oid aggtype;
+ Node *target;
+ int aggno;
+ bool usenulls;
} Aggreg;
/* ----------------
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_agg.h,v 1.3 1997/11/26 03:43:08 momjian Exp $
+ * $Id: parse_agg.h,v 1.4 1998/01/04 04:31:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
extern void finalizeAggregates(ParseState *pstate, Query *qry);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
-extern Aggreg *ParseAgg(char *aggname, Oid basetype, Node *target);
+extern Aggreg *ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
+ List *target, int precedence);
extern void agg_error(char *caller, char *aggname, Oid basetypeID);
#endif /* PARSE_AGG_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.3 1997/11/26 03:43:11 momjian Exp $
+ * $Id: parse_expr.h,v 1.4 1998/01/04 04:31:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *transformExpr(ParseState *pstate, Node *expr, int precedence);
extern Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
extern Oid exprType(Node *expr);
-extern Node *handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno);
+extern Node *handleNestedDots(ParseState *pstate, Attr *attr,
+ int *curr_resno, int precedence);
extern Node *parser_typecast2(Node *expr, Oid exprType, Type tp, int typlen);
#endif /* PARSE_EXPR_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_func.h,v 1.3 1997/11/26 03:43:12 momjian Exp $
+ * $Id: parse_func.h,v 1.4 1998/01/04 04:31:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} *CandidateList;
extern Node *ParseFunc(ParseState *pstate, char *funcname, List *fargs,
- int *curr_resno);
+ int *curr_resno, int precedence);
extern void func_error(char *caller, char *funcname, int nargs, Oid *argtypes);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_relation.h,v 1.3 1997/11/26 03:43:16 momjian Exp $
+ * $Id: parse_relation.h,v 1.4 1998/01/04 04:31:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool attnameIsSet(Relation rd, char *name);
extern char *attnumAttName(Relation rd, int attrno);
extern int attnumAttNelems(Relation rd, int attid);
-extern Oid attnameTypeId(Oid relid, char *attrname);
extern Oid attnumTypeId(Relation rd, int attid);
extern void handleTargetColname(ParseState *pstate, char **resname,
char *refname, char *colname);
projects / postgresql.git / commitdiff