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 */
61110 ** Memory cell pMem contains the context of an aggregate function.
61112 ** result of the aggregate is stored back into pMem.
66873 ** Allocate or return the aggregate context for a user function. A new
66962 ** Return the number of times the Step function of a aggregate has been
66966 ** provide only to avoid breaking legacy code. New aggregate function
66967 ** implementations should keep their own counts within their aggregate
69489 ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
69494 ** max() aggregate will set to 1 if the current row is not the minimum or
73657 ** Execute the step function for an aggregate. The
73720 ** Execute the finalizer function for an aggregate. P1 is
73721 ** the memory location that is the accumulator for the aggregate.
76809 ** Walk the expression tree pExpr and increase the aggregate function
77210 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
77385 ** function names. The operator for aggregate functions is changed
77466 int is_agg = 0; /* True if is an aggregate function */
77526 sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
78006 /* If there are no aggregate functions in the result-set, and no GROUP BY
78055 ** the GROUP BY clause does not contain aggregate functions.
78065 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
78091 ** checking on function usage and set a flag if any aggregate functions
78128 ** If the function is an aggregate function, then the NC_HasAgg flag is
78130 ** If an expression contains aggregate functions then the EP_Agg
79697 return 0; /* No DISTINCT keyword and no aggregate functions */
80985 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
82278 ** aggregate function, in order to implement the
82382 ** clause of the aggregate query */
82390 ** that is in the FROM clause of the aggregate query.
82450 /* Check to see if pExpr is a duplicate of another aggregate
82501 ** Analyze the pExpr expression looking for aggregate functions and
91720 ** iteration of the aggregate loop.
91727 ** Implementation of the non-aggregate min() and max() functions
93044 ** sum() or avg() aggregate computation.
93115 ** count() aggregate function.
93123 ** Routines to implement the count() aggregate function.
93148 ** Routines to implement min() and max() aggregate functions.
93170 ** comparison is inverted. For the max() aggregate, the
93174 ** aggregate, or 0 for min().
93355 AGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize ),
93358 AGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize ),
93405 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ),
93406 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ),
93407 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ),
93408 /* AGGREGATE(count, 0, 0, 0, countStep, countFinalize ), */
93410 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ),
93411 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize),
93412 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize),
99384 ** used to limit the aggregate size of all memory mapped regions of the
104547 ** (2) The subquery is not an aggregate or the outer query is not a join.
104587 ** (16) The outer query is not an aggregate or the subquery does
104592 ** compound clause made up entirely of non-aggregate queries, and
104596 ** * is not an aggregate or DISTINCT query, and
104650 int isAgg, /* True if outer SELECT uses aggregate functions */
104651 int subqueryIsAgg /* True if the subquery uses aggregate functions */
104748 ** that make up the compound SELECT are allowed to be aggregate or distinct
105030 ** * the query contains just a single aggregate function,
105031 ** * the aggregate function is either min() or max(), and
105032 ** * the argument to the aggregate function is a column value.
105036 ** list of arguments passed to the aggregate before returning.
105046 Expr *pExpr = pAggInfo->aFunc[0].pExpr; /* Aggregate function */
105067 ** The select statement passed as the first argument is an aggregate query.
105068 ** The second argment is the associated aggregate-info object. This
105814 ** Reset the aggregate accumulator.
105816 ** The aggregate accumulator is a set of memory cells that hold
105817 ** intermediate results while calculating an aggregate. This
105859 ** Invoke the OP_AggFinalize opcode for every aggregate function
105875 ** Update the accumulator memory cells for an aggregate based on
106011 AggInfo sAggInfo; /* Information used by aggregate queries */
106186 /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
106264 /* No aggregate functions and no GROUP BY clause */
106301 /* This case when there exist aggregate functions or a GROUP BY clause
106303 NameContext sNC; /* Name context for processing aggregate information */
106401 /* Initialize memory locations used by GROUP BY aggregate processing
106539 ** and resets the aggregate accumulator registers in preparation
106550 /* Update the aggregate accumulators based on the content of
106607 } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
106715 /* This case runs if the aggregate has no GROUP BY clause. The
106744 } /* endif aggregate query */
143449 const char *a; /* Aggregate column length array */
