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