src/func.c

   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-language implementations for many of the SQL
  13 ** functions of SQLite.  (Some function, and in particular the date and
  14 ** time functions, are implemented separately.)
  15 */
  16 #include "sqliteInt.h"
  17 #include <stdlib.h>
  18 #include <assert.h>
  19 #include "vdbeInt.h"
  20
  21 /*
  22 ** Return the collating function associated with a function.
  23 */
  24 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
  25   VdbeOp *pOp;
  26   assert( context->pVdbe!=0 );
  27   pOp = &context->pVdbe->aOp[context->iOp-1];
  28   assert( pOp->opcode==OP_CollSeq );
  29   assert( pOp->p4type==P4_COLLSEQ );
  30   return pOp->p4.pColl;
  31 }
  32
  33 /*
  34 ** Indicate that the accumulator load should be skipped on this
  35 ** iteration of the aggregate loop.
  36 */
  37 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){
  38   context->skipFlag = 1;
  39 }
  40
  41 /*
  42 ** Implementation of the non-aggregate min() and max() functions
  43 */
  44 static void minmaxFunc(
  45   sqlite3_context *context,
  46   int argc,
  47   sqlite3_value **argv
  48 ){
  49   int i;
  50   int mask;    /* 0 for min() or 0xffffffff for max() */
  51   int iBest;
  52   CollSeq *pColl;
  53
  54   assert( argc>1 );
  55   mask = sqlite3_user_data(context)==0 ? 0 : -1;
  56   pColl = sqlite3GetFuncCollSeq(context);
  57   assert( pColl );
  58   assert( mask==-1 || mask==0 );
  59   iBest = 0;
  60   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  61   for(i=1; i<argc; i++){
  62     if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
  63     if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
  64       testcase( mask==0 );
  65       iBest = i;
  66     }
  67   }
  68   sqlite3_result_value(context, argv[iBest]);
  69 }
  70
  71 /*
  72 ** Return the type of the argument.
  73 */
  74 static void typeofFunc(
  75   sqlite3_context *context,
  76   int NotUsed,
  77   sqlite3_value **argv
  78 ){
  79   const char *z = 0;
  80   UNUSED_PARAMETER(NotUsed);
  81   switch( sqlite3_value_type(argv[0]) ){
  82     case SQLITE_INTEGER: z = "integer"; break;
  83     case SQLITE_TEXT:    z = "text";    break;
  84     case SQLITE_FLOAT:   z = "real";    break;
  85     case SQLITE_BLOB:    z = "blob";    break;
  86     default:             z = "null";    break;
  87   }
  88   sqlite3_result_text(context, z, -1, SQLITE_STATIC);
  89 }
  90
  91
  92 /*
  93 ** Implementation of the length() function
  94 */
  95 static void lengthFunc(
  96   sqlite3_context *context,
  97   int argc,
  98   sqlite3_value **argv
  99 ){
 100   int len;
 101
 102   assert( argc==1 );
 103   UNUSED_PARAMETER(argc);
 104   switch( sqlite3_value_type(argv[0]) ){
 105     case SQLITE_BLOB:
 106     case SQLITE_INTEGER:
 107     case SQLITE_FLOAT: {
 108       sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
 109       break;
 110     }
 111     case SQLITE_TEXT: {
 112       const unsigned char *z = sqlite3_value_text(argv[0]);
 113       if( z==0 ) return;
 114       len = 0;
 115       while( *z ){
 116         len++;
 117         SQLITE_SKIP_UTF8(z);
 118       }
 119       sqlite3_result_int(context, len);
 120       break;
 121     }
 122     default: {
 123       sqlite3_result_null(context);
 124       break;
 125     }
 126   }
 127 }
 128
 129 /*
 130 ** Implementation of the abs() function.
 131 **
 132 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
 133 ** the numeric argument X.
 134 */
 135 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 136   assert( argc==1 );
 137   UNUSED_PARAMETER(argc);
 138   switch( sqlite3_value_type(argv[0]) ){
 139     case SQLITE_INTEGER: {
 140       i64 iVal = sqlite3_value_int64(argv[0]);
 141       if( iVal<0 ){
 142         if( iVal==SMALLEST_INT64 ){
 143           /* IMP: R-31676-45509 If X is the integer -9223372036854775808
 144           ** then abs(X) throws an integer overflow error since there is no
 145           ** equivalent positive 64-bit two complement value. */
 146           sqlite3_result_error(context, "integer overflow", -1);
 147           return;
 148         }
 149         iVal = -iVal;
 150       }
 151       sqlite3_result_int64(context, iVal);
 152       break;
 153     }
 154     case SQLITE_NULL: {
 155       /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
 156       sqlite3_result_null(context);
 157       break;
 158     }
 159     default: {
 160       /* Because sqlite3_value_double() returns 0.0 if the argument is not
 161       ** something that can be converted into a number, we have:
 162       ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
 163       ** that cannot be converted to a numeric value.
 164       */
 165       double rVal = sqlite3_value_double(argv[0]);
 166       if( rVal<0 ) rVal = -rVal;
 167       sqlite3_result_double(context, rVal);
 168       break;
 169     }
 170   }
 171 }
 172
 173 /*
 174 ** Implementation of the instr() function.
 175 **
 176 ** instr(haystack,needle) finds the first occurrence of needle
 177 ** in haystack and returns the number of previous characters plus 1,
 178 ** or 0 if needle does not occur within haystack.
 179 **
 180 ** If both haystack and needle are BLOBs, then the result is one more than
 181 ** the number of bytes in haystack prior to the first occurrence of needle,
 182 ** or 0 if needle never occurs in haystack.
 183 */
 184 static void instrFunc(
 185   sqlite3_context *context,
 186   int argc,
 187   sqlite3_value **argv
 188 ){
 189   const unsigned char *zHaystack;
 190   const unsigned char *zNeedle;
 191   int nHaystack;
 192   int nNeedle;
 193   int typeHaystack, typeNeedle;
 194   int N = 1;
 195   int isText;
 196
 197   UNUSED_PARAMETER(argc);
 198   typeHaystack = sqlite3_value_type(argv[0]);
 199   typeNeedle = sqlite3_value_type(argv[1]);
 200   if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;
 201   nHaystack = sqlite3_value_bytes(argv[0]);
 202   nNeedle = sqlite3_value_bytes(argv[1]);
 203   if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
 204     zHaystack = sqlite3_value_blob(argv[0]);
 205     zNeedle = sqlite3_value_blob(argv[1]);
 206     isText = 0;
 207   }else{
 208     zHaystack = sqlite3_value_text(argv[0]);
 209     zNeedle = sqlite3_value_text(argv[1]);
 210     isText = 1;
 211   }
 212   while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
 213     N++;
 214     do{
 215       nHaystack--;
 216       zHaystack++;
 217     }while( isText && (zHaystack[0]&0xc0)==0x80 );
 218   }
 219   if( nNeedle>nHaystack ) N = 0;
 220   sqlite3_result_int(context, N);
 221 }
 222
 223 /*
 224 ** Implementation of the printf() function.
 225 */
 226 static void printfFunc(
 227   sqlite3_context *context,
 228   int argc,
 229   sqlite3_value **argv
 230 ){
 231   PrintfArguments x;
 232   StrAccum str;
 233   const char *zFormat;
 234   int n;
 235   sqlite3 *db = sqlite3_context_db_handle(context);
 236
 237   if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
 238     x.nArg = argc-1;
 239     x.nUsed = 0;
 240     x.apArg = argv+1;
 241     sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
 242     str.printfFlags = SQLITE_PRINTF_SQLFUNC;
 243     sqlite3XPrintf(&str, zFormat, &x);
 244     n = str.nChar;
 245     sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
 246                         SQLITE_DYNAMIC);
 247   }
 248 }
 249
 250 /*
 251 ** Implementation of the substr() function.
 252 **
 253 ** substr(x,p1,p2)  returns p2 characters of x[] beginning with p1.
 254 ** p1 is 1-indexed.  So substr(x,1,1) returns the first character
 255 ** of x.  If x is text, then we actually count UTF-8 characters.
 256 ** If x is a blob, then we count bytes.
 257 **
 258 ** If p1 is negative, then we begin abs(p1) from the end of x[].
 259 **
 260 ** If p2 is negative, return the p2 characters preceding p1.
 261 */
 262 static void substrFunc(
 263   sqlite3_context *context,
 264   int argc,
 265   sqlite3_value **argv
 266 ){
 267   const unsigned char *z;
 268   const unsigned char *z2;
 269   int len;
 270   int p0type;
 271   i64 p1, p2;
 272   int negP2 = 0;
 273
 274   assert( argc==3 || argc==2 );
 275   if( sqlite3_value_type(argv[1])==SQLITE_NULL
 276    || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
 277   ){
 278     return;
 279   }
 280   p0type = sqlite3_value_type(argv[0]);
 281   p1 = sqlite3_value_int(argv[1]);
 282   if( p0type==SQLITE_BLOB ){
 283     len = sqlite3_value_bytes(argv[0]);
 284     z = sqlite3_value_blob(argv[0]);
 285     if( z==0 ) return;
 286     assert( len==sqlite3_value_bytes(argv[0]) );
 287   }else{
 288     z = sqlite3_value_text(argv[0]);
 289     if( z==0 ) return;
 290     len = 0;
 291     if( p1<0 ){
 292       for(z2=z; *z2; len++){
 293         SQLITE_SKIP_UTF8(z2);
 294       }
 295     }
 296   }
 297 #ifdef SQLITE_SUBSTR_COMPATIBILITY
 298   /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
 299   ** as substr(X,1,N) - it returns the first N characters of X.  This
 300   ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
 301   ** from 2009-02-02 for compatibility of applications that exploited the
 302   ** old buggy behavior. */
 303   if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */
 304 #endif
 305   if( argc==3 ){
 306     p2 = sqlite3_value_int(argv[2]);
 307     if( p2<0 ){
 308       p2 = -p2;
 309       negP2 = 1;
 310     }
 311   }else{
 312     p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
 313   }
 314   if( p1<0 ){
 315     p1 += len;
 316     if( p1<0 ){
 317       p2 += p1;
 318       if( p2<0 ) p2 = 0;
 319       p1 = 0;
 320     }
 321   }else if( p1>0 ){
 322     p1--;
 323   }else if( p2>0 ){
 324     p2--;
 325   }
 326   if( negP2 ){
 327     p1 -= p2;
 328     if( p1<0 ){
 329       p2 += p1;
 330       p1 = 0;
 331     }
 332   }
 333   assert( p1>=0 && p2>=0 );
 334   if( p0type!=SQLITE_BLOB ){
 335     while( *z && p1 ){
 336       SQLITE_SKIP_UTF8(z);
 337       p1--;
 338     }
 339     for(z2=z; *z2 && p2; p2--){
 340       SQLITE_SKIP_UTF8(z2);
 341     }
 342     sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
 343                           SQLITE_UTF8);
 344   }else{
 345     if( p1+p2>len ){
 346       p2 = len-p1;
 347       if( p2<0 ) p2 = 0;
 348     }
 349     sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
 350   }
 351 }
 352
 353 /*
 354 ** Implementation of the round() function
 355 */
 356 #ifndef SQLITE_OMIT_FLOATING_POINT
 357 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 358   int n = 0;
 359   double r;
 360   char *zBuf;
 361   assert( argc==1 || argc==2 );
 362   if( argc==2 ){
 363     if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
 364     n = sqlite3_value_int(argv[1]);
 365     if( n>30 ) n = 30;
 366     if( n<0 ) n = 0;
 367   }
 368   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
 369   r = sqlite3_value_double(argv[0]);
 370   /* If Y==0 and X will fit in a 64-bit int,
 371   ** handle the rounding directly,
 372   ** otherwise use printf.
 373   */
 374   if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
 375     r = (double)((sqlite_int64)(r+0.5));
 376   }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
 377     r = -(double)((sqlite_int64)((-r)+0.5));
 378   }else{
 379     zBuf = sqlite3_mprintf("%.*f",n,r);
 380     if( zBuf==0 ){
 381       sqlite3_result_error_nomem(context);
 382       return;
 383     }
 384     sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
 385     sqlite3_free(zBuf);
 386   }
 387   sqlite3_result_double(context, r);
 388 }
 389 #endif
 390
 391 /*
 392 ** Allocate nByte bytes of space using sqlite3Malloc(). If the
 393 ** allocation fails, call sqlite3_result_error_nomem() to notify
 394 ** the database handle that malloc() has failed and return NULL.
 395 ** If nByte is larger than the maximum string or blob length, then
 396 ** raise an SQLITE_TOOBIG exception and return NULL.
 397 */
 398 static void *contextMalloc(sqlite3_context *context, i64 nByte){
 399   char *z;
 400   sqlite3 *db = sqlite3_context_db_handle(context);
 401   assert( nByte>0 );
 402   testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
 403   testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
 404   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
 405     sqlite3_result_error_toobig(context);
 406     z = 0;
 407   }else{
 408     z = sqlite3Malloc(nByte);
 409     if( !z ){
 410       sqlite3_result_error_nomem(context);
 411     }
 412   }
 413   return z;
 414 }
 415
 416 /*
 417 ** Implementation of the upper() and lower() SQL functions.
 418 */
 419 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 420   char *z1;
 421   const char *z2;
 422   int i, n;
 423   UNUSED_PARAMETER(argc);
 424   z2 = (char*)sqlite3_value_text(argv[0]);
 425   n = sqlite3_value_bytes(argv[0]);
 426   /* Verify that the call to _bytes() does not invalidate the _text() pointer */
 427   assert( z2==(char*)sqlite3_value_text(argv[0]) );
 428   if( z2 ){
 429     z1 = contextMalloc(context, ((i64)n)+1);
 430     if( z1 ){
 431       for(i=0; i<n; i++){
 432         z1[i] = (char)sqlite3Toupper(z2[i]);
 433       }
 434       sqlite3_result_text(context, z1, n, sqlite3_free);
 435     }
 436   }
 437 }
 438 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 439   char *z1;
 440   const char *z2;
 441   int i, n;
 442   UNUSED_PARAMETER(argc);
 443   z2 = (char*)sqlite3_value_text(argv[0]);
 444   n = sqlite3_value_bytes(argv[0]);
 445   /* Verify that the call to _bytes() does not invalidate the _text() pointer */
 446   assert( z2==(char*)sqlite3_value_text(argv[0]) );
 447   if( z2 ){
 448     z1 = contextMalloc(context, ((i64)n)+1);
 449     if( z1 ){
 450       for(i=0; i<n; i++){
 451         z1[i] = sqlite3Tolower(z2[i]);
 452       }
 453       sqlite3_result_text(context, z1, n, sqlite3_free);
 454     }
 455   }
 456 }
 457
 458 /*
 459 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
 460 ** as VDBE code so that unused argument values do not have to be computed.
 461 ** However, we still need some kind of function implementation for this
 462 ** routines in the function table.  The noopFunc macro provides this.
 463 ** noopFunc will never be called so it doesn't matter what the implementation
 464 ** is.  We might as well use the "version()" function as a substitute.
 465 */
 466 #define noopFunc versionFunc   /* Substitute function - never called */
 467
 468 /*
 469 ** Implementation of random().  Return a random integer.
 470 */
 471 static void randomFunc(
 472   sqlite3_context *context,
 473   int NotUsed,
 474   sqlite3_value **NotUsed2
 475 ){
 476   sqlite_int64 r;
 477   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 478   sqlite3_randomness(sizeof(r), &r);
 479   if( r<0 ){
 480     /* We need to prevent a random number of 0x8000000000000000
 481     ** (or -9223372036854775808) since when you do abs() of that
 482     ** number of you get the same value back again.  To do this
 483     ** in a way that is testable, mask the sign bit off of negative
 484     ** values, resulting in a positive value.  Then take the
 485     ** 2s complement of that positive value.  The end result can
 486     ** therefore be no less than -9223372036854775807.
 487     */
 488     r = -(r & LARGEST_INT64);
 489   }
 490   sqlite3_result_int64(context, r);
 491 }
 492
 493 /*
 494 ** Implementation of randomblob(N).  Return a random blob
 495 ** that is N bytes long.
 496 */
 497 static void randomBlob(
 498   sqlite3_context *context,
 499   int argc,
 500   sqlite3_value **argv
 501 ){
 502   int n;
 503   unsigned char *p;
 504   assert( argc==1 );
 505   UNUSED_PARAMETER(argc);
 506   n = sqlite3_value_int(argv[0]);
 507   if( n<1 ){
 508     n = 1;
 509   }
 510   p = contextMalloc(context, n);
 511   if( p ){
 512     sqlite3_randomness(n, p);
 513     sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
 514   }
 515 }
 516
 517 /*
 518 ** Implementation of the last_insert_rowid() SQL function.  The return
 519 ** value is the same as the sqlite3_last_insert_rowid() API function.
 520 */
 521 static void last_insert_rowid(
 522   sqlite3_context *context,
 523   int NotUsed,
 524   sqlite3_value **NotUsed2
 525 ){
 526   sqlite3 *db = sqlite3_context_db_handle(context);
 527   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 528   /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
 529   ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
 530   ** function. */
 531   sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
 532 }
 533
 534 /*
 535 ** Implementation of the changes() SQL function.
 536 **
 537 ** IMP: R-62073-11209 The changes() SQL function is a wrapper
 538 ** around the sqlite3_changes() C/C++ function and hence follows the same
 539 ** rules for counting changes.
 540 */
 541 static void changes(
 542   sqlite3_context *context,
 543   int NotUsed,
 544   sqlite3_value **NotUsed2
 545 ){
 546   sqlite3 *db = sqlite3_context_db_handle(context);
 547   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 548   sqlite3_result_int(context, sqlite3_changes(db));
 549 }
 550
 551 /*
 552 ** Implementation of the total_changes() SQL function.  The return value is
 553 ** the same as the sqlite3_total_changes() API function.
 554 */
 555 static void total_changes(
 556   sqlite3_context *context,
 557   int NotUsed,
 558   sqlite3_value **NotUsed2
 559 ){
 560   sqlite3 *db = sqlite3_context_db_handle(context);
 561   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 562   /* IMP: R-52756-41993 This function is a wrapper around the
 563   ** sqlite3_total_changes() C/C++ interface. */
 564   sqlite3_result_int(context, sqlite3_total_changes(db));
 565 }
 566
 567 /*
 568 ** A structure defining how to do GLOB-style comparisons.
 569 */
 570 struct compareInfo {
 571   u8 matchAll;          /* "*" or "%" */
 572   u8 matchOne;          /* "?" or "_" */
 573   u8 matchSet;          /* "[" or 0 */
 574   u8 noCase;            /* true to ignore case differences */
 575 };
 576
 577 /*
 578 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
 579 ** character is exactly one byte in size.  Also, provde the Utf8Read()
 580 ** macro for fast reading of the next character in the common case where
 581 ** the next character is ASCII.
 582 */
 583 #if defined(SQLITE_EBCDIC)
 584 # define sqlite3Utf8Read(A)        (*((*A)++))
 585 # define Utf8Read(A)               (*(A++))
 586 #else
 587 # define Utf8Read(A)               (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))
 588 #endif
 589
 590 static const struct compareInfo globInfo = { '*', '?', '[', 0 };
 591 /* The correct SQL-92 behavior is for the LIKE operator to ignore
 592 ** case.  Thus  'a' LIKE 'A' would be true. */
 593 static const struct compareInfo likeInfoNorm = { '%', '_',   0, 1 };
 594 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
 595 ** is case sensitive causing 'a' LIKE 'A' to be false */
 596 static const struct compareInfo likeInfoAlt = { '%', '_',   0, 0 };
 597
 598 /*
 599 ** Compare two UTF-8 strings for equality where the first string can
 600 ** potentially be a "glob" or "like" expression.  Return true (1) if they
 601 ** are the same and false (0) if they are different.
 602 **
 603 ** Globbing rules:
 604 **
 605 **      '*'       Matches any sequence of zero or more characters.
 606 **
 607 **      '?'       Matches exactly one character.
 608 **
 609 **     [...]      Matches one character from the enclosed list of
 610 **                characters.
 611 **
 612 **     [^...]     Matches one character not in the enclosed list.
 613 **
 614 ** With the [...] and [^...] matching, a ']' character can be included
 615 ** in the list by making it the first character after '[' or '^'.  A
 616 ** range of characters can be specified using '-'.  Example:
 617 ** "[a-z]" matches any single lower-case letter.  To match a '-', make
 618 ** it the last character in the list.
 619 **
 620 ** Like matching rules:
 621 **
 622 **      '%'       Matches any sequence of zero or more characters
 623 **
 624 ***     '_'       Matches any one character
 625 **
 626 **      Ec        Where E is the "esc" character and c is any other
 627 **                character, including '%', '_', and esc, match exactly c.
 628 **
 629 ** The comments within this routine usually assume glob matching.
 630 **
 631 ** This routine is usually quick, but can be N**2 in the worst case.
 632 */
 633 static int patternCompare(
 634   const u8 *zPattern,              /* The glob pattern */
 635   const u8 *zString,               /* The string to compare against the glob */
 636   const struct compareInfo *pInfo, /* Information about how to do the compare */
 637   u32 matchOther                   /* The escape char (LIKE) or '[' (GLOB) */
 638 ){
 639   u32 c, c2;                       /* Next pattern and input string chars */
 640   u32 matchOne = pInfo->matchOne;  /* "?" or "_" */
 641   u32 matchAll = pInfo->matchAll;  /* "*" or "%" */
 642   u8 noCase = pInfo->noCase;       /* True if uppercase==lowercase */
 643   const u8 *zEscaped = 0;          /* One past the last escaped input char */
 644
 645   while( (c = Utf8Read(zPattern))!=0 ){
 646     if( c==matchAll ){  /* Match "*" */
 647       /* Skip over multiple "*" characters in the pattern.  If there
 648       ** are also "?" characters, skip those as well, but consume a
 649       ** single character of the input string for each "?" skipped */
 650       while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){
 651         if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
 652           return 0;
 653         }
 654       }
 655       if( c==0 ){
 656         return 1;   /* "*" at the end of the pattern matches */
 657       }else if( c==matchOther ){
 658         if( pInfo->matchSet==0 ){
 659           c = sqlite3Utf8Read(&zPattern);
 660           if( c==0 ) return 0;
 661         }else{
 662           /* "[...]" immediately follows the "*".  We have to do a slow
 663           ** recursive search in this case, but it is an unusual case. */
 664           assert( matchOther<0x80 );  /* '[' is a single-byte character */
 665           while( *zString
 666                  && patternCompare(&zPattern[-1],zString,pInfo,matchOther)==0 ){
 667             SQLITE_SKIP_UTF8(zString);
 668           }
 669           return *zString!=0;
 670         }
 671       }
 672
 673       /* At this point variable c contains the first character of the
 674       ** pattern string past the "*".  Search in the input string for the
 675       ** first matching character and recursively contine the match from
 676       ** that point.
 677       **
 678       ** For a case-insensitive search, set variable cx to be the same as
 679       ** c but in the other case and search the input string for either
 680       ** c or cx.
 681       */
 682       if( c<=0x80 ){
 683         u32 cx;
 684         if( noCase ){
 685           cx = sqlite3Toupper(c);
 686           c = sqlite3Tolower(c);
 687         }else{
 688           cx = c;
 689         }
 690         while( (c2 = *(zString++))!=0 ){
 691           if( c2!=c && c2!=cx ) continue;
 692           if( patternCompare(zPattern,zString,pInfo,matchOther) ) return 1;
 693         }
 694       }else{
 695         while( (c2 = Utf8Read(zString))!=0 ){
 696           if( c2!=c ) continue;
 697           if( patternCompare(zPattern,zString,pInfo,matchOther) ) return 1;
 698         }
 699       }
 700       return 0;
 701     }
 702     if( c==matchOther ){
 703       if( pInfo->matchSet==0 ){
 704         c = sqlite3Utf8Read(&zPattern);
 705         if( c==0 ) return 0;
 706         zEscaped = zPattern;
 707       }else{
 708         u32 prior_c = 0;
 709         int seen = 0;
 710         int invert = 0;
 711         c = sqlite3Utf8Read(&zString);
 712         if( c==0 ) return 0;
 713         c2 = sqlite3Utf8Read(&zPattern);
 714         if( c2=='^' ){
 715           invert = 1;
 716           c2 = sqlite3Utf8Read(&zPattern);
 717         }
 718         if( c2==']' ){
 719           if( c==']' ) seen = 1;
 720           c2 = sqlite3Utf8Read(&zPattern);
 721         }
 722         while( c2 && c2!=']' ){
 723           if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
 724             c2 = sqlite3Utf8Read(&zPattern);
 725             if( c>=prior_c && c<=c2 ) seen = 1;
 726             prior_c = 0;
 727           }else{
 728             if( c==c2 ){
 729               seen = 1;
 730             }
 731             prior_c = c2;
 732           }
 733           c2 = sqlite3Utf8Read(&zPattern);
 734         }
 735         if( c2==0 || (seen ^ invert)==0 ){
 736           return 0;
 737         }
 738         continue;
 739       }
 740     }
 741     c2 = Utf8Read(zString);
 742     if( c==c2 ) continue;
 743     if( noCase  && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){
 744       continue;
 745     }
 746     if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;
 747     return 0;
 748   }
 749   return *zString==0;
 750 }
 751
 752 /*
 753 ** The sqlite3_strglob() interface.
 754 */
 755 int sqlite3_strglob(const char *zGlobPattern, const char *zString){
 756   return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[')==0;
 757 }
 758
 759 /*
 760 ** The sqlite3_strlike() interface.
 761 */
 762 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){
 763   return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc)==0;
 764 }
 765
 766 /*
 767 ** Count the number of times that the LIKE operator (or GLOB which is
 768 ** just a variation of LIKE) gets called.  This is used for testing
 769 ** only.
 770 */
 771 #ifdef SQLITE_TEST
 772 int sqlite3_like_count = 0;
 773 #endif
 774
 775
 776 /*
 777 ** Implementation of the like() SQL function.  This function implements
 778 ** the build-in LIKE operator.  The first argument to the function is the
 779 ** pattern and the second argument is the string.  So, the SQL statements:
 780 **
 781 **       A LIKE B
 782 **
 783 ** is implemented as like(B,A).
 784 **
 785 ** This same function (with a different compareInfo structure) computes
 786 ** the GLOB operator.
 787 */
 788 static void likeFunc(
 789   sqlite3_context *context,
 790   int argc,
 791   sqlite3_value **argv
 792 ){
 793   const unsigned char *zA, *zB;
 794   u32 escape;
 795   int nPat;
 796   sqlite3 *db = sqlite3_context_db_handle(context);
 797   struct compareInfo *pInfo = sqlite3_user_data(context);
 798
 799 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
 800   if( sqlite3_value_type(argv[0])==SQLITE_BLOB
 801    || sqlite3_value_type(argv[1])==SQLITE_BLOB
 802   ){
 803 #ifdef SQLITE_TEST
 804     sqlite3_like_count++;
 805 #endif
 806     sqlite3_result_int(context, 0);
 807     return;
 808   }
 809 #endif
 810   zB = sqlite3_value_text(argv[0]);
 811   zA = sqlite3_value_text(argv[1]);
 812
 813   /* Limit the length of the LIKE or GLOB pattern to avoid problems
 814   ** of deep recursion and N*N behavior in patternCompare().
 815   */
 816   nPat = sqlite3_value_bytes(argv[0]);
 817   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
 818   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
 819   if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
 820     sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
 821     return;
 822   }
 823   assert( zB==sqlite3_value_text(argv[0]) );  /* Encoding did not change */
 824
 825   if( argc==3 ){
 826     /* The escape character string must consist of a single UTF-8 character.
 827     ** Otherwise, return an error.
 828     */
 829     const unsigned char *zEsc = sqlite3_value_text(argv[2]);
 830     if( zEsc==0 ) return;
 831     if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
 832       sqlite3_result_error(context,
 833           "ESCAPE expression must be a single character", -1);
 834       return;
 835     }
 836     escape = sqlite3Utf8Read(&zEsc);
 837   }else{
 838     escape = pInfo->matchSet;
 839   }
 840   if( zA && zB ){
 841 #ifdef SQLITE_TEST
 842     sqlite3_like_count++;
 843 #endif
 844     sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
 845   }
 846 }
 847
 848 /*
 849 ** Implementation of the NULLIF(x,y) function.  The result is the first
 850 ** argument if the arguments are different.  The result is NULL if the
 851 ** arguments are equal to each other.
 852 */
 853 static void nullifFunc(
 854   sqlite3_context *context,
 855   int NotUsed,
 856   sqlite3_value **argv
 857 ){
 858   CollSeq *pColl = sqlite3GetFuncCollSeq(context);
 859   UNUSED_PARAMETER(NotUsed);
 860   if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
 861     sqlite3_result_value(context, argv[0]);
 862   }
 863 }
 864
 865 /*
 866 ** Implementation of the sqlite_version() function.  The result is the version
 867 ** of the SQLite library that is running.
 868 */
 869 static void versionFunc(
 870   sqlite3_context *context,
 871   int NotUsed,
 872   sqlite3_value **NotUsed2
 873 ){
 874   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 875   /* IMP: R-48699-48617 This function is an SQL wrapper around the
 876   ** sqlite3_libversion() C-interface. */
 877   sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
 878 }
 879
 880 /*
 881 ** Implementation of the sqlite_source_id() function. The result is a string
 882 ** that identifies the particular version of the source code used to build
 883 ** SQLite.
 884 */
 885 static void sourceidFunc(
 886   sqlite3_context *context,
 887   int NotUsed,
 888   sqlite3_value **NotUsed2
 889 ){
 890   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 891   /* IMP: R-24470-31136 This function is an SQL wrapper around the
 892   ** sqlite3_sourceid() C interface. */
 893   sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
 894 }
 895
 896 /*
 897 ** Implementation of the sqlite_log() function.  This is a wrapper around
 898 ** sqlite3_log().  The return value is NULL.  The function exists purely for
 899 ** its side-effects.
 900 */
 901 static void errlogFunc(
 902   sqlite3_context *context,
 903   int argc,
 904   sqlite3_value **argv
 905 ){
 906   UNUSED_PARAMETER(argc);
 907   UNUSED_PARAMETER(context);
 908   sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
 909 }
 910
 911 /*
 912 ** Implementation of the sqlite_compileoption_used() function.
 913 ** The result is an integer that identifies if the compiler option
 914 ** was used to build SQLite.
 915 */
 916 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 917 static void compileoptionusedFunc(
 918   sqlite3_context *context,
 919   int argc,
 920   sqlite3_value **argv
 921 ){
 922   const char *zOptName;
 923   assert( argc==1 );
 924   UNUSED_PARAMETER(argc);
 925   /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
 926   ** function is a wrapper around the sqlite3_compileoption_used() C/C++
 927   ** function.
 928   */
 929   if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
 930     sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
 931   }
 932 }
 933 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 934
 935 /*
 936 ** Implementation of the sqlite_compileoption_get() function.
 937 ** The result is a string that identifies the compiler options
 938 ** used to build SQLite.
 939 */
 940 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 941 static void compileoptiongetFunc(
 942   sqlite3_context *context,
 943   int argc,
 944   sqlite3_value **argv
 945 ){
 946   int n;
 947   assert( argc==1 );
 948   UNUSED_PARAMETER(argc);
 949   /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
 950   ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
 951   */
 952   n = sqlite3_value_int(argv[0]);
 953   sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
 954 }
 955 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 956
 957 /* Array for converting from half-bytes (nybbles) into ASCII hex
 958 ** digits. */
 959 static const char hexdigits[] = {
 960   '0', '1', '2', '3', '4', '5', '6', '7',
 961   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 962 };
 963
 964 /*
 965 ** Implementation of the QUOTE() function.  This function takes a single
 966 ** argument.  If the argument is numeric, the return value is the same as
 967 ** the argument.  If the argument is NULL, the return value is the string
 968 ** "NULL".  Otherwise, the argument is enclosed in single quotes with
 969 ** single-quote escapes.
 970 */
 971 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
 972   assert( argc==1 );
 973   UNUSED_PARAMETER(argc);
 974   switch( sqlite3_value_type(argv[0]) ){
 975     case SQLITE_FLOAT: {
 976       double r1, r2;
 977       char zBuf[50];
 978       r1 = sqlite3_value_double(argv[0]);
 979       sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
 980       sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8);
 981       if( r1!=r2 ){
 982         sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
 983       }
 984       sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
 985       break;
 986     }
 987     case SQLITE_INTEGER: {
 988       sqlite3_result_value(context, argv[0]);
 989       break;
 990     }
 991     case SQLITE_BLOB: {
 992       char *zText = 0;
 993       char const *zBlob = sqlite3_value_blob(argv[0]);
 994       int nBlob = sqlite3_value_bytes(argv[0]);
 995       assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
 996       zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);
 997       if( zText ){
 998         int i;
 999         for(i=0; i<nBlob; i++){
1000           zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
1001           zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
1002         }
1003         zText[(nBlob*2)+2] = '\'';
1004         zText[(nBlob*2)+3] = '\0';
1005         zText[0] = 'X';
1006         zText[1] = '\'';
1007         sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
1008         sqlite3_free(zText);
1009       }
1010       break;
1011     }
1012     case SQLITE_TEXT: {
1013       int i,j;
1014       u64 n;
1015       const unsigned char *zArg = sqlite3_value_text(argv[0]);
1016       char *z;
1017
1018       if( zArg==0 ) return;
1019       for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
1020       z = contextMalloc(context, ((i64)i)+((i64)n)+3);
1021       if( z ){
1022         z[0] = '\'';
1023         for(i=0, j=1; zArg[i]; i++){
1024           z[j++] = zArg[i];
1025           if( zArg[i]=='\'' ){
1026             z[j++] = '\'';
1027           }
1028         }
1029         z[j++] = '\'';
1030         z[j] = 0;
1031         sqlite3_result_text(context, z, j, sqlite3_free);
1032       }
1033       break;
1034     }
1035     default: {
1036       assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
1037       sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
1038       break;
1039     }
1040   }
1041 }
1042
1043 /*
1044 ** The unicode() function.  Return the integer unicode code-point value
1045 ** for the first character of the input string.
1046 */
1047 static void unicodeFunc(
1048   sqlite3_context *context,
1049   int argc,
1050   sqlite3_value **argv
1051 ){
1052   const unsigned char *z = sqlite3_value_text(argv[0]);
1053   (void)argc;
1054   if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
1055 }
1056
1057 /*
1058 ** The char() function takes zero or more arguments, each of which is
1059 ** an integer.  It constructs a string where each character of the string
1060 ** is the unicode character for the corresponding integer argument.
1061 */
1062 static void charFunc(
1063   sqlite3_context *context,
1064   int argc,
1065   sqlite3_value **argv
1066 ){
1067   unsigned char *z, *zOut;
1068   int i;
1069   zOut = z = sqlite3_malloc64( argc*4+1 );
1070   if( z==0 ){
1071     sqlite3_result_error_nomem(context);
1072     return;
1073   }
1074   for(i=0; i<argc; i++){
1075     sqlite3_int64 x;
1076     unsigned c;
1077     x = sqlite3_value_int64(argv[i]);
1078     if( x<0 || x>0x10ffff ) x = 0xfffd;
1079     c = (unsigned)(x & 0x1fffff);
1080     if( c<0x00080 ){
1081       *zOut++ = (u8)(c&0xFF);
1082     }else if( c<0x00800 ){
1083       *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
1084       *zOut++ = 0x80 + (u8)(c & 0x3F);
1085     }else if( c<0x10000 ){
1086       *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
1087       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1088       *zOut++ = 0x80 + (u8)(c & 0x3F);
1089     }else{
1090       *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
1091       *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
1092       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1093       *zOut++ = 0x80 + (u8)(c & 0x3F);
1094     }                                                    \
1095   }
1096   sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
1097 }
1098
1099 /*
1100 ** The hex() function.  Interpret the argument as a blob.  Return
1101 ** a hexadecimal rendering as text.
1102 */
1103 static void hexFunc(
1104   sqlite3_context *context,
1105   int argc,
1106   sqlite3_value **argv
1107 ){
1108   int i, n;
1109   const unsigned char *pBlob;
1110   char *zHex, *z;
1111   assert( argc==1 );
1112   UNUSED_PARAMETER(argc);
1113   pBlob = sqlite3_value_blob(argv[0]);
1114   n = sqlite3_value_bytes(argv[0]);
1115   assert( pBlob==sqlite3_value_blob(argv[0]) );  /* No encoding change */
1116   z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
1117   if( zHex ){
1118     for(i=0; i<n; i++, pBlob++){
1119       unsigned char c = *pBlob;
1120       *(z++) = hexdigits[(c>>4)&0xf];
1121       *(z++) = hexdigits[c&0xf];
1122     }
1123     *z = 0;
1124     sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1125   }
1126 }
1127
1128 /*
1129 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1130 */
1131 static void zeroblobFunc(
1132   sqlite3_context *context,
1133   int argc,
1134   sqlite3_value **argv
1135 ){
1136   i64 n;
1137   int rc;
1138   assert( argc==1 );
1139   UNUSED_PARAMETER(argc);
1140   n = sqlite3_value_int64(argv[0]);
1141   if( n<0 ) n = 0;
1142   rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
1143   if( rc ){
1144     sqlite3_result_error_code(context, rc);
1145   }
1146 }
1147
1148 /*
1149 ** The replace() function.  Three arguments are all strings: call
1150 ** them A, B, and C. The result is also a string which is derived
1151 ** from A by replacing every occurrence of B with C.  The match
1152 ** must be exact.  Collating sequences are not used.
1153 */
1154 static void replaceFunc(
1155   sqlite3_context *context,
1156   int argc,
1157   sqlite3_value **argv
1158 ){
1159   const unsigned char *zStr;        /* The input string A */
1160   const unsigned char *zPattern;    /* The pattern string B */
1161   const unsigned char *zRep;        /* The replacement string C */
1162   unsigned char *zOut;              /* The output */
1163   int nStr;                /* Size of zStr */
1164   int nPattern;            /* Size of zPattern */
1165   int nRep;                /* Size of zRep */
1166   i64 nOut;                /* Maximum size of zOut */
1167   int loopLimit;           /* Last zStr[] that might match zPattern[] */
1168   int i, j;                /* Loop counters */
1169
1170   assert( argc==3 );
1171   UNUSED_PARAMETER(argc);
1172   zStr = sqlite3_value_text(argv[0]);
1173   if( zStr==0 ) return;
1174   nStr = sqlite3_value_bytes(argv[0]);
1175   assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
1176   zPattern = sqlite3_value_text(argv[1]);
1177   if( zPattern==0 ){
1178     assert( sqlite3_value_type(argv[1])==SQLITE_NULL
1179             || sqlite3_context_db_handle(context)->mallocFailed );
1180     return;
1181   }
1182   if( zPattern[0]==0 ){
1183     assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
1184     sqlite3_result_value(context, argv[0]);
1185     return;
1186   }
1187   nPattern = sqlite3_value_bytes(argv[1]);
1188   assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */
1189   zRep = sqlite3_value_text(argv[2]);
1190   if( zRep==0 ) return;
1191   nRep = sqlite3_value_bytes(argv[2]);
1192   assert( zRep==sqlite3_value_text(argv[2]) );
1193   nOut = nStr + 1;
1194   assert( nOut<SQLITE_MAX_LENGTH );
1195   zOut = contextMalloc(context, (i64)nOut);
1196   if( zOut==0 ){
1197     return;
1198   }
1199   loopLimit = nStr - nPattern;
1200   for(i=j=0; i<=loopLimit; i++){
1201     if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1202       zOut[j++] = zStr[i];
1203     }else{
1204       u8 *zOld;
1205       sqlite3 *db = sqlite3_context_db_handle(context);
1206       nOut += nRep - nPattern;
1207       testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
1208       testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
1209       if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1210         sqlite3_result_error_toobig(context);
1211         sqlite3_free(zOut);
1212         return;
1213       }
1214       zOld = zOut;
1215       zOut = sqlite3_realloc64(zOut, (int)nOut);
1216       if( zOut==0 ){
1217         sqlite3_result_error_nomem(context);
1218         sqlite3_free(zOld);
1219         return;
1220       }
1221       memcpy(&zOut[j], zRep, nRep);
1222       j += nRep;
1223       i += nPattern-1;
1224     }
1225   }
1226   assert( j+nStr-i+1==nOut );
1227   memcpy(&zOut[j], &zStr[i], nStr-i);
1228   j += nStr - i;
1229   assert( j<=nOut );
1230   zOut[j] = 0;
1231   sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1232 }
1233
1234 /*
1235 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1236 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1237 */
1238 static void trimFunc(
1239   sqlite3_context *context,
1240   int argc,
1241   sqlite3_value **argv
1242 ){
1243   const unsigned char *zIn;         /* Input string */
1244   const unsigned char *zCharSet;    /* Set of characters to trim */
1245   int nIn;                          /* Number of bytes in input */
1246   int flags;                        /* 1: trimleft  2: trimright  3: trim */
1247   int i;                            /* Loop counter */
1248   unsigned char *aLen = 0;          /* Length of each character in zCharSet */
1249   unsigned char **azChar = 0;       /* Individual characters in zCharSet */
1250   int nChar;                        /* Number of characters in zCharSet */
1251
1252   if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1253     return;
1254   }
1255   zIn = sqlite3_value_text(argv[0]);
1256   if( zIn==0 ) return;
1257   nIn = sqlite3_value_bytes(argv[0]);
1258   assert( zIn==sqlite3_value_text(argv[0]) );
1259   if( argc==1 ){
1260     static const unsigned char lenOne[] = { 1 };
1261     static unsigned char * const azOne[] = { (u8*)" " };
1262     nChar = 1;
1263     aLen = (u8*)lenOne;
1264     azChar = (unsigned char **)azOne;
1265     zCharSet = 0;
1266   }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1267     return;
1268   }else{
1269     const unsigned char *z;
1270     for(z=zCharSet, nChar=0; *z; nChar++){
1271       SQLITE_SKIP_UTF8(z);
1272     }
1273     if( nChar>0 ){
1274       azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
1275       if( azChar==0 ){
1276         return;
1277       }
1278       aLen = (unsigned char*)&azChar[nChar];
1279       for(z=zCharSet, nChar=0; *z; nChar++){
1280         azChar[nChar] = (unsigned char *)z;
1281         SQLITE_SKIP_UTF8(z);
1282         aLen[nChar] = (u8)(z - azChar[nChar]);
1283       }
1284     }
1285   }
1286   if( nChar>0 ){
1287     flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
1288     if( flags & 1 ){
1289       while( nIn>0 ){
1290         int len = 0;
1291         for(i=0; i<nChar; i++){
1292           len = aLen[i];
1293           if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
1294         }
1295         if( i>=nChar ) break;
1296         zIn += len;
1297         nIn -= len;
1298       }
1299     }
1300     if( flags & 2 ){
1301       while( nIn>0 ){
1302         int len = 0;
1303         for(i=0; i<nChar; i++){
1304           len = aLen[i];
1305           if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1306         }
1307         if( i>=nChar ) break;
1308         nIn -= len;
1309       }
1310     }
1311     if( zCharSet ){
1312       sqlite3_free(azChar);
1313     }
1314   }
1315   sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1316 }
1317
1318
1319 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1320 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1321 ** when SQLite is built.
1322 */
1323 #ifdef SQLITE_SOUNDEX
1324 /*
1325 ** Compute the soundex encoding of a word.
1326 **
1327 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1328 ** soundex encoding of the string X.
1329 */
1330 static void soundexFunc(
1331   sqlite3_context *context,
1332   int argc,
1333   sqlite3_value **argv
1334 ){
1335   char zResult[8];
1336   const u8 *zIn;
1337   int i, j;
1338   static const unsigned char iCode[] = {
1339     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1340     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1341     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1342     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1343     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1344     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1345     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1346     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1347   };
1348   assert( argc==1 );
1349   zIn = (u8*)sqlite3_value_text(argv[0]);
1350   if( zIn==0 ) zIn = (u8*)"";
1351   for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
1352   if( zIn[i] ){
1353     u8 prevcode = iCode[zIn[i]&0x7f];
1354     zResult[0] = sqlite3Toupper(zIn[i]);
1355     for(j=1; j<4 && zIn[i]; i++){
1356       int code = iCode[zIn[i]&0x7f];
1357       if( code>0 ){
1358         if( code!=prevcode ){
1359           prevcode = code;
1360           zResult[j++] = code + '0';
1361         }
1362       }else{
1363         prevcode = 0;
1364       }
1365     }
1366     while( j<4 ){
1367       zResult[j++] = '0';
1368     }
1369     zResult[j] = 0;
1370     sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1371   }else{
1372     /* IMP: R-64894-50321 The string "?000" is returned if the argument
1373     ** is NULL or contains no ASCII alphabetic characters. */
1374     sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1375   }
1376 }
1377 #endif /* SQLITE_SOUNDEX */
1378
1379 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1380 /*
1381 ** A function that loads a shared-library extension then returns NULL.
1382 */
1383 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1384   const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1385   const char *zProc;
1386   sqlite3 *db = sqlite3_context_db_handle(context);
1387   char *zErrMsg = 0;
1388
1389   /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
1390   ** flag is set.  See the sqlite3_enable_load_extension() API.
1391   */
1392   if( (db->flags & SQLITE_LoadExtFunc)==0 ){
1393     sqlite3_result_error(context, "not authorized", -1);
1394     return;
1395   }
1396
1397   if( argc==2 ){
1398     zProc = (const char *)sqlite3_value_text(argv[1]);
1399   }else{
1400     zProc = 0;
1401   }
1402   if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1403     sqlite3_result_error(context, zErrMsg, -1);
1404     sqlite3_free(zErrMsg);
1405   }
1406 }
1407 #endif
1408
1409
1410 /*
1411 ** An instance of the following structure holds the context of a
1412 ** sum() or avg() aggregate computation.
1413 */
1414 typedef struct SumCtx SumCtx;
1415 struct SumCtx {
1416   double rSum;      /* Floating point sum */
1417   i64 iSum;         /* Integer sum */
1418   i64 cnt;          /* Number of elements summed */
1419   u8 overflow;      /* True if integer overflow seen */
1420   u8 approx;        /* True if non-integer value was input to the sum */
1421 };
1422
1423 /*
1424 ** Routines used to compute the sum, average, and total.
1425 **
1426 ** The SUM() function follows the (broken) SQL standard which means
1427 ** that it returns NULL if it sums over no inputs.  TOTAL returns
1428 ** 0.0 in that case.  In addition, TOTAL always returns a float where
1429 ** SUM might return an integer if it never encounters a floating point
1430 ** value.  TOTAL never fails, but SUM might through an exception if
1431 ** it overflows an integer.
1432 */
1433 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1434   SumCtx *p;
1435   int type;
1436   assert( argc==1 );
1437   UNUSED_PARAMETER(argc);
1438   p = sqlite3_aggregate_context(context, sizeof(*p));
1439   type = sqlite3_value_numeric_type(argv[0]);
1440   if( p && type!=SQLITE_NULL ){
1441     p->cnt++;
1442     if( type==SQLITE_INTEGER ){
1443       i64 v = sqlite3_value_int64(argv[0]);
1444       p->rSum += v;
1445       if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
1446         p->overflow = 1;
1447       }
1448     }else{
1449       p->rSum += sqlite3_value_double(argv[0]);
1450       p->approx = 1;
1451     }
1452   }
1453 }
1454 static void sumFinalize(sqlite3_context *context){
1455   SumCtx *p;
1456   p = sqlite3_aggregate_context(context, 0);
1457   if( p && p->cnt>0 ){
1458     if( p->overflow ){
1459       sqlite3_result_error(context,"integer overflow",-1);
1460     }else if( p->approx ){
1461       sqlite3_result_double(context, p->rSum);
1462     }else{
1463       sqlite3_result_int64(context, p->iSum);
1464     }
1465   }
1466 }
1467 static void avgFinalize(sqlite3_context *context){
1468   SumCtx *p;
1469   p = sqlite3_aggregate_context(context, 0);
1470   if( p && p->cnt>0 ){
1471     sqlite3_result_double(context, p->rSum/(double)p->cnt);
1472   }
1473 }
1474 static void totalFinalize(sqlite3_context *context){
1475   SumCtx *p;
1476   p = sqlite3_aggregate_context(context, 0);
1477   /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1478   sqlite3_result_double(context, p ? p->rSum : (double)0);
1479 }
1480
1481 /*
1482 ** The following structure keeps track of state information for the
1483 ** count() aggregate function.
1484 */
1485 typedef struct CountCtx CountCtx;
1486 struct CountCtx {
1487   i64 n;
1488 };
1489
1490 /*
1491 ** Routines to implement the count() aggregate function.
1492 */
1493 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1494   CountCtx *p;
1495   p = sqlite3_aggregate_context(context, sizeof(*p));
1496   if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1497     p->n++;
1498   }
1499
1500 #ifndef SQLITE_OMIT_DEPRECATED
1501   /* The sqlite3_aggregate_count() function is deprecated.  But just to make
1502   ** sure it still operates correctly, verify that its count agrees with our
1503   ** internal count when using count(*) and when the total count can be
1504   ** expressed as a 32-bit integer. */
1505   assert( argc==1 || p==0 || p->n>0x7fffffff
1506           || p->n==sqlite3_aggregate_count(context) );
1507 #endif
1508 }
1509 static void countFinalize(sqlite3_context *context){
1510   CountCtx *p;
1511   p = sqlite3_aggregate_context(context, 0);
1512   sqlite3_result_int64(context, p ? p->n : 0);
1513 }
1514
1515 /*
1516 ** Routines to implement min() and max() aggregate functions.
1517 */
1518 static void minmaxStep(
1519   sqlite3_context *context,
1520   int NotUsed,
1521   sqlite3_value **argv
1522 ){
1523   Mem *pArg  = (Mem *)argv[0];
1524   Mem *pBest;
1525   UNUSED_PARAMETER(NotUsed);
1526
1527   pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1528   if( !pBest ) return;
1529
1530   if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1531     if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
1532   }else if( pBest->flags ){
1533     int max;
1534     int cmp;
1535     CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1536     /* This step function is used for both the min() and max() aggregates,
1537     ** the only difference between the two being that the sense of the
1538     ** comparison is inverted. For the max() aggregate, the
1539     ** sqlite3_user_data() function returns (void *)-1. For min() it
1540     ** returns (void *)db, where db is the sqlite3* database pointer.
1541     ** Therefore the next statement sets variable 'max' to 1 for the max()
1542     ** aggregate, or 0 for min().
1543     */
1544     max = sqlite3_user_data(context)!=0;
1545     cmp = sqlite3MemCompare(pBest, pArg, pColl);
1546     if( (max && cmp<0) || (!max && cmp>0) ){
1547       sqlite3VdbeMemCopy(pBest, pArg);
1548     }else{
1549       sqlite3SkipAccumulatorLoad(context);
1550     }
1551   }else{
1552     pBest->db = sqlite3_context_db_handle(context);
1553     sqlite3VdbeMemCopy(pBest, pArg);
1554   }
1555 }
1556 static void minMaxFinalize(sqlite3_context *context){
1557   sqlite3_value *pRes;
1558   pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1559   if( pRes ){
1560     if( pRes->flags ){
1561       sqlite3_result_value(context, pRes);
1562     }
1563     sqlite3VdbeMemRelease(pRes);
1564   }
1565 }
1566
1567 /*
1568 ** group_concat(EXPR, ?SEPARATOR?)
1569 */
1570 static void groupConcatStep(
1571   sqlite3_context *context,
1572   int argc,
1573   sqlite3_value **argv
1574 ){
1575   const char *zVal;
1576   StrAccum *pAccum;
1577   const char *zSep;
1578   int nVal, nSep;
1579   assert( argc==1 || argc==2 );
1580   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1581   pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
1582
1583   if( pAccum ){
1584     sqlite3 *db = sqlite3_context_db_handle(context);
1585     int firstTerm = pAccum->mxAlloc==0;
1586     pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
1587     if( !firstTerm ){
1588       if( argc==2 ){
1589         zSep = (char*)sqlite3_value_text(argv[1]);
1590         nSep = sqlite3_value_bytes(argv[1]);
1591       }else{
1592         zSep = ",";
1593         nSep = 1;
1594       }
1595       if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
1596     }
1597     zVal = (char*)sqlite3_value_text(argv[0]);
1598     nVal = sqlite3_value_bytes(argv[0]);
1599     if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
1600   }
1601 }
1602 static void groupConcatFinalize(sqlite3_context *context){
1603   StrAccum *pAccum;
1604   pAccum = sqlite3_aggregate_context(context, 0);
1605   if( pAccum ){
1606     if( pAccum->accError==STRACCUM_TOOBIG ){
1607       sqlite3_result_error_toobig(context);
1608     }else if( pAccum->accError==STRACCUM_NOMEM ){
1609       sqlite3_result_error_nomem(context);
1610     }else{
1611       sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
1612                           sqlite3_free);
1613     }
1614   }
1615 }
1616
1617 /*
1618 ** This routine does per-connection function registration.  Most
1619 ** of the built-in functions above are part of the global function set.
1620 ** This routine only deals with those that are not global.
1621 */
1622 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
1623   int rc = sqlite3_overload_function(db, "MATCH", 2);
1624   assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1625   if( rc==SQLITE_NOMEM ){
1626     sqlite3OomFault(db);
1627   }
1628 }
1629
1630 /*
1631 ** Set the LIKEOPT flag on the 2-argument function with the given name.
1632 */
1633 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
1634   FuncDef *pDef;
1635   pDef = sqlite3FindFunction(db, zName, 2, SQLITE_UTF8, 0);
1636   if( ALWAYS(pDef) ){
1637     pDef->funcFlags |= flagVal;
1638   }
1639 }
1640
1641 /*
1642 ** Register the built-in LIKE and GLOB functions.  The caseSensitive
1643 ** parameter determines whether or not the LIKE operator is case
1644 ** sensitive.  GLOB is always case sensitive.
1645 */
1646 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1647   struct compareInfo *pInfo;
1648   if( caseSensitive ){
1649     pInfo = (struct compareInfo*)&likeInfoAlt;
1650   }else{
1651     pInfo = (struct compareInfo*)&likeInfoNorm;
1652   }
1653   sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1654   sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1655   sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
1656       (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0);
1657   setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
1658   setLikeOptFlag(db, "like",
1659       caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
1660 }
1661
1662 /*
1663 ** pExpr points to an expression which implements a function.  If
1664 ** it is appropriate to apply the LIKE optimization to that function
1665 ** then set aWc[0] through aWc[2] to the wildcard characters and
1666 ** return TRUE.  If the function is not a LIKE-style function then
1667 ** return FALSE.
1668 **
1669 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
1670 ** the function (default for LIKE).  If the function makes the distinction
1671 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
1672 ** false.
1673 */
1674 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1675   FuncDef *pDef;
1676   if( pExpr->op!=TK_FUNCTION
1677    || !pExpr->x.pList
1678    || pExpr->x.pList->nExpr!=2
1679   ){
1680     return 0;
1681   }
1682   assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
1683   pDef = sqlite3FindFunction(db, pExpr->u.zToken, 2, SQLITE_UTF8, 0);
1684   if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
1685     return 0;
1686   }
1687
1688   /* The memcpy() statement assumes that the wildcard characters are
1689   ** the first three statements in the compareInfo structure.  The
1690   ** asserts() that follow verify that assumption
1691   */
1692   memcpy(aWc, pDef->pUserData, 3);
1693   assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1694   assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1695   assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1696   *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
1697   return 1;
1698 }
1699
1700 /*
1701 ** All of the FuncDef structures in the aBuiltinFunc[] array above
1702 ** to the global function hash table.  This occurs at start-time (as
1703 ** a consequence of calling sqlite3_initialize()).
1704 **
1705 ** After this routine runs
1706 */
1707 void sqlite3RegisterBuiltinFunctions(void){
1708   /*
1709   ** The following array holds FuncDef structures for all of the functions
1710   ** defined in this file.
1711   **
1712   ** The array cannot be constant since changes are made to the
1713   ** FuncDef.pHash elements at start-time.  The elements of this array
1714   ** are read-only after initialization is complete.
1715   **
1716   ** For peak efficiency, put the most frequently used function last.
1717   */
1718   static FuncDef aBuiltinFunc[] = {
1719 #ifdef SQLITE_SOUNDEX
1720     FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
1721 #endif
1722 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1723     VFUNCTION(load_extension,    1, 0, 0, loadExt          ),
1724     VFUNCTION(load_extension,    2, 0, 0, loadExt          ),
1725 #endif
1726 #if SQLITE_USER_AUTHENTICATION
1727     FUNCTION(sqlite_crypt,       2, 0, 0, sqlite3CryptFunc ),
1728 #endif
1729 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1730     DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
1731     DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
1732 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1733     FUNCTION2(unlikely,          1, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1734     FUNCTION2(likelihood,        2, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1735     FUNCTION2(likely,            1, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1736     FUNCTION(ltrim,              1, 1, 0, trimFunc         ),
1737     FUNCTION(ltrim,              2, 1, 0, trimFunc         ),
1738     FUNCTION(rtrim,              1, 2, 0, trimFunc         ),
1739     FUNCTION(rtrim,              2, 2, 0, trimFunc         ),
1740     FUNCTION(trim,               1, 3, 0, trimFunc         ),
1741     FUNCTION(trim,               2, 3, 0, trimFunc         ),
1742     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
1743     FUNCTION(min,                0, 0, 1, 0                ),
1744     AGGREGATE2(min,              1, 0, 1, minmaxStep,      minMaxFinalize,
1745                                           SQLITE_FUNC_MINMAX ),
1746     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
1747     FUNCTION(max,                0, 1, 1, 0                ),
1748     AGGREGATE2(max,              1, 1, 1, minmaxStep,      minMaxFinalize,
1749                                           SQLITE_FUNC_MINMAX ),
1750     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
1751     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
1752     FUNCTION(instr,              2, 0, 0, instrFunc        ),
1753     FUNCTION(printf,            -1, 0, 0, printfFunc       ),
1754     FUNCTION(unicode,            1, 0, 0, unicodeFunc      ),
1755     FUNCTION(char,              -1, 0, 0, charFunc         ),
1756     FUNCTION(abs,                1, 0, 0, absFunc          ),
1757 #ifndef SQLITE_OMIT_FLOATING_POINT
1758     FUNCTION(round,              1, 0, 0, roundFunc        ),
1759     FUNCTION(round,              2, 0, 0, roundFunc        ),
1760 #endif
1761     FUNCTION(upper,              1, 0, 0, upperFunc        ),
1762     FUNCTION(lower,              1, 0, 0, lowerFunc        ),
1763     FUNCTION(hex,                1, 0, 0, hexFunc          ),
1764     FUNCTION2(ifnull,            2, 0, 0, noopFunc,  SQLITE_FUNC_COALESCE),
1765     VFUNCTION(random,            0, 0, 0, randomFunc       ),
1766     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
1767     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
1768     DFUNCTION(sqlite_version,    0, 0, 0, versionFunc      ),
1769     DFUNCTION(sqlite_source_id,  0, 0, 0, sourceidFunc     ),
1770     FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
1771     FUNCTION(quote,              1, 0, 0, quoteFunc        ),
1772     VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
1773     VFUNCTION(changes,           0, 0, 0, changes          ),
1774     VFUNCTION(total_changes,     0, 0, 0, total_changes    ),
1775     FUNCTION(replace,            3, 0, 0, replaceFunc      ),
1776     FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
1777     FUNCTION(substr,             2, 0, 0, substrFunc       ),
1778     FUNCTION(substr,             3, 0, 0, substrFunc       ),
1779     AGGREGATE(sum,               1, 0, 0, sumStep,         sumFinalize    ),
1780     AGGREGATE(total,             1, 0, 0, sumStep,         totalFinalize    ),
1781     AGGREGATE(avg,               1, 0, 0, sumStep,         avgFinalize    ),
1782     AGGREGATE2(count,            0, 0, 0, countStep,       countFinalize,
1783                SQLITE_FUNC_COUNT  ),
1784     AGGREGATE(count,             1, 0, 0, countStep,       countFinalize  ),
1785     AGGREGATE(group_concat,      1, 0, 0, groupConcatStep, groupConcatFinalize),
1786     AGGREGATE(group_concat,      2, 0, 0, groupConcatStep, groupConcatFinalize),
1787
1788     LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1789   #ifdef SQLITE_CASE_SENSITIVE_LIKE
1790     LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1791     LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1792   #else
1793     LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
1794     LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
1795   #endif
1796     FUNCTION(coalesce,           1, 0, 0, 0                ),
1797     FUNCTION(coalesce,           0, 0, 0, 0                ),
1798     FUNCTION2(coalesce,         -1, 0, 0, noopFunc,  SQLITE_FUNC_COALESCE),
1799   };
1800 #ifndef SQLITE_OMIT_ALTERTABLE
1801   sqlite3AlterFunctions();
1802 #endif
1803 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4)
1804   sqlite3AnalyzeFunctions();
1805 #endif
1806   sqlite3RegisterDateTimeFunctions();
1807   sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
1808
1809 #if 0  /* Enable to print out how the built-in functions are hashed */
1810   {
1811     int i;
1812     FuncDef *p;
1813     for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
1814       printf("FUNC-HASH %02d:", i);
1815       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
1816         int n = sqlite3Strlen30(p->zName);
1817         int h = p->zName[0] + n;
1818         printf(" %s(%d)", p->zName, h);
1819       }
1820       printf("\n");
1821     }
1822   }
1823 #endif
1824 }