Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Aggregate functions also use sqlite_value* instead of const char * for arguments. (CVS 1451) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
5c28ed5e9b5a3ecb3081ce0c5c9450d6 |
User & Date: | danielk1977 2004-05-24 23:48:26.000 |
Context
2004-05-25
| ||
01:13 | Add manifest type aware versions of the min() and max() aggregates. (CVS 1452) (check-in: b77c268ebe user: danielk1977 tags: trunk) | |
2004-05-24
| ||
23:48 | Aggregate functions also use sqlite_value* instead of const char * for arguments. (CVS 1451) (check-in: 5c28ed5e9b user: danielk1977 tags: trunk) | |
12:55 | Update the typeof() operator to respect manifest types. (CVS 1450) (check-in: 162cf42e33 user: danielk1977 tags: trunk) | |
Changes
Changes to src/func.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** | | | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: func.c,v 1.52 2004/05/24 23:48:26 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "os.h" |
︙ | ︙ | |||
440 441 442 443 444 445 446 | double sum; /* Sum of terms */ int cnt; /* Number of elements summed */ }; /* ** Routines used to compute the sum or average. */ | | | | | 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 | double sum; /* Sum of terms */ int cnt; /* Number of elements summed */ }; /* ** Routines used to compute the sum or average. */ static void sumStep(sqlite_func *context, int argc, sqlite3_value **argv){ SumCtx *p; if( argc<1 ) return; p = sqlite3_aggregate_context(context, sizeof(*p)); if( p && SQLITE3_NULL!=sqlite3_value_type(argv[0]) ){ p->sum += sqlite3_value_float(argv[0]); p->cnt++; } } static void sumFinalize(sqlite_func *context){ SumCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); sqlite3_set_result_double(context, p ? p->sum : 0.0); |
︙ | ︙ | |||
512 513 514 515 516 517 518 | struct CountCtx { int n; }; /* ** Routines to implement the count() aggregate function. */ | | | | 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 | struct CountCtx { int n; }; /* ** Routines to implement the count() aggregate function. */ static void countStep(sqlite_func *context, int argc, sqlite3_value **argv){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0])) && p ){ p->n++; } } static void countFinalize(sqlite_func *context){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); sqlite3_set_result_int(context, p ? p->n : 0); |
︙ | ︙ | |||
538 539 540 541 542 543 544 | char *z; /* The best so far */ char zBuf[28]; /* Space that can be used for storage */ }; /* ** Routines to implement min() and max() aggregate functions. */ | | > > | | | | | | 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 | char *z; /* The best so far */ char zBuf[28]; /* Space that can be used for storage */ }; /* ** Routines to implement min() and max() aggregate functions. */ static void minmaxStep(sqlite_func *context, int argc, sqlite3_value **argv){ MinMaxCtx *p; int (*xCompare)(const char*, const char*); int mask; /* 0 for min() or 0xffffffff for max() */ const char *zArg0 = sqlite3_value_data(argv[0]); const char *zArg1 = sqlite3_value_data(argv[1]); assert( argc==2 ); if( zArg1[0]=='n' ){ xCompare = sqlite3Compare; }else{ xCompare = strcmp; } mask = (int)sqlite3_user_data(context); p = sqlite3_aggregate_context(context, sizeof(*p)); if( p==0 || argc<1 || zArg0==0 ) return; if( p->z==0 || (xCompare(zArg0,p->z)^mask)<0 ){ int len; if( !p->zBuf[0] ){ sqliteFree(p->z); } len = strlen(zArg0); if( len < sizeof(p->zBuf)-1 ){ p->z = &p->zBuf[1]; p->zBuf[0] = 1; }else{ p->z = sqliteMalloc( len+1 ); p->zBuf[0] = 0; if( p->z==0 ) return; } strcpy(p->z, zArg0); } } static void minMaxFinalize(sqlite_func *context){ MinMaxCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); if( p && p->z ){ sqlite3_set_result_string(context, p->z, strlen(p->z)); |
︙ | ︙ | |||
632 633 634 635 636 637 638 | #endif }; static struct { char *zName; signed char nArg; signed char dataType; u8 argType; | | | 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 | #endif }; static struct { char *zName; signed char nArg; signed char dataType; u8 argType; void (*xStep)(sqlite_func*,int,sqlite3_value**); void (*xFinalize)(sqlite_func*); } aAggs[] = { { "min", 1, 0, 0, minmaxStep, minMaxFinalize }, { "max", 1, 0, 2, minmaxStep, minMaxFinalize }, { "sum", 1, SQLITE_NUMERIC, 0, sumStep, sumFinalize }, { "avg", 1, SQLITE_NUMERIC, 0, sumStep, avgFinalize }, { "count", 0, SQLITE_NUMERIC, 0, countStep, countFinalize }, |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.187 2004/05/24 23:48:26 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
878 879 880 881 882 883 884 | p->pUserData = pUserData; return 0; } int sqlite3_create_aggregate( sqlite *db, /* Add the function to this database connection */ const char *zName, /* Name of the function to add */ int nArg, /* Number of arguments */ | | | 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 | p->pUserData = pUserData; return 0; } int sqlite3_create_aggregate( sqlite *db, /* Add the function to this database connection */ const char *zName, /* Name of the function to add */ int nArg, /* Number of arguments */ void (*xStep)(sqlite_func*,int,sqlite3_value**), /* The step function */ void (*xFinalize)(sqlite_func*), /* The finalizer */ void *pUserData /* User data */ ){ FuncDef *p; int nName; if( db==0 || zName==0 || sqlite3SafetyCheck(db) ) return 1; if( nArg<-1 || nArg>127 ) return 1; |
︙ | ︙ |
Changes to src/md5.c.
︙ | ︙ | |||
352 353 354 355 356 357 358 | return TCL_OK; } /* ** During testing, the special md5sum() aggregate function is available. ** inside SQLite. The following routines implement that function. */ | | > | | | 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 | return TCL_OK; } /* ** During testing, the special md5sum() aggregate function is available. ** inside SQLite. The following routines implement that function. */ static void md5step(sqlite_func *context, int argc, sqlite3_value **argv){ MD5Context *p; int i; if( argc<1 ) return; p = sqlite3_aggregate_context(context, sizeof(*p)); if( p==0 ) return; if( sqlite3_aggregate_count(context)==1 ){ MD5Init(p); } for(i=0; i<argc; i++){ const char *zData = sqlite3_value_data(argv[i]); if( zData ){ MD5Update(p, zData, strlen(zData)); } } } static void md5finalize(sqlite_func *context){ MD5Context *p; unsigned char digest[16]; char zBuf[33]; |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** ** @(#) $Id: sqlite.h.in,v 1.74 2004/05/24 23:48:27 danielk1977 Exp $ */ #ifndef _SQLITE_H_ #define _SQLITE_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
435 436 437 438 439 440 441 | void (*xFunc)(sqlite_func*,int,sqlite3_value **), /* C code to implement */ void *pUserData /* Available via the sqlite3_user_data() call */ ); int sqlite3_create_aggregate( sqlite*, /* Database where the new function is registered */ const char *zName, /* Name of the function */ int nArg, /* Number of arguments */ | | | 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 | void (*xFunc)(sqlite_func*,int,sqlite3_value **), /* C code to implement */ void *pUserData /* Available via the sqlite3_user_data() call */ ); int sqlite3_create_aggregate( sqlite*, /* Database where the new function is registered */ const char *zName, /* Name of the function */ int nArg, /* Number of arguments */ void (*xStep)(sqlite_func*,int,sqlite3_value**), /* Called for each row */ void (*xFinalize)(sqlite_func*), /* Called once to get final result */ void *pUserData /* Available via the sqlite3_user_data() call */ ); /* ** Use the following routine to define the datatype returned by a ** user-defined function. The second argument can be one of the |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.250 2004/05/24 23:48:27 danielk1977 Exp $ */ #include "config.h" #include "sqlite.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> |
︙ | ︙ | |||
461 462 463 464 465 466 467 | ** Each SQL function is defined by an instance of the following ** structure. A pointer to this structure is stored in the sqlite.aFunc ** hash table. When multiple functions have the same name, the hash table ** points to a linked list of these structures. */ struct FuncDef { void (*xFunc)(sqlite_func*,int,sqlite3_value**); /* Regular function */ | | | 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 | ** Each SQL function is defined by an instance of the following ** structure. A pointer to this structure is stored in the sqlite.aFunc ** hash table. When multiple functions have the same name, the hash table ** points to a linked list of these structures. */ struct FuncDef { void (*xFunc)(sqlite_func*,int,sqlite3_value**); /* Regular function */ void (*xStep)(sqlite_func*,int,sqlite3_value**); /* Aggregate function step */ void (*xFinalize)(sqlite_func*); /* Aggregate function finializer */ signed char nArg; /* Number of arguments. -1 means unlimited */ signed char dataType; /* Arg that determines datatype. -1=NUMERIC, */ /* -2=TEXT. -3=SQLITE_ARGS */ u8 includeTypes; /* Add datatypes to args of xFunc and xStep */ void *pUserData; /* User data parameter */ FuncDef *pNext; /* Next function with same name */ |
︙ | ︙ |
Changes to src/test1.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the printf() interface to SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the printf() interface to SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** ** $Id: test1.c,v 1.49 2004/05/24 23:48:27 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include "os.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
427 428 429 430 431 432 433 | /* ** Routines to implement the x_count() aggregate function. */ typedef struct CountCtx CountCtx; struct CountCtx { int n; }; | | | | 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 | /* ** Routines to implement the x_count() aggregate function. */ typedef struct CountCtx CountCtx; struct CountCtx { int n; }; static void countStep(sqlite_func *context, int argc, sqlite3_value **argv){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0]) ) && p ){ p->n++; } } static void countFinalize(sqlite_func *context){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); sqlite3_set_result_int(context, p ? p->n : 0); |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
39 40 41 42 43 44 45 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** ** $Id: vdbe.c,v 1.327 2004/05/24 23:48:27 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
2002 2003 2004 2005 2006 2007 2008 | /* Opcode: Callback P1 * * ** ** Pop P1 values off the stack and form them into an array. Then ** invoke the callback function using the newly formed array as the ** 3rd parameter. */ case OP_Callback: { | < < < < < < < < < < < < < < < < < < < < | 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 | /* Opcode: Callback P1 * * ** ** Pop P1 values off the stack and form them into an array. Then ** invoke the callback function using the newly formed array as the ** 3rd parameter. */ case OP_Callback: { int i; assert( p->nResColumn==pOp->p1 ); for(i=0; i<pOp->p1; i++){ Mem *pVal = &pTos[0-i]; SetEncodingFlags(pVal, db->enc); } |
︙ | ︙ | |||
2272 2273 2274 2275 2276 2277 2278 | int i; Mem *pArg; sqlite_func ctx; sqlite3_value **apVal; int n = pOp->p1; n = pOp->p1; | | | 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 | int i; Mem *pArg; sqlite_func ctx; sqlite3_value **apVal; int n = pOp->p1; n = pOp->p1; apVal = p->apArg; assert( apVal || n==0 ); pArg = &pTos[1-n]; for(i=0; i<n; i++, pArg++){ SetEncodingFlags(pArg, db->enc); apVal[i] = pArg; } |
︙ | ︙ | |||
2309 2310 2311 2312 2313 2314 2315 | } if( pTos->flags&MEM_Str ){ SetEncodingFlags(pTos, TEXT_Utf8); SetEncoding(pTos, encToFlags(db->enc)|MEM_Term); } | < | 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 | } if( pTos->flags&MEM_Str ){ SetEncodingFlags(pTos, TEXT_Utf8); SetEncoding(pTos, encToFlags(db->enc)|MEM_Term); } break; } /* Opcode: BitAnd * * * ** ** Pop the top two elements from the stack. Convert both elements ** to integers. Push back onto the stack the bit-wise AND of the |
︙ | ︙ | |||
5615 5616 5617 5618 5619 5620 5621 | ** Ideally, this index would be another parameter, but there are ** no free parameters left. The integer is popped from the stack. */ case OP_AggFunc: { int n = pOp->p2; int i; Mem *pMem, *pRec; | < > > > > > < | < < < < < | | 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 | ** Ideally, this index would be another parameter, but there are ** no free parameters left. The integer is popped from the stack. */ case OP_AggFunc: { int n = pOp->p2; int i; Mem *pMem, *pRec; sqlite_func ctx; sqlite3_value **apVal; assert( n>=0 ); assert( pTos->flags==MEM_Int ); pRec = &pTos[-n]; assert( pRec>=p->aStack ); apVal = p->apArg; assert( apVal || n==0 ); for(i=0; i<n; i++, pRec++){ apVal[i] = pRec; SetEncodingFlags(pRec, db->enc); } i = pTos->i; assert( i>=0 && i<p->agg.nMem ); ctx.pFunc = (FuncDef*)pOp->p3; pMem = &p->agg.pCurrent->aMem[i]; ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */ ctx.pAgg = pMem->z; ctx.cnt = ++pMem->i; ctx.isError = 0; ctx.isStep = 1; (ctx.pFunc->xStep)(&ctx, n, apVal); pMem->z = ctx.pAgg; pMem->flags = MEM_AggCtx; popStack(&pTos, n+1); if( ctx.isError ){ rc = SQLITE_ERROR; } break; |
︙ | ︙ |
Changes to src/vdbeInt.h.
︙ | ︙ | |||
289 290 291 292 293 294 295 | int nOpAlloc; /* Number of slots allocated for aOp[] */ Op *aOp; /* Space to hold the virtual machine's program */ int nLabel; /* Number of labels used */ int nLabelAlloc; /* Number of slots allocated in aLabel[] */ int *aLabel; /* Space to hold the labels */ Mem *aStack; /* The operand stack, except string values */ Mem *pTos; /* Top entry in the operand stack */ | | | 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 | int nOpAlloc; /* Number of slots allocated for aOp[] */ Op *aOp; /* Space to hold the virtual machine's program */ int nLabel; /* Number of labels used */ int nLabelAlloc; /* Number of slots allocated in aLabel[] */ int *aLabel; /* Space to hold the labels */ Mem *aStack; /* The operand stack, except string values */ Mem *pTos; /* Top entry in the operand stack */ Mem **apArg; /* Arguments to currently executing user function */ char **azColName; /* Becomes the 4th parameter to callbacks */ void **azColName16; /* UTF-16 encoded equivalent of azColName */ int nCursor; /* Number of slots in apCsr[] */ Cursor **apCsr; /* One element of this array for each open cursor */ Sorter *pSort; /* A linked list of objects to be sorted */ FILE *pFile; /* At most one open file handler */ int nField; /* Number of file fields */ |
︙ | ︙ |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
728 729 730 731 732 733 734 | ** Allocation all the stack space we will ever need. */ if( p->aStack==0 ){ p->nVar = nVar; assert( nVar>=0 ); n = isExplain ? 10 : p->nOp; p->aStack = sqliteMalloc( | | | | | 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 | ** Allocation all the stack space we will ever need. */ if( p->aStack==0 ){ p->nVar = nVar; assert( nVar>=0 ); n = isExplain ? 10 : p->nOp; p->aStack = sqliteMalloc( n*(sizeof(p->aStack[0])+sizeof(Mem*)+sizeof(char*)) /* aStack, apArg */ + p->nVar*sizeof(Mem) /* apVar */ ); p->apArg = (Mem **)&p->aStack[n]; p->azColName = (char**)&p->apArg[n]; p->apVar = (Mem *)&p->azColName[n]; for(n=0; n<p->nVar; n++){ p->apVar[n].flags = MEM_Null; } } sqlite3HashInit(&p->agg.hash, SQLITE_HASH_BINARY, 0); |
︙ | ︙ |