Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Change a couple of symbol names for the new user function API. (CVS 1454) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
8f6b20c2938ded7ab9e400494c02370e |
User & Date: | danielk1977 2004-05-25 12:05:57.000 |
Context
2004-05-25
| ||
23:35 | Move the sqlite3_exec() function to legacy.c. (CVS 1455) (check-in: 9385ad5ca8 user: danielk1977 tags: trunk) | |
12:05 | Change a couple of symbol names for the new user function API. (CVS 1454) (check-in: 8f6b20c293 user: danielk1977 tags: trunk) | |
11:47 | Use the new API for returning values and errors from user functions. (CVS 1453) (check-in: 4eccae03b4 user: danielk1977 tags: trunk) | |
Changes
Changes to src/date.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() 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 date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: date.c,v 1.23 2004/05/25 12:05:57 danielk1977 Exp $ ** ** NOTES: ** ** SQLite processes all times and dates as Julian Day numbers. The ** dates and times are stored as the number of days since noon ** in Greenwich on November 24, 4714 B.C. according to the Gregorian ** calendar system. |
︙ | ︙ | |||
660 661 662 663 664 665 666 | */ /* ** julianday( TIMESTRING, MOD, MOD, ...) ** ** Return the julian day number of the date specified in the arguments */ | | | | | | 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 | */ /* ** julianday( TIMESTRING, MOD, MOD, ...) ** ** Return the julian day number of the date specified in the arguments */ static void juliandayFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ DateTime x; if( isDate(argc, argv, &x)==0 ){ computeJD(&x); sqlite3_result_double(context, x.rJD); } } /* ** datetime( TIMESTRING, MOD, MOD, ...) ** ** Return YYYY-MM-DD HH:MM:SS */ static void datetimeFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ DateTime x; if( isDate(argc, argv, &x)==0 ){ char zBuf[100]; computeYMD_HMS(&x); sprintf(zBuf, "%04d-%02d-%02d %02d:%02d:%02d",x.Y, x.M, x.D, x.h, x.m, (int)(x.s)); sqlite3_result_text(context, zBuf, -1, 1); } } /* ** time( TIMESTRING, MOD, MOD, ...) ** ** Return HH:MM:SS */ static void timeFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ DateTime x; if( isDate(argc, argv, &x)==0 ){ char zBuf[100]; computeHMS(&x); sprintf(zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s); sqlite3_result_text(context, zBuf, -1, 1); } } /* ** date( TIMESTRING, MOD, MOD, ...) ** ** Return YYYY-MM-DD */ static void dateFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ DateTime x; if( isDate(argc, argv, &x)==0 ){ char zBuf[100]; computeYMD(&x); sprintf(zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D); sqlite3_result_text(context, zBuf, -1, 1); } |
︙ | ︙ | |||
733 734 735 736 737 738 739 | ** %s seconds since 1970-01-01 ** %S seconds 00-59 ** %w day of week 0-6 sunday==0 ** %W week of year 00-53 ** %Y year 0000-9999 ** %% % */ | | | 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | ** %s seconds since 1970-01-01 ** %S seconds 00-59 ** %w day of week 0-6 sunday==0 ** %W week of year 00-53 ** %Y year 0000-9999 ** %% % */ static void strftimeFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ DateTime x; int n, i, j; char *z; const char *zFmt = sqlite3_value_data(argv[0]); char zBuf[100]; if( zFmt==0 || isDate(argc-1, argv+1, &x) ) return; for(i=0, n=1; zFmt[i]; i++, n++){ |
︙ | ︙ | |||
849 850 851 852 853 854 855 | ** external linkage. */ void sqlite3RegisterDateTimeFunctions(sqlite *db){ static struct { char *zName; int nArg; int dataType; | | | 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 | ** external linkage. */ void sqlite3RegisterDateTimeFunctions(sqlite *db){ static struct { char *zName; int nArg; int dataType; void (*xFunc)(sqlite3_context*,int,sqlite3_value**); } aFuncs[] = { #ifndef SQLITE_OMIT_DATETIME_FUNCS { "julianday", -1, SQLITE_NUMERIC, juliandayFunc }, { "date", -1, SQLITE_TEXT, dateFunc }, { "time", -1, SQLITE_TEXT, timeFunc }, { "datetime", -1, SQLITE_TEXT, datetimeFunc }, { "strftime", -1, SQLITE_TEXT, strftimeFunc }, |
︙ | ︙ |
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 27 28 29 30 31 32 33 34 35 36 37 38 39 | ** 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.55 2004/05/25 12:05:57 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "vdbeInt.h" #include "os.h" /* ** Implementation of the non-aggregate min() and max() functions */ static void minmaxFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *zBest; int i; int (*xCompare)(const char*, const char*); int mask; /* 0 for min() or 0xffffffff for max() */ const char *zArg; if( argc==0 ) return; |
︙ | ︙ | |||
55 56 57 58 59 60 61 | } sqlite3_result_text(context, zBest, -1, 1); } /* ** Return the type of the argument. */ | | | | | | 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | } sqlite3_result_text(context, zBest, -1, 1); } /* ** Return the type of the argument. */ static void typeofFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *z = 0; assert( argc==2 ); switch( sqlite3_value_type(argv[0]) ){ case SQLITE3_NULL: z = "null" ; break; case SQLITE3_INTEGER: z = "integer" ; break; case SQLITE3_TEXT: z = "text" ; break; case SQLITE3_FLOAT: z = "real" ; break; case SQLITE3_BLOB: z = "blob" ; break; } sqlite3_result_text(context, z, -1, 0); } /* ** Implementation of the length() function */ static void lengthFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *z; int len; assert( argc==1 ); z = sqlite3_value_data(argv[0]); if( z==0 ) return; #ifdef SQLITE_UTF8 for(len=0; *z; z++){ if( (0xc0&*z)!=0x80 ) len++; } #else len = strlen(z); #endif sqlite3_result_int32(context, len); } /* ** Implementation of the abs() function */ static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *z; assert( argc==1 ); z = sqlite3_value_data(argv[0]); if( z==0 ) return; if( z[0]=='-' && isdigit(z[1]) ) z++; sqlite3_result_text(context, z, -1, 1); } /* ** Implementation of the substr() function */ static void substrFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *z; #ifdef SQLITE_UTF8 const char *z2; int i; #endif int p1, p2, len; assert( argc==3 ); |
︙ | ︙ | |||
147 148 149 150 151 152 153 | if( p2<0 ) p2 = 0; sqlite3_result_text(context, &z[p1], p2, 1); } /* ** Implementation of the round() function */ | | | | | | | | | | | | | | | 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 | if( p2<0 ) p2 = 0; sqlite3_result_text(context, &z[p1], p2, 1); } /* ** Implementation of the round() function */ static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ int n = 0; double r; char zBuf[100]; assert( argc==1 || argc==2 ); if( argc==2 ){ if( SQLITE3_NULL==sqlite3_value_type(argv[1]) ) return; n = sqlite3_value_int(argv[1]); if( n>30 ) n = 30; if( n<0 ) n = 0; } if( SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; r = sqlite3_value_float(argv[0]); sprintf(zBuf,"%.*f",n,r); sqlite3_result_text(context, zBuf, -1, 1); } /* ** Implementation of the upper() and lower() SQL functions. */ static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char *z; int i; if( argc<1 || SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; z = sqliteMalloc(sqlite3_value_bytes(argv[0])); if( z==0 ) return; strcpy(z, sqlite3_value_data(argv[0])); for(i=0; z[i]; i++){ if( islower(z[i]) ) z[i] = toupper(z[i]); } sqlite3_result_text(context, z, -1, 1); sqliteFree(z); } static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char *z; int i; if( argc<1 || SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; z = sqliteMalloc(sqlite3_value_bytes(argv[0])); if( z==0 ) return; strcpy(z, sqlite3_value_data(argv[0])); for(i=0; z[i]; i++){ if( isupper(z[i]) ) z[i] = tolower(z[i]); } sqlite3_result_text(context, z, -1, 1); sqliteFree(z); } /* ** Implementation of the IFNULL(), NVL(), and COALESCE() functions. ** All three do the same thing. They return the first non-NULL ** argument. */ static void ifnullFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ int i; for(i=0; i<argc; i++){ if( SQLITE3_NULL!=sqlite3_value_type(argv[i]) ){ sqlite3_result_text(context, sqlite3_value_data(argv[i]), -1, 1); break; } } } /* ** Implementation of random(). Return a random integer. */ static void randomFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ int r; sqlite3Randomness(sizeof(r), &r); sqlite3_result_int32(context, r); } /* ** Implementation of the last_insert_rowid() SQL function. The return ** value is the same as the sqlite3_last_insert_rowid() API function. */ static void last_insert_rowid( sqlite3_context *context, int arg, sqlite3_value **argv ){ sqlite *db = sqlite3_user_data(context); sqlite3_result_int32(context, sqlite3_last_insert_rowid(db)); } /* ** Implementation of the change_count() SQL function. The return ** value is the same as the sqlite3_changes() API function. */ static void change_count(sqlite3_context *context, int arg, sqlite3_value **argv){ sqlite *db = sqlite3_user_data(context); sqlite3_result_int32(context, sqlite3_changes(db)); } /* ** Implementation of the last_statement_change_count() SQL function. The ** return value is the same as the sqlite3_last_statement_changes() API ** function. */ static void last_statement_change_count( sqlite3_context *context, int arg, sqlite3_value **argv ){ sqlite *db = sqlite3_user_data(context); sqlite3_result_int32(context, sqlite3_last_statement_changes(db)); } /* ** Implementation of the like() SQL function. This function implements ** the build-in LIKE operator. The first argument to the function is the ** string and the second argument is the pattern. So, the SQL statements: ** ** A LIKE B ** ** is implemented as like(A,B). */ static void likeFunc( sqlite3_context *context, int argc, sqlite3_value **argv ){ const unsigned char *zA = sqlite3_value_data(argv[0]); const unsigned char *zB = sqlite3_value_data(argv[1]); if( zA && zB ){ sqlite3_result_int32(context, sqlite3LikeCompare(zA, zB)); } } /* ** Implementation of the glob() SQL function. This function implements ** the build-in GLOB operator. The first argument to the function is the ** string and the second argument is the pattern. So, the SQL statements: ** ** A GLOB B ** ** is implemented as glob(A,B). */ static void globFunc(sqlite3_context *context, int arg, sqlite3_value **argv){ const unsigned char *zA = sqlite3_value_data(argv[0]); const unsigned char *zB = sqlite3_value_data(argv[1]); if( zA && zB ){ sqlite3_result_int32(context, sqlite3GlobCompare(zA, zB)); } } /* ** Implementation of the NULLIF(x,y) function. The result is the first ** argument if the arguments are different. The result is NULL if the ** arguments are equal to each other. */ static void nullifFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const unsigned char *zX = sqlite3_value_data(argv[0]); const unsigned char *zY = sqlite3_value_data(argv[1]); if( zX!=0 && sqlite3Compare(zX, zY)!=0 ){ sqlite3_result_text(context, zX, -1, 1); } } /* ** Implementation of the VERSION(*) function. The result is the version ** of the SQLite library that is running. */ static void versionFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ sqlite3_result_text(context, sqlite3_version, -1, 0); } /* ** EXPERIMENTAL - This is not an official function. The interface may ** change. This function may disappear. Do not write code that depends ** on this function. ** ** Implementation of the QUOTE() function. This function takes a single ** argument. If the argument is numeric, the return value is the same as ** the argument. If the argument is NULL, the return value is the string ** "NULL". Otherwise, the argument is enclosed in single quotes with ** single-quote escapes. */ static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ const char *zArg = sqlite3_value_data(argv[0]); if( argc<1 ) return; if( zArg==0 ){ sqlite3_result_text(context, "NULL", 4, 0); }else if( sqlite3IsNumber(zArg, 0, TEXT_Utf8) ){ sqlite3_result_text(context, zArg, -1, 1); }else{ |
︙ | ︙ | |||
355 356 357 358 359 360 361 | } } #ifdef SQLITE_SOUNDEX /* ** Compute the soundex encoding of a word. */ | | | 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 | } } #ifdef SQLITE_SOUNDEX /* ** Compute the soundex encoding of a word. */ static void soundexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char zResult[8]; const char *zIn; int i, j; static const unsigned char iCode[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
︙ | ︙ | |||
396 397 398 399 400 401 402 | #endif #ifdef SQLITE_TEST /* ** This function generates a string of random characters. Used for ** generating test data. */ | | | 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 | #endif #ifdef SQLITE_TEST /* ** This function generates a string of random characters. Used for ** generating test data. */ static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ static const unsigned char zSrc[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789" ".-!,:*^+=_|?/<> "; int iMin, iMax, n, r, i; unsigned char zBuf[1000]; |
︙ | ︙ | |||
447 448 449 450 451 452 453 | double sum; /* Sum of terms */ int cnt; /* Number of elements summed */ }; /* ** Routines used to compute the sum or average. */ | | | | | | | | | | 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 | double sum; /* Sum of terms */ int cnt; /* Number of elements summed */ }; /* ** Routines used to compute the sum or average. */ static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ SumCtx *p; if( argc<1 ) return; p = sqlite3_get_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(sqlite3_context *context){ SumCtx *p; p = sqlite3_get_context(context, sizeof(*p)); sqlite3_result_double(context, p ? p->sum : 0.0); } static void avgFinalize(sqlite3_context *context){ SumCtx *p; p = sqlite3_get_context(context, sizeof(*p)); if( p && p->cnt>0 ){ sqlite3_result_double(context, p->sum/(double)p->cnt); } } /* ** An instance of the following structure holds the context of a ** variance or standard deviation computation. */ typedef struct StdDevCtx StdDevCtx; struct StdDevCtx { double sum; /* Sum of terms */ double sum2; /* Sum of the squares of terms */ int cnt; /* Number of terms counted */ }; #if 0 /* Omit because math library is required */ /* ** Routines used to compute the standard deviation as an aggregate. */ static void stdDevStep(sqlite3_context *context, int argc, const char **argv){ StdDevCtx *p; double x; if( argc<1 ) return; p = sqlite3_aggregate_context(context, sizeof(*p)); if( p && argv[0] ){ x = sqlite3AtoF(argv[0], 0); p->sum += x; p->sum2 += x*x; p->cnt++; } } static void stdDevFinalize(sqlite3_context *context){ double rN = sqlite3_aggregate_count(context); StdDevCtx *p = sqlite3_aggregate_context(context, sizeof(*p)); if( p && p->cnt>1 ){ double rCnt = cnt; sqlite3_set_result_double(context, sqrt((p->sum2 - p->sum*p->sum/rCnt)/(rCnt-1.0))); } |
︙ | ︙ | |||
519 520 521 522 523 524 525 | struct CountCtx { int n; }; /* ** Routines to implement the count() aggregate function. */ | | | | | | | | 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 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 | struct CountCtx { int n; }; /* ** Routines to implement the count() aggregate function. */ static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ CountCtx *p; p = sqlite3_get_context(context, sizeof(*p)); if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0])) && p ){ p->n++; } } static void countFinalize(sqlite3_context *context){ CountCtx *p; p = sqlite3_get_context(context, sizeof(*p)); sqlite3_result_int32(context, p ? p->n : 0); } /* ** This function tracks state information for the min() and max() ** aggregate functions. */ typedef struct MinMaxCtx MinMaxCtx; struct MinMaxCtx { 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(sqlite3_context *context, int argc, sqlite3_value **argv){ int max = 0; int cmp = 0; Mem *pArg = (Mem *)argv[0]; Mem *pBest = (Mem *)sqlite3_get_context(context, sizeof(*pBest)); if( SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; if( pBest->flags ){ /* This step function is used for both the min() and max() aggregates, ** the only difference between the two being that the sense of the ** comparison is inverted. For the max() aggregate, the |
︙ | ︙ | |||
571 572 573 574 575 576 577 | if( (max && cmp<0) || (!max && cmp>0) ){ sqlite3VdbeMemCopy(pBest, pArg); } }else{ sqlite3VdbeMemCopy(pBest, pArg); } } | | | | 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 | if( (max && cmp<0) || (!max && cmp>0) ){ sqlite3VdbeMemCopy(pBest, pArg); } }else{ sqlite3VdbeMemCopy(pBest, pArg); } } static void minMaxFinalize(sqlite3_context *context){ sqlite3_value *pRes; pRes = (sqlite3_value *)sqlite3_get_context(context, sizeof(Mem)); if( pRes->flags ){ switch( sqlite3_value_type(pRes) ){ case SQLITE3_INTEGER: sqlite3_result_int32(context, sqlite3_value_int(pRes)); break; case SQLITE3_FLOAT: |
︙ | ︙ | |||
605 606 607 608 609 610 611 | */ void sqlite3RegisterBuiltinFunctions(sqlite *db){ static struct { char *zName; signed char nArg; signed char dataType; u8 argType; /* 0: none. 1: db 2: (-1) */ | | | 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 | */ void sqlite3RegisterBuiltinFunctions(sqlite *db){ static struct { char *zName; signed char nArg; signed char dataType; u8 argType; /* 0: none. 1: db 2: (-1) */ void (*xFunc)(sqlite3_context*,int,sqlite3_value **); } aFuncs[] = { { "min", -1, SQLITE_ARGS, 0, minmaxFunc }, { "min", 0, 0, 0, 0 }, { "max", -1, SQLITE_ARGS, 2, minmaxFunc }, { "max", 0, 0, 2, 0 }, { "typeof", 1, SQLITE_TEXT, 0, typeofFunc }, { "classof", 1, SQLITE_TEXT, 0, typeofFunc }, /* FIX ME: hack */ |
︙ | ︙ | |||
646 647 648 649 650 651 652 | #endif }; static struct { char *zName; signed char nArg; signed char dataType; u8 argType; | | | | 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 | #endif }; static struct { char *zName; signed char nArg; signed char dataType; u8 argType; void (*xStep)(sqlite3_context*,int,sqlite3_value**); void (*xFinalize)(sqlite3_context*); } 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 }, { "count", 1, 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.188 2004/05/25 12:05:57 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
857 858 859 860 861 862 863 | ** If nArg is -1 it means that this function will accept any number ** of arguments, including 0. The maximum allowed value of nArg is 127. */ int sqlite3_create_function( sqlite *db, /* Add the function to this database connection */ const char *zName, /* Name of the function to add */ int nArg, /* Number of arguments */ | | | | | 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 | ** If nArg is -1 it means that this function will accept any number ** of arguments, including 0. The maximum allowed value of nArg is 127. */ int sqlite3_create_function( sqlite *db, /* Add the function to this database connection */ const char *zName, /* Name of the function to add */ int nArg, /* Number of arguments */ void (*xFunc)(sqlite3_context*,int,sqlite3_value **), /* The implementation */ void *pUserData /* User data */ ){ FuncDef *p; int nName; if( db==0 || zName==0 || sqlite3SafetyCheck(db) ) return 1; if( nArg<-1 || nArg>127 ) return 1; nName = strlen(zName); if( nName>255 ) return 1; p = sqlite3FindFunction(db, zName, nName, nArg, 1); if( p==0 ) return 1; p->xFunc = xFunc; p->xStep = 0; p->xFinalize = 0; 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)(sqlite3_context*,int,sqlite3_value**), /* The step function */ void (*xFinalize)(sqlite3_context*), /* 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; nName = strlen(zName); |
︙ | ︙ |
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 379 380 381 382 383 384 385 386 | return TCL_OK; } /* ** During testing, the special md5sum() aggregate function is available. ** inside SQLite. The following routines implement that function. */ static void md5step(sqlite3_context *context, int argc, sqlite3_value **argv){ MD5Context *p; int i; if( argc<1 ) return; p = sqlite3_get_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(sqlite3_context *context){ MD5Context *p; unsigned char digest[16]; char zBuf[33]; p = sqlite3_get_context(context, sizeof(*p)); MD5Final(digest,p); DigestToBase16(digest, zBuf); sqlite3_result_text(context, zBuf, -1, 1); } void Md5_Register(sqlite *db){ sqlite3_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0); } |
︙ | ︙ |
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.76 2004/05/25 12:05:57 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++. |
︙ | ︙ | |||
417 418 419 420 421 422 423 | const char *sqlite3_libversion(void); const char *sqlite3_libencoding(void); /* ** A pointer to the following structure is used to communicate with ** the implementations of user-defined functions. */ | | > | | | | 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 | const char *sqlite3_libversion(void); const char *sqlite3_libencoding(void); /* ** A pointer to the following structure is used to communicate with ** the implementations of user-defined functions. */ typedef struct sqlite3_context sqlite3_context; typedef struct Mem sqlite3_value; /* ** Use the following routines to create new user-defined functions. See ** the documentation for details. */ int sqlite3_create_function( sqlite*, /* Database where the new function is registered */ const char *zName, /* Name of the new function */ int nArg, /* Number of arguments. -1 means any number */ void (*xFunc)(sqlite3_context*,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)(sqlite3_context*,int,sqlite3_value**), /* Called for each row */ void (*xFinalize)(sqlite3_context*), /* 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 ** constants SQLITE_NUMERIC, SQLITE_TEXT, or SQLITE_ARGS or it |
︙ | ︙ | |||
460 461 462 463 464 465 466 | const char *zName, /* Name of the function */ int datatype /* The datatype for this function */ ); #define SQLITE_NUMERIC (-1) #define SQLITE_TEXT (-2) #define SQLITE_ARGS (-3) | < < < < < < < < < < < < | | 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 | const char *zName, /* Name of the function */ int datatype /* The datatype for this function */ ); #define SQLITE_NUMERIC (-1) #define SQLITE_TEXT (-2) #define SQLITE_ARGS (-3) /* ** The next routine returns the number of calls to xStep for a particular ** aggregate function instance. The current call to xStep counts so this ** routine always returns at least 1. */ int sqlite3_aggregate_count(sqlite3_context*); /* ** This routine registers a callback with the SQLite library. The ** callback is invoked (at compile-time, not at run-time) for each ** attempt to access a column of a table in the database. The callback ** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire ** SQL statement should be aborted with an error and SQLITE_IGNORE |
︙ | ︙ | |||
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 | ** SQLITE3_NULL 0.0 ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_column_float(sqlite3_stmt*,int); /* ** Return the type of the sqlite3_value* passed as the first argument. ** The type is one of SQLITE3_NULL, SQLITE3_INTEGER, SQLITE3_FLOAT, ** SQLITE3_TEXT or SQLITE3_BLOB. */ int sqlite3_value_type(sqlite3_value*); | > | 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 | ** SQLITE3_NULL 0.0 ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_column_float(sqlite3_stmt*,int); /* ** Return the type of the sqlite3_value* passed as the first argument. ** The type is one of SQLITE3_NULL, SQLITE3_INTEGER, SQLITE3_FLOAT, ** SQLITE3_TEXT or SQLITE3_BLOB. */ int sqlite3_value_type(sqlite3_value*); |
︙ | ︙ | |||
1378 1379 1380 1381 1382 1383 1384 | ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_value_float(sqlite3_value*); | < | > > > > > > > > > | | 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 | ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_value_float(sqlite3_value*); /* ** Aggregate functions use the following routine to allocate ** a structure for storing their state. The first time this routine ** is called for a particular aggregate, a new structure of size nBytes ** is allocated, zeroed, and returned. On subsequent calls (for the ** same aggregate instance) the same buffer is returned. The implementation ** of the aggregate can use the returned buffer to accumulate data. ** ** The buffer allocated is freed automatically by SQLite. */ void *sqlite3_get_context(sqlite3_context*, int nBytes); /* ** The pUserData parameter to the sqlite3_create_function() and ** sqlite3_create_aggregate() routines used to register user functions ** is available to the implementation of the function using this ** call. */ |
︙ | ︙ |
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.251 2004/05/25 12:05:57 danielk1977 Exp $ */ #include "config.h" #include "sqlite.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> |
︙ | ︙ | |||
460 461 462 463 464 465 466 | /* ** 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 { | | | | | 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 | /* ** 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)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate function step */ void (*xFinalize)(sqlite3_context*); /* 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/tclsqlite.c.
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. ** ************************************************************************* ** A TCL Interface to 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. ** ************************************************************************* ** A TCL Interface to SQLite ** ** $Id: tclsqlite.c,v 1.69 2004/05/25 12:05:57 danielk1977 Exp $ */ #ifndef NO_TCL /* Omit this whole file if TCL is unavailable */ #include "sqliteInt.h" #include "tcl.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
375 376 377 378 379 380 381 | return 0; } /* ** This routine is called to evaluate an SQL function implemented ** using TCL script. */ | | | 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 | return 0; } /* ** This routine is called to evaluate an SQL function implemented ** using TCL script. */ static void tclSqlFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ SqlFunc *p = sqlite3_user_data(context); Tcl_DString cmd; int i; int rc; Tcl_DStringInit(&cmd); Tcl_DStringAppend(&cmd, p->zScript, -1); |
︙ | ︙ |
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.51 2004/05/25 12:05:57 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include "os.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
303 304 305 306 307 308 309 | return TCL_OK; } /* ** Implementation of the x_coalesce() function. ** Return the first argument non-NULL argument. */ | | | 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 | return TCL_OK; } /* ** Implementation of the x_coalesce() function. ** Return the first argument non-NULL argument. */ static void ifnullFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ int i; for(i=0; i<argc; i++){ if( SQLITE3_NULL!=sqlite3_value_type(argv[i]) ){ sqlite3_result_text(context, sqlite3_value_data(argv[i]), -1, 1); break; } } |
︙ | ︙ | |||
373 374 375 376 377 378 379 | ** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec() ** from within a function call. ** ** This routine simulates the effect of having two threads attempt to ** use the same database at the same time. */ static void sqlite3ExecFunc( | | | 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 | ** 2004-Jan-07: We have changed this to make it legal to call sqlite3_exec() ** from within a function call. ** ** This routine simulates the effect of having two threads attempt to ** use the same database at the same time. */ static void sqlite3ExecFunc( sqlite3_context *context, int argc, sqlite3_value **argv ){ struct dstr x; memset(&x, 0, sizeof(x)); sqlite3_exec((sqlite*)sqlite3_user_data(context), sqlite3_value_data(argv[0]), |
︙ | ︙ | |||
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 445 446 447 448 449 450 | /* ** Routines to implement the x_count() aggregate function. */ typedef struct CountCtx CountCtx; struct CountCtx { int n; }; static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ CountCtx *p; p = sqlite3_get_context(context, sizeof(*p)); if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0]) ) && p ){ p->n++; } } static void countFinalize(sqlite3_context *context){ CountCtx *p; p = sqlite3_get_context(context, sizeof(*p)); sqlite3_result_int32(context, p ? p->n : 0); } /* ** Usage: sqlite_test_create_aggregate DB ** ** Call the sqlite3_create_function API on the given database in order |
︙ | ︙ | |||
649 650 651 652 653 654 655 | return TCL_OK; } /* ** The following routine is a user-defined SQL function whose purpose ** is to test the sqlite_set_result() API. */ | | | 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 | return TCL_OK; } /* ** The following routine is a user-defined SQL function whose purpose ** is to test the sqlite_set_result() API. */ static void testFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ while( argc>=2 ){ const char *zArg0 = sqlite3_value_data(argv[0]); const char *zArg1 = sqlite3_value_data(argv[1]); if( zArg0==0 ){ sqlite3_result_error(context, "first argument to test function " "may not be NULL", -1); }else if( sqlite3StrICmp(zArg0,"string")==0 ){ |
︙ | ︙ |
Changes to src/vdbeInt.h.
︙ | ︙ | |||
233 234 235 236 237 238 239 | ** even the public interface to SQLite, can use a pointer to this structure. ** But this file is the only place where the internal details of this ** structure are known. ** ** This structure is defined inside of vdbe.c because it uses substructures ** (Mem) which are only defined there. */ | | | 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 | ** even the public interface to SQLite, can use a pointer to this structure. ** But this file is the only place where the internal details of this ** structure are known. ** ** This structure is defined inside of vdbe.c because it uses substructures ** (Mem) which are only defined there. */ struct sqlite3_context { FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */ Mem s; /* The return value is stored here */ void *pAgg; /* Aggregate context */ u8 isError; /* Set to true for an error */ u8 isStep; /* Current in the step function */ int cnt; /* Number of times that the step function has been called */ }; |
︙ | ︙ |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
421 422 423 424 425 426 427 | VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ assert( p->magic==VDBE_MAGIC_INIT ); assert( addr>=0 && addr<p->nOp ); return &p->aOp[addr]; } /* | | | | | | | 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 | VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ assert( p->magic==VDBE_MAGIC_INIT ); assert( addr>=0 && addr<p->nOp ); return &p->aOp[addr]; } /* ** Extract the user data from a sqlite3_context structure and return a ** pointer to it. */ void *sqlite3_user_data(sqlite3_context *p){ assert( p && p->pFunc ); return p->pFunc->pUserData; } /* ** Allocate or return the aggregate context for a user function. A new ** context is allocated on the first call. Subsequent calls return the ** same context that was returned on prior calls. ** ** This routine is defined here in vdbe.c because it depends on knowing ** the internals of the sqlite3_context structure which is only defined in ** this source file. */ void *sqlite3_get_context(sqlite3_context *p, int nByte){ assert( p && p->pFunc && p->pFunc->xStep ); if( p->pAgg==0 ){ if( nByte<=NBFS ){ p->pAgg = (void*)p->s.z; memset(p->pAgg, 0, nByte); }else{ p->pAgg = sqliteMalloc( nByte ); } } return p->pAgg; } /* ** Return the number of times the Step function of a aggregate has been ** called. ** ** This routine is defined here in vdbe.c because it depends on knowing ** the internals of the sqlite3_context structure which is only defined in ** this source file. */ int sqlite3_aggregate_count(sqlite3_context *p){ assert( p && p->pFunc && p->pFunc->xStep ); return p->cnt; } /* ** Compute a string that describes the P3 parameter for an opcode. ** Use zTemp for any required temporary buffer space. |
︙ | ︙ | |||
727 728 729 730 731 732 733 | HashElem *p; for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){ AggElem *pElem = sqliteHashData(p); assert( pAgg->apFunc!=0 ); for(i=0; i<pAgg->nMem; i++){ Mem *pMem = &pElem->aMem[i]; if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){ | | | 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 | HashElem *p; for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){ AggElem *pElem = sqliteHashData(p); assert( pAgg->apFunc!=0 ); for(i=0; i<pAgg->nMem; i++){ Mem *pMem = &pElem->aMem[i]; if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){ sqlite3_context ctx; ctx.pFunc = pAgg->apFunc[i]; ctx.s.flags = MEM_Null; ctx.pAgg = pMem->z; ctx.cnt = pMem->i; ctx.isStep = 0; ctx.isError = 0; (*pAgg->apFunc[i]->xFinalize)(&ctx); |
︙ | ︙ |