Lines Matching defs:AGGREGATE
4118 ** aggregate takes. ^If this parameter is -1, then the SQL function or
4119 ** aggregate may take any number of arguments between 0 and the limit
4150 ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
4152 ** parameters. ^An aggregate SQL function requires an implementation of xStep
4154 ** SQL function or aggregate, pass NULL pointers for all three function
4267 ** the function or aggregate.
4321 ** CAPI3REF: Obtain Aggregate Function Context
4323 ** Implementations of aggregate SQL functions use this
4327 ** for a particular aggregate function, SQLite
4330 ** sqlite3_aggregate_context() for the same aggregate function instance,
4334 ** an aggregate query, the xStep() callback of the aggregate function
4346 ** the same aggregate function instance will not resize the memory
4352 ** sqlite3_aggregate_context() when the aggregate query concludes.
4356 ** to the xStep or xFinal callback routine that implements the aggregate
4360 ** the aggregate SQL function is running.
4392 ** These functions may be used by (non-aggregate) SQL functions to
8763 ** implementation of an SQL aggregate step callback may not use the
8764 ** parameter indicating the number of arguments passed to the aggregate,
10645 void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
10646 void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
10684 #define SQLITE_FUNC_COUNT 0x100 /* Built-in count(*) aggregate */
10690 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
10703 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
10704 ** Used to create an aggregate function definition implemented by
10732 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
11228 ** code for a SELECT that contains aggregate functions.
11260 ** aggregate functions */
11261 struct AggInfo_func { /* For each aggregate function */
11263 FuncDef *pFunc; /* The aggregate function implementation */
11316 ** expression is used as a result in an aggregate SELECT, then the
11317 ** value is also stored in the Expr.iAgg column in the aggregate so that
11397 #define EP_Agg 0x000002 /* Contains one or more aggregate functions */
11400 #define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */
11663 #define NC_AllowAgg 0x01 /* Aggregate functions are allowed here */
11664 #define NC_HasAgg 0x02 /* One or more aggregate functions seen */
11714 #define SF_Aggregate 0x0004 /* Contains aggregate functions */
14129 Mem *pMem; /* Memory cell used to store aggregate context */
61090 ** Memory cell pMem contains the context of an aggregate function.
61092 ** result of the aggregate is stored back into pMem.
66853 ** Allocate or return the aggregate context for a user function. A new
66942 ** Return the number of times the Step function of a aggregate has been
66946 ** provide only to avoid breaking legacy code. New aggregate function
66947 ** implementations should keep their own counts within their aggregate
69469 ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
69474 ** max() aggregate will set to 1 if the current row is not the minimum or
73637 ** Execute the step function for an aggregate. The
73700 ** Execute the finalizer function for an aggregate. P1 is
73701 ** the memory location that is the accumulator for the aggregate.
76789 ** Walk the expression tree pExpr and increase the aggregate function
77190 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
77365 ** function names. The operator for aggregate functions is changed
77446 int is_agg = 0; /* True if is an aggregate function */
77506 sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
77986 /* If there are no aggregate functions in the result-set, and no GROUP BY
78035 ** the GROUP BY clause does not contain aggregate functions.
78045 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
78071 ** checking on function usage and set a flag if any aggregate functions
78108 ** If the function is an aggregate function, then the NC_HasAgg flag is
78110 ** If an expression contains aggregate functions then the EP_Agg
79677 return 0; /* No DISTINCT keyword and no aggregate functions */
80965 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
82258 ** aggregate function, in order to implement the
82362 ** clause of the aggregate query */
82370 ** that is in the FROM clause of the aggregate query.
82430 /* Check to see if pExpr is a duplicate of another aggregate
82481 ** Analyze the pExpr expression looking for aggregate functions and
91700 ** iteration of the aggregate loop.
91707 ** Implementation of the non-aggregate min() and max() functions
93024 ** sum() or avg() aggregate computation.
93095 ** count() aggregate function.
93103 ** Routines to implement the count() aggregate function.
93128 ** Routines to implement min() and max() aggregate functions.
93150 ** comparison is inverted. For the max() aggregate, the
93154 ** aggregate, or 0 for min().
93335 AGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize ),
93338 AGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize ),
93385 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ),
93386 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ),
93387 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ),
93388 /* AGGREGATE(count, 0, 0, 0, countStep, countFinalize ), */
93390 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ),
93391 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize),
93392 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize),
99364 ** used to limit the aggregate size of all memory mapped regions of the
104527 ** (2) The subquery is not an aggregate or the outer query is not a join.
104567 ** (16) The outer query is not an aggregate or the subquery does
104572 ** compound clause made up entirely of non-aggregate queries, and
104576 ** * is not an aggregate or DISTINCT query, and
104630 int isAgg, /* True if outer SELECT uses aggregate functions */
104631 int subqueryIsAgg /* True if the subquery uses aggregate functions */
104728 ** that make up the compound SELECT are allowed to be aggregate or distinct
105010 ** * the query contains just a single aggregate function,
105011 ** * the aggregate function is either min() or max(), and
105012 ** * the argument to the aggregate function is a column value.
105016 ** list of arguments passed to the aggregate before returning.
105026 Expr *pExpr = pAggInfo->aFunc[0].pExpr; /* Aggregate function */
105047 ** The select statement passed as the first argument is an aggregate query.
105048 ** The second argment is the associated aggregate-info object. This
105794 ** Reset the aggregate accumulator.
105796 ** The aggregate accumulator is a set of memory cells that hold
105797 ** intermediate results while calculating an aggregate. This
105839 ** Invoke the OP_AggFinalize opcode for every aggregate function
105855 ** Update the accumulator memory cells for an aggregate based on
105991 aggregate queries */
106166 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
106244 /* No aggregate functions and no GROUP BY clause */
106281 /* This case when there exist aggregate functions or a GROUP BY clause
106283 NameContext sNC; /* Name context for processing aggregate information */
106381 /* Initialize memory locations used by GROUP BY aggregate processing
106519 ** and resets the aggregate accumulator registers in preparation
106530 /* Update the aggregate accumulators based on the content of
106587 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
106695 /* This case runs if the aggregate has no GROUP BY clause. The
106724 } /* endif aggregate query */
143417 const char *a; /* Aggregate column length array */
