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