Annotation of embedaddon/php/ext/sqlite/libsqlite/src/func.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2002 February 23
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** This file contains the C functions that implement various SQL
! 13: ** functions of SQLite.
! 14: **
! 15: ** There is only one exported symbol in this file - the function
! 16: ** sqliteRegisterBuildinFunctions() found at the bottom of the file.
! 17: ** All other code has file scope.
! 18: **
! 19: ** $Id: func.c 195361 2005-09-07 15:11:33Z iliaa $
! 20: */
! 21: #include <ctype.h>
! 22: #include <math.h>
! 23: #include <stdlib.h>
! 24: #include <assert.h>
! 25: #include "sqliteInt.h"
! 26: #include "os.h"
! 27:
! 28: /*
! 29: ** Implementation of the non-aggregate min() and max() functions
! 30: */
! 31: static void minmaxFunc(sqlite_func *context, int argc, const char **argv){
! 32: const char *zBest;
! 33: int i;
! 34: int (*xCompare)(const char*, const char*);
! 35: int mask; /* 0 for min() or 0xffffffff for max() */
! 36:
! 37: if( argc==0 ) return;
! 38: mask = (int)sqlite_user_data(context);
! 39: zBest = argv[0];
! 40: if( zBest==0 ) return;
! 41: if( argv[1][0]=='n' ){
! 42: xCompare = sqliteCompare;
! 43: }else{
! 44: xCompare = strcmp;
! 45: }
! 46: for(i=2; i<argc; i+=2){
! 47: if( argv[i]==0 ) return;
! 48: if( (xCompare(argv[i], zBest)^mask)<0 ){
! 49: zBest = argv[i];
! 50: }
! 51: }
! 52: sqlite_set_result_string(context, zBest, -1);
! 53: }
! 54:
! 55: /*
! 56: ** Return the type of the argument.
! 57: */
! 58: static void typeofFunc(sqlite_func *context, int argc, const char **argv){
! 59: assert( argc==2 );
! 60: sqlite_set_result_string(context, argv[1], -1);
! 61: }
! 62:
! 63: /*
! 64: ** Implementation of the length() function
! 65: */
! 66: static void lengthFunc(sqlite_func *context, int argc, const char **argv){
! 67: const char *z;
! 68: int len;
! 69:
! 70: assert( argc==1 );
! 71: z = argv[0];
! 72: if( z==0 ) return;
! 73: #ifdef SQLITE_UTF8
! 74: for(len=0; *z; z++){ if( (0xc0&*z)!=0x80 ) len++; }
! 75: #else
! 76: len = strlen(z);
! 77: #endif
! 78: sqlite_set_result_int(context, len);
! 79: }
! 80:
! 81: /*
! 82: ** Implementation of the abs() function
! 83: */
! 84: static void absFunc(sqlite_func *context, int argc, const char **argv){
! 85: const char *z;
! 86: assert( argc==1 );
! 87: z = argv[0];
! 88: if( z==0 ) return;
! 89: if( z[0]=='-' && isdigit(z[1]) ) z++;
! 90: sqlite_set_result_string(context, z, -1);
! 91: }
! 92:
! 93: /*
! 94: ** Implementation of the substr() function
! 95: */
! 96: static void substrFunc(sqlite_func *context, int argc, const char **argv){
! 97: const char *z;
! 98: #ifdef SQLITE_UTF8
! 99: const char *z2;
! 100: int i;
! 101: #endif
! 102: int p1, p2, len;
! 103: assert( argc==3 );
! 104: z = argv[0];
! 105: if( z==0 ) return;
! 106: p1 = atoi(argv[1]?argv[1]:0);
! 107: p2 = atoi(argv[2]?argv[2]:0);
! 108: #ifdef SQLITE_UTF8
! 109: for(len=0, z2=z; *z2; z2++){ if( (0xc0&*z2)!=0x80 ) len++; }
! 110: #else
! 111: len = strlen(z);
! 112: #endif
! 113: if( p1<0 ){
! 114: p1 += len;
! 115: if( p1<0 ){
! 116: p2 += p1;
! 117: p1 = 0;
! 118: }
! 119: }else if( p1>0 ){
! 120: p1--;
! 121: }
! 122: if( p1+p2>len ){
! 123: p2 = len-p1;
! 124: }
! 125: #ifdef SQLITE_UTF8
! 126: for(i=0; i<p1 && z[i]; i++){
! 127: if( (z[i]&0xc0)==0x80 ) p1++;
! 128: }
! 129: while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p1++; }
! 130: for(; i<p1+p2 && z[i]; i++){
! 131: if( (z[i]&0xc0)==0x80 ) p2++;
! 132: }
! 133: while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p2++; }
! 134: #endif
! 135: if( p2<0 ) p2 = 0;
! 136: sqlite_set_result_string(context, &z[p1], p2);
! 137: }
! 138:
! 139: /*
! 140: ** Implementation of the round() function
! 141: */
! 142: static void roundFunc(sqlite_func *context, int argc, const char **argv){
! 143: int n;
! 144: double r;
! 145: char zBuf[100];
! 146: assert( argc==1 || argc==2 );
! 147: if( argv[0]==0 || (argc==2 && argv[1]==0) ) return;
! 148: n = argc==2 ? atoi(argv[1]) : 0;
! 149: if( n>30 ) n = 30;
! 150: if( n<0 ) n = 0;
! 151: r = sqliteAtoF(argv[0], 0);
! 152: sprintf(zBuf,"%.*f",n,r);
! 153: sqlite_set_result_string(context, zBuf, -1);
! 154: }
! 155:
! 156: /*
! 157: ** Implementation of the upper() and lower() SQL functions.
! 158: */
! 159: static void upperFunc(sqlite_func *context, int argc, const char **argv){
! 160: unsigned char *z;
! 161: int i;
! 162: if( argc<1 || argv[0]==0 ) return;
! 163: z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1);
! 164: if( z==0 ) return;
! 165: for(i=0; z[i]; i++){
! 166: if( islower(z[i]) ) z[i] = toupper(z[i]);
! 167: }
! 168: }
! 169: static void lowerFunc(sqlite_func *context, int argc, const char **argv){
! 170: unsigned char *z;
! 171: int i;
! 172: if( argc<1 || argv[0]==0 ) return;
! 173: z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1);
! 174: if( z==0 ) return;
! 175: for(i=0; z[i]; i++){
! 176: if( isupper(z[i]) ) z[i] = tolower(z[i]);
! 177: }
! 178: }
! 179:
! 180: /*
! 181: ** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
! 182: ** All three do the same thing. They return the first non-NULL
! 183: ** argument.
! 184: */
! 185: static void ifnullFunc(sqlite_func *context, int argc, const char **argv){
! 186: int i;
! 187: for(i=0; i<argc; i++){
! 188: if( argv[i] ){
! 189: sqlite_set_result_string(context, argv[i], -1);
! 190: break;
! 191: }
! 192: }
! 193: }
! 194:
! 195: /*
! 196: ** Implementation of random(). Return a random integer.
! 197: */
! 198: static void randomFunc(sqlite_func *context, int argc, const char **argv){
! 199: int r;
! 200: sqliteRandomness(sizeof(r), &r);
! 201: sqlite_set_result_int(context, r);
! 202: }
! 203:
! 204: /*
! 205: ** Implementation of the last_insert_rowid() SQL function. The return
! 206: ** value is the same as the sqlite_last_insert_rowid() API function.
! 207: */
! 208: static void last_insert_rowid(sqlite_func *context, int arg, const char **argv){
! 209: sqlite *db = sqlite_user_data(context);
! 210: sqlite_set_result_int(context, sqlite_last_insert_rowid(db));
! 211: }
! 212:
! 213: /*
! 214: ** Implementation of the change_count() SQL function. The return
! 215: ** value is the same as the sqlite_changes() API function.
! 216: */
! 217: static void change_count(sqlite_func *context, int arg, const char **argv){
! 218: sqlite *db = sqlite_user_data(context);
! 219: sqlite_set_result_int(context, sqlite_changes(db));
! 220: }
! 221:
! 222: /*
! 223: ** Implementation of the last_statement_change_count() SQL function. The
! 224: ** return value is the same as the sqlite_last_statement_changes() API function.
! 225: */
! 226: static void last_statement_change_count(sqlite_func *context, int arg,
! 227: const char **argv){
! 228: sqlite *db = sqlite_user_data(context);
! 229: sqlite_set_result_int(context, sqlite_last_statement_changes(db));
! 230: }
! 231:
! 232: /*
! 233: ** Implementation of the like() SQL function. This function implements
! 234: ** the build-in LIKE operator. The first argument to the function is the
! 235: ** string and the second argument is the pattern. So, the SQL statements:
! 236: **
! 237: ** A LIKE B
! 238: **
! 239: ** is implemented as like(A,B).
! 240: */
! 241: static void likeFunc(sqlite_func *context, int arg, const char **argv){
! 242: if( argv[0]==0 || argv[1]==0 ) return;
! 243: sqlite_set_result_int(context,
! 244: sqliteLikeCompare((const unsigned char*)argv[0],
! 245: (const unsigned char*)argv[1]));
! 246: }
! 247:
! 248: /*
! 249: ** Implementation of the glob() SQL function. This function implements
! 250: ** the build-in GLOB operator. The first argument to the function is the
! 251: ** string and the second argument is the pattern. So, the SQL statements:
! 252: **
! 253: ** A GLOB B
! 254: **
! 255: ** is implemented as glob(A,B).
! 256: */
! 257: static void globFunc(sqlite_func *context, int arg, const char **argv){
! 258: if( argv[0]==0 || argv[1]==0 ) return;
! 259: sqlite_set_result_int(context,
! 260: sqliteGlobCompare((const unsigned char*)argv[0],
! 261: (const unsigned char*)argv[1]));
! 262: }
! 263:
! 264: /*
! 265: ** Implementation of the NULLIF(x,y) function. The result is the first
! 266: ** argument if the arguments are different. The result is NULL if the
! 267: ** arguments are equal to each other.
! 268: */
! 269: static void nullifFunc(sqlite_func *context, int argc, const char **argv){
! 270: if( argv[0]!=0 && sqliteCompare(argv[0],argv[1])!=0 ){
! 271: sqlite_set_result_string(context, argv[0], -1);
! 272: }
! 273: }
! 274:
! 275: /*
! 276: ** Implementation of the VERSION(*) function. The result is the version
! 277: ** of the SQLite library that is running.
! 278: */
! 279: static void versionFunc(sqlite_func *context, int argc, const char **argv){
! 280: sqlite_set_result_string(context, sqlite_version, -1);
! 281: }
! 282:
! 283: /*
! 284: ** EXPERIMENTAL - This is not an official function. The interface may
! 285: ** change. This function may disappear. Do not write code that depends
! 286: ** on this function.
! 287: **
! 288: ** Implementation of the QUOTE() function. This function takes a single
! 289: ** argument. If the argument is numeric, the return value is the same as
! 290: ** the argument. If the argument is NULL, the return value is the string
! 291: ** "NULL". Otherwise, the argument is enclosed in single quotes with
! 292: ** single-quote escapes.
! 293: */
! 294: static void quoteFunc(sqlite_func *context, int argc, const char **argv){
! 295: if( argc<1 ) return;
! 296: if( argv[0]==0 ){
! 297: sqlite_set_result_string(context, "NULL", 4);
! 298: }else if( sqliteIsNumber(argv[0]) ){
! 299: sqlite_set_result_string(context, argv[0], -1);
! 300: }else{
! 301: int i,j,n;
! 302: char *z;
! 303: for(i=n=0; argv[0][i]; i++){ if( argv[0][i]=='\'' ) n++; }
! 304: z = sqliteMalloc( i+n+3 );
! 305: if( z==0 ) return;
! 306: z[0] = '\'';
! 307: for(i=0, j=1; argv[0][i]; i++){
! 308: z[j++] = argv[0][i];
! 309: if( argv[0][i]=='\'' ){
! 310: z[j++] = '\'';
! 311: }
! 312: }
! 313: z[j++] = '\'';
! 314: z[j] = 0;
! 315: sqlite_set_result_string(context, z, j);
! 316: sqliteFree(z);
! 317: }
! 318: }
! 319:
! 320: #ifdef SQLITE_SOUNDEX
! 321: /*
! 322: ** Compute the soundex encoding of a word.
! 323: */
! 324: static void soundexFunc(sqlite_func *context, int argc, const char **argv){
! 325: char zResult[8];
! 326: const char *zIn;
! 327: int i, j;
! 328: static const unsigned char iCode[] = {
! 329: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 330: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 331: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 332: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 333: 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
! 334: 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
! 335: 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
! 336: 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
! 337: };
! 338: assert( argc==1 );
! 339: zIn = argv[0];
! 340: for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
! 341: if( zIn[i] ){
! 342: zResult[0] = toupper(zIn[i]);
! 343: for(j=1; j<4 && zIn[i]; i++){
! 344: int code = iCode[zIn[i]&0x7f];
! 345: if( code>0 ){
! 346: zResult[j++] = code + '0';
! 347: }
! 348: }
! 349: while( j<4 ){
! 350: zResult[j++] = '0';
! 351: }
! 352: zResult[j] = 0;
! 353: sqlite_set_result_string(context, zResult, 4);
! 354: }else{
! 355: sqlite_set_result_string(context, "?000", 4);
! 356: }
! 357: }
! 358: #endif
! 359:
! 360: #ifdef SQLITE_TEST
! 361: /*
! 362: ** This function generates a string of random characters. Used for
! 363: ** generating test data.
! 364: */
! 365: static void randStr(sqlite_func *context, int argc, const char **argv){
! 366: static const unsigned char zSrc[] =
! 367: "abcdefghijklmnopqrstuvwxyz"
! 368: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 369: "0123456789"
! 370: ".-!,:*^+=_|?/<> ";
! 371: int iMin, iMax, n, r, i;
! 372: unsigned char zBuf[1000];
! 373: if( argc>=1 ){
! 374: iMin = atoi(argv[0]);
! 375: if( iMin<0 ) iMin = 0;
! 376: if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
! 377: }else{
! 378: iMin = 1;
! 379: }
! 380: if( argc>=2 ){
! 381: iMax = atoi(argv[1]);
! 382: if( iMax<iMin ) iMax = iMin;
! 383: if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
! 384: }else{
! 385: iMax = 50;
! 386: }
! 387: n = iMin;
! 388: if( iMax>iMin ){
! 389: sqliteRandomness(sizeof(r), &r);
! 390: r &= 0x7fffffff;
! 391: n += r%(iMax + 1 - iMin);
! 392: }
! 393: assert( n<sizeof(zBuf) );
! 394: sqliteRandomness(n, zBuf);
! 395: for(i=0; i<n; i++){
! 396: zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
! 397: }
! 398: zBuf[n] = 0;
! 399: sqlite_set_result_string(context, zBuf, n);
! 400: }
! 401: #endif
! 402:
! 403: /*
! 404: ** An instance of the following structure holds the context of a
! 405: ** sum() or avg() aggregate computation.
! 406: */
! 407: typedef struct SumCtx SumCtx;
! 408: struct SumCtx {
! 409: double sum; /* Sum of terms */
! 410: int cnt; /* Number of elements summed */
! 411: };
! 412:
! 413: /*
! 414: ** Routines used to compute the sum or average.
! 415: */
! 416: static void sumStep(sqlite_func *context, int argc, const char **argv){
! 417: SumCtx *p;
! 418: if( argc<1 ) return;
! 419: p = sqlite_aggregate_context(context, sizeof(*p));
! 420: if( p && argv[0] ){
! 421: p->sum += sqliteAtoF(argv[0], 0);
! 422: p->cnt++;
! 423: }
! 424: }
! 425: static void sumFinalize(sqlite_func *context){
! 426: SumCtx *p;
! 427: p = sqlite_aggregate_context(context, sizeof(*p));
! 428: sqlite_set_result_double(context, p ? p->sum : 0.0);
! 429: }
! 430: static void avgFinalize(sqlite_func *context){
! 431: SumCtx *p;
! 432: p = sqlite_aggregate_context(context, sizeof(*p));
! 433: if( p && p->cnt>0 ){
! 434: sqlite_set_result_double(context, p->sum/(double)p->cnt);
! 435: }
! 436: }
! 437:
! 438: /*
! 439: ** An instance of the following structure holds the context of a
! 440: ** variance or standard deviation computation.
! 441: */
! 442: typedef struct StdDevCtx StdDevCtx;
! 443: struct StdDevCtx {
! 444: double sum; /* Sum of terms */
! 445: double sum2; /* Sum of the squares of terms */
! 446: int cnt; /* Number of terms counted */
! 447: };
! 448:
! 449: #if 0 /* Omit because math library is required */
! 450: /*
! 451: ** Routines used to compute the standard deviation as an aggregate.
! 452: */
! 453: static void stdDevStep(sqlite_func *context, int argc, const char **argv){
! 454: StdDevCtx *p;
! 455: double x;
! 456: if( argc<1 ) return;
! 457: p = sqlite_aggregate_context(context, sizeof(*p));
! 458: if( p && argv[0] ){
! 459: x = sqliteAtoF(argv[0], 0);
! 460: p->sum += x;
! 461: p->sum2 += x*x;
! 462: p->cnt++;
! 463: }
! 464: }
! 465: static void stdDevFinalize(sqlite_func *context){
! 466: double rN = sqlite_aggregate_count(context);
! 467: StdDevCtx *p = sqlite_aggregate_context(context, sizeof(*p));
! 468: if( p && p->cnt>1 ){
! 469: double rCnt = cnt;
! 470: sqlite_set_result_double(context,
! 471: sqrt((p->sum2 - p->sum*p->sum/rCnt)/(rCnt-1.0)));
! 472: }
! 473: }
! 474: #endif
! 475:
! 476: /*
! 477: ** The following structure keeps track of state information for the
! 478: ** count() aggregate function.
! 479: */
! 480: typedef struct CountCtx CountCtx;
! 481: struct CountCtx {
! 482: int n;
! 483: };
! 484:
! 485: /*
! 486: ** Routines to implement the count() aggregate function.
! 487: */
! 488: static void countStep(sqlite_func *context, int argc, const char **argv){
! 489: CountCtx *p;
! 490: p = sqlite_aggregate_context(context, sizeof(*p));
! 491: if( (argc==0 || argv[0]) && p ){
! 492: p->n++;
! 493: }
! 494: }
! 495: static void countFinalize(sqlite_func *context){
! 496: CountCtx *p;
! 497: p = sqlite_aggregate_context(context, sizeof(*p));
! 498: sqlite_set_result_int(context, p ? p->n : 0);
! 499: }
! 500:
! 501: /*
! 502: ** This function tracks state information for the min() and max()
! 503: ** aggregate functions.
! 504: */
! 505: typedef struct MinMaxCtx MinMaxCtx;
! 506: struct MinMaxCtx {
! 507: char *z; /* The best so far */
! 508: char zBuf[28]; /* Space that can be used for storage */
! 509: };
! 510:
! 511: /*
! 512: ** Routines to implement min() and max() aggregate functions.
! 513: */
! 514: static void minmaxStep(sqlite_func *context, int argc, const char **argv){
! 515: MinMaxCtx *p;
! 516: int (*xCompare)(const char*, const char*);
! 517: int mask; /* 0 for min() or 0xffffffff for max() */
! 518:
! 519: assert( argc==2 );
! 520: if( argv[0]==0 ) return; /* Ignore NULL values */
! 521: if( argv[1][0]=='n' ){
! 522: xCompare = sqliteCompare;
! 523: }else{
! 524: xCompare = strcmp;
! 525: }
! 526: mask = (int)sqlite_user_data(context);
! 527: assert( mask==0 || mask==-1 );
! 528: p = sqlite_aggregate_context(context, sizeof(*p));
! 529: if( p==0 || argc<1 ) return;
! 530: if( p->z==0 || (xCompare(argv[0],p->z)^mask)<0 ){
! 531: int len;
! 532: if( p->zBuf[0] ){
! 533: sqliteFree(p->z);
! 534: }
! 535: len = strlen(argv[0]);
! 536: if( len < sizeof(p->zBuf)-1 ){
! 537: p->z = &p->zBuf[1];
! 538: p->zBuf[0] = 0;
! 539: }else{
! 540: p->z = sqliteMalloc( len+1 );
! 541: p->zBuf[0] = 1;
! 542: if( p->z==0 ) return;
! 543: }
! 544: strcpy(p->z, argv[0]);
! 545: }
! 546: }
! 547: static void minMaxFinalize(sqlite_func *context){
! 548: MinMaxCtx *p;
! 549: p = sqlite_aggregate_context(context, sizeof(*p));
! 550: if( p && p->z && p->zBuf[0]<2 ){
! 551: sqlite_set_result_string(context, p->z, strlen(p->z));
! 552: }
! 553: if( p && p->zBuf[0] ){
! 554: sqliteFree(p->z);
! 555: }
! 556: }
! 557:
! 558: /*
! 559: ** This function registered all of the above C functions as SQL
! 560: ** functions. This should be the only routine in this file with
! 561: ** external linkage.
! 562: */
! 563: void sqliteRegisterBuiltinFunctions(sqlite *db){
! 564: static struct {
! 565: char *zName;
! 566: signed char nArg;
! 567: signed char dataType;
! 568: u8 argType; /* 0: none. 1: db 2: (-1) */
! 569: void (*xFunc)(sqlite_func*,int,const char**);
! 570: } aFuncs[] = {
! 571: { "min", -1, SQLITE_ARGS, 0, minmaxFunc },
! 572: { "min", 0, 0, 0, 0 },
! 573: { "max", -1, SQLITE_ARGS, 2, minmaxFunc },
! 574: { "max", 0, 0, 2, 0 },
! 575: { "typeof", 1, SQLITE_TEXT, 0, typeofFunc },
! 576: { "length", 1, SQLITE_NUMERIC, 0, lengthFunc },
! 577: { "substr", 3, SQLITE_TEXT, 0, substrFunc },
! 578: { "abs", 1, SQLITE_NUMERIC, 0, absFunc },
! 579: { "round", 1, SQLITE_NUMERIC, 0, roundFunc },
! 580: { "round", 2, SQLITE_NUMERIC, 0, roundFunc },
! 581: { "upper", 1, SQLITE_TEXT, 0, upperFunc },
! 582: { "lower", 1, SQLITE_TEXT, 0, lowerFunc },
! 583: { "coalesce", -1, SQLITE_ARGS, 0, ifnullFunc },
! 584: { "coalesce", 0, 0, 0, 0 },
! 585: { "coalesce", 1, 0, 0, 0 },
! 586: { "ifnull", 2, SQLITE_ARGS, 0, ifnullFunc },
! 587: { "random", -1, SQLITE_NUMERIC, 0, randomFunc },
! 588: { "like", 2, SQLITE_NUMERIC, 0, likeFunc },
! 589: { "glob", 2, SQLITE_NUMERIC, 0, globFunc },
! 590: { "nullif", 2, SQLITE_ARGS, 0, nullifFunc },
! 591: { "sqlite_version",0,SQLITE_TEXT, 0, versionFunc},
! 592: { "quote", 1, SQLITE_ARGS, 0, quoteFunc },
! 593: { "last_insert_rowid", 0, SQLITE_NUMERIC, 1, last_insert_rowid },
! 594: { "change_count", 0, SQLITE_NUMERIC, 1, change_count },
! 595: { "last_statement_change_count",
! 596: 0, SQLITE_NUMERIC, 1, last_statement_change_count },
! 597: #ifdef SQLITE_SOUNDEX
! 598: { "soundex", 1, SQLITE_TEXT, 0, soundexFunc},
! 599: #endif
! 600: #ifdef SQLITE_TEST
! 601: { "randstr", 2, SQLITE_TEXT, 0, randStr },
! 602: #endif
! 603: };
! 604: static struct {
! 605: char *zName;
! 606: signed char nArg;
! 607: signed char dataType;
! 608: u8 argType;
! 609: void (*xStep)(sqlite_func*,int,const char**);
! 610: void (*xFinalize)(sqlite_func*);
! 611: } aAggs[] = {
! 612: { "min", 1, 0, 0, minmaxStep, minMaxFinalize },
! 613: { "max", 1, 0, 2, minmaxStep, minMaxFinalize },
! 614: { "sum", 1, SQLITE_NUMERIC, 0, sumStep, sumFinalize },
! 615: { "avg", 1, SQLITE_NUMERIC, 0, sumStep, avgFinalize },
! 616: { "count", 0, SQLITE_NUMERIC, 0, countStep, countFinalize },
! 617: { "count", 1, SQLITE_NUMERIC, 0, countStep, countFinalize },
! 618: #if 0
! 619: { "stddev", 1, SQLITE_NUMERIC, 0, stdDevStep, stdDevFinalize },
! 620: #endif
! 621: };
! 622: static const char *azTypeFuncs[] = { "min", "max", "typeof" };
! 623: int i;
! 624:
! 625: for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
! 626: void *pArg;
! 627: switch( aFuncs[i].argType ){
! 628: case 0: pArg = 0; break;
! 629: case 1: pArg = db; break;
! 630: case 2: pArg = (void*)(-1); break;
! 631: }
! 632: sqlite_create_function(db, aFuncs[i].zName,
! 633: aFuncs[i].nArg, aFuncs[i].xFunc, pArg);
! 634: if( aFuncs[i].xFunc ){
! 635: sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
! 636: }
! 637: }
! 638: for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
! 639: void *pArg;
! 640: switch( aAggs[i].argType ){
! 641: case 0: pArg = 0; break;
! 642: case 1: pArg = db; break;
! 643: case 2: pArg = (void*)(-1); break;
! 644: }
! 645: sqlite_create_aggregate(db, aAggs[i].zName,
! 646: aAggs[i].nArg, aAggs[i].xStep, aAggs[i].xFinalize, pArg);
! 647: sqlite_function_type(db, aAggs[i].zName, aAggs[i].dataType);
! 648: }
! 649: for(i=0; i<sizeof(azTypeFuncs)/sizeof(azTypeFuncs[0]); i++){
! 650: int n = strlen(azTypeFuncs[i]);
! 651: FuncDef *p = sqliteHashFind(&db->aFunc, azTypeFuncs[i], n);
! 652: while( p ){
! 653: p->includeTypes = 1;
! 654: p = p->pNext;
! 655: }
! 656: }
! 657: sqliteRegisterDateTimeFunctions(db);
! 658: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to func.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src