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         char zStop[3];
 702         int bMatch;
 703         if( noCase ){
 704           zStop[0] = sqlite3Toupper(c);
 705           zStop[1] = sqlite3Tolower(c);
 706           zStop[2] = 0;
 707         }else{
 708           zStop[0] = c;
 709           zStop[1] = 0;
 710         }
 711         while(1){
 712           zString += strcspn((const char*)zString, zStop);
 713           if( zString[0]==0 ) break;
 714           zString++;
 715           bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
 716           if( bMatch!=SQLITE_NOMATCH ) return bMatch;
 717         }
 718       }else{
 719         int bMatch;
 720         while( (c2 = Utf8Read(zString))!=0 ){
 721           if( c2!=c ) continue;
 722           bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
 723           if( bMatch!=SQLITE_NOMATCH ) return bMatch;
 724         }
 725       }
 726       return SQLITE_NOWILDCARDMATCH;
 727     }
 728     if( c==matchOther ){
 729       if( pInfo->matchSet==0 ){
 730         c = sqlite3Utf8Read(&zPattern);
 731         if( c==0 ) return SQLITE_NOMATCH;
 732         zEscaped = zPattern;
 733       }else{
 734         u32 prior_c = 0;
 735         int seen = 0;
 736         int invert = 0;
 737         c = sqlite3Utf8Read(&zString);
 738         if( c==0 ) return SQLITE_NOMATCH;
 739         c2 = sqlite3Utf8Read(&zPattern);
 740         if( c2=='^' ){
 741           invert = 1;
 742           c2 = sqlite3Utf8Read(&zPattern);
 743         }
 744         if( c2==']' ){
 745           if( c==']' ) seen = 1;
 746           c2 = sqlite3Utf8Read(&zPattern);
 747         }
 748         while( c2 && c2!=']' ){
 749           if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
 750             c2 = sqlite3Utf8Read(&zPattern);
 751             if( c>=prior_c && c<=c2 ) seen = 1;
 752             prior_c = 0;
 753           }else{
 754             if( c==c2 ){
 755               seen = 1;
 756             }
 757             prior_c = c2;
 758           }
 759           c2 = sqlite3Utf8Read(&zPattern);
 760         }
 761         if( c2==0 || (seen ^ invert)==0 ){
 762           return SQLITE_NOMATCH;
 763         }
 764         continue;
 765       }
 766     }
 767     c2 = Utf8Read(zString);
 768     if( c==c2 ) continue;
 769     if( noCase  && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){
 770       continue;
 771     }
 772     if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;
 773     return SQLITE_NOMATCH;
 774   }
 775   return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH;
 776 }
 777
 778 /*
 779 ** The sqlite3_strglob() interface.  Return 0 on a match (like strcmp()) and
 780 ** non-zero if there is no match.
 781 */
 782 int sqlite3_strglob(const char *zGlobPattern, const char *zString){
 783   return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[');
 784 }
 785
 786 /*
 787 ** The sqlite3_strlike() interface.  Return 0 on a match and non-zero for
 788 ** a miss - like strcmp().
 789 */
 790 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){
 791   return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc);
 792 }
 793
 794 /*
 795 ** Count the number of times that the LIKE operator (or GLOB which is
 796 ** just a variation of LIKE) gets called.  This is used for testing
 797 ** only.
 798 */
 799 #ifdef SQLITE_TEST
 800 int sqlite3_like_count = 0;
 801 #endif
 802
 803
 804 /*
 805 ** Implementation of the like() SQL function.  This function implements
 806 ** the build-in LIKE operator.  The first argument to the function is the
 807 ** pattern and the second argument is the string.  So, the SQL statements:
 808 **
 809 **       A LIKE B
 810 **
 811 ** is implemented as like(B,A).
 812 **
 813 ** This same function (with a different compareInfo structure) computes
 814 ** the GLOB operator.
 815 */
 816 static void likeFunc(
 817   sqlite3_context *context,
 818   int argc,
 819   sqlite3_value **argv
 820 ){
 821   const unsigned char *zA, *zB;
 822   u32 escape;
 823   int nPat;
 824   sqlite3 *db = sqlite3_context_db_handle(context);
 825   struct compareInfo *pInfo = sqlite3_user_data(context);
 826
 827 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
 828   if( sqlite3_value_type(argv[0])==SQLITE_BLOB
 829    || sqlite3_value_type(argv[1])==SQLITE_BLOB
 830   ){
 831 #ifdef SQLITE_TEST
 832     sqlite3_like_count++;
 833 #endif
 834     sqlite3_result_int(context, 0);
 835     return;
 836   }
 837 #endif
 838   zB = sqlite3_value_text(argv[0]);
 839   zA = sqlite3_value_text(argv[1]);
 840
 841   /* Limit the length of the LIKE or GLOB pattern to avoid problems
 842   ** of deep recursion and N*N behavior in patternCompare().
 843   */
 844   nPat = sqlite3_value_bytes(argv[0]);
 845   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
 846   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
 847   if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
 848     sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
 849     return;
 850   }
 851   assert( zB==sqlite3_value_text(argv[0]) );  /* Encoding did not change */
 852
 853   if( argc==3 ){
 854     /* The escape character string must consist of a single UTF-8 character.
 855     ** Otherwise, return an error.
 856     */
 857     const unsigned char *zEsc = sqlite3_value_text(argv[2]);
 858     if( zEsc==0 ) return;
 859     if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
 860       sqlite3_result_error(context,
 861           "ESCAPE expression must be a single character", -1);
 862       return;
 863     }
 864     escape = sqlite3Utf8Read(&zEsc);
 865   }else{
 866     escape = pInfo->matchSet;
 867   }
 868   if( zA && zB ){
 869 #ifdef SQLITE_TEST
 870     sqlite3_like_count++;
 871 #endif
 872     sqlite3_result_int(context,
 873                       patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH);
 874   }
 875 }
 876
 877 /*
 878 ** Implementation of the NULLIF(x,y) function.  The result is the first
 879 ** argument if the arguments are different.  The result is NULL if the
 880 ** arguments are equal to each other.
 881 */
 882 static void nullifFunc(
 883   sqlite3_context *context,
 884   int NotUsed,
 885   sqlite3_value **argv
 886 ){
 887   CollSeq *pColl = sqlite3GetFuncCollSeq(context);
 888   UNUSED_PARAMETER(NotUsed);
 889   if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
 890     sqlite3_result_value(context, argv[0]);
 891   }
 892 }
 893
 894 /*
 895 ** Implementation of the sqlite_version() function.  The result is the version
 896 ** of the SQLite library that is running.
 897 */
 898 static void versionFunc(
 899   sqlite3_context *context,
 900   int NotUsed,
 901   sqlite3_value **NotUsed2
 902 ){
 903   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 904   /* IMP: R-48699-48617 This function is an SQL wrapper around the
 905   ** sqlite3_libversion() C-interface. */
 906   sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
 907 }
 908
 909 /*
 910 ** Implementation of the sqlite_source_id() function. The result is a string
 911 ** that identifies the particular version of the source code used to build
 912 ** SQLite.
 913 */
 914 static void sourceidFunc(
 915   sqlite3_context *context,
 916   int NotUsed,
 917   sqlite3_value **NotUsed2
 918 ){
 919   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 920   /* IMP: R-24470-31136 This function is an SQL wrapper around the
 921   ** sqlite3_sourceid() C interface. */
 922   sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
 923 }
 924
 925 /*
 926 ** Implementation of the sqlite_log() function.  This is a wrapper around
 927 ** sqlite3_log().  The return value is NULL.  The function exists purely for
 928 ** its side-effects.
 929 */
 930 static void errlogFunc(
 931   sqlite3_context *context,
 932   int argc,
 933   sqlite3_value **argv
 934 ){
 935   UNUSED_PARAMETER(argc);
 936   UNUSED_PARAMETER(context);
 937   sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
 938 }
 939
 940 /*
 941 ** Implementation of the sqlite_compileoption_used() function.
 942 ** The result is an integer that identifies if the compiler option
 943 ** was used to build SQLite.
 944 */
 945 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 946 static void compileoptionusedFunc(
 947   sqlite3_context *context,
 948   int argc,
 949   sqlite3_value **argv
 950 ){
 951   const char *zOptName;
 952   assert( argc==1 );
 953   UNUSED_PARAMETER(argc);
 954   /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
 955   ** function is a wrapper around the sqlite3_compileoption_used() C/C++
 956   ** function.
 957   */
 958   if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
 959     sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
 960   }
 961 }
 962 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 963
 964 /*
 965 ** Implementation of the sqlite_compileoption_get() function.
 966 ** The result is a string that identifies the compiler options
 967 ** used to build SQLite.
 968 */
 969 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 970 static void compileoptiongetFunc(
 971   sqlite3_context *context,
 972   int argc,
 973   sqlite3_value **argv
 974 ){
 975   int n;
 976   assert( argc==1 );
 977   UNUSED_PARAMETER(argc);
 978   /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
 979   ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
 980   */
 981   n = sqlite3_value_int(argv[0]);
 982   sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
 983 }
 984 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
 985
 986 /* Array for converting from half-bytes (nybbles) into ASCII hex
 987 ** digits. */
 988 static const char hexdigits[] = {
 989   '0', '1', '2', '3', '4', '5', '6', '7',
 990   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 991 };
 992
 993 /*
 994 ** Implementation of the QUOTE() function.  This function takes a single
 995 ** argument.  If the argument is numeric, the return value is the same as
 996 ** the argument.  If the argument is NULL, the return value is the string
 997 ** "NULL".  Otherwise, the argument is enclosed in single quotes with
 998 ** single-quote escapes.
 999 */
1000 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1001   assert( argc==1 );
1002   UNUSED_PARAMETER(argc);
1003   switch( sqlite3_value_type(argv[0]) ){
1004     case SQLITE_FLOAT: {
1005       double r1, r2;
1006       char zBuf[50];
1007       r1 = sqlite3_value_double(argv[0]);
1008       sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
1009       sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8);
1010       if( r1!=r2 ){
1011         sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
1012       }
1013       sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
1014       break;
1015     }
1016     case SQLITE_INTEGER: {
1017       sqlite3_result_value(context, argv[0]);
1018       break;
1019     }
1020     case SQLITE_BLOB: {
1021       char *zText = 0;
1022       char const *zBlob = sqlite3_value_blob(argv[0]);
1023       int nBlob = sqlite3_value_bytes(argv[0]);
1024       assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
1025       zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);
1026       if( zText ){
1027         int i;
1028         for(i=0; i<nBlob; i++){
1029           zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
1030           zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
1031         }
1032         zText[(nBlob*2)+2] = '\'';
1033         zText[(nBlob*2)+3] = '\0';
1034         zText[0] = 'X';
1035         zText[1] = '\'';
1036         sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
1037         sqlite3_free(zText);
1038       }
1039       break;
1040     }
1041     case SQLITE_TEXT: {
1042       int i,j;
1043       u64 n;
1044       const unsigned char *zArg = sqlite3_value_text(argv[0]);
1045       char *z;
1046
1047       if( zArg==0 ) return;
1048       for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
1049       z = contextMalloc(context, ((i64)i)+((i64)n)+3);
1050       if( z ){
1051         z[0] = '\'';
1052         for(i=0, j=1; zArg[i]; i++){
1053           z[j++] = zArg[i];
1054           if( zArg[i]=='\'' ){
1055             z[j++] = '\'';
1056           }
1057         }
1058         z[j++] = '\'';
1059         z[j] = 0;
1060         sqlite3_result_text(context, z, j, sqlite3_free);
1061       }
1062       break;
1063     }
1064     default: {
1065       assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
1066       sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
1067       break;
1068     }
1069   }
1070 }
1071
1072 /*
1073 ** The unicode() function.  Return the integer unicode code-point value
1074 ** for the first character of the input string.
1075 */
1076 static void unicodeFunc(
1077   sqlite3_context *context,
1078   int argc,
1079   sqlite3_value **argv
1080 ){
1081   const unsigned char *z = sqlite3_value_text(argv[0]);
1082   (void)argc;
1083   if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
1084 }
1085
1086 /*
1087 ** The char() function takes zero or more arguments, each of which is
1088 ** an integer.  It constructs a string where each character of the string
1089 ** is the unicode character for the corresponding integer argument.
1090 */
1091 static void charFunc(
1092   sqlite3_context *context,
1093   int argc,
1094   sqlite3_value **argv
1095 ){
1096   unsigned char *z, *zOut;
1097   int i;
1098   zOut = z = sqlite3_malloc64( argc*4+1 );
1099   if( z==0 ){
1100     sqlite3_result_error_nomem(context);
1101     return;
1102   }
1103   for(i=0; i<argc; i++){
1104     sqlite3_int64 x;
1105     unsigned c;
1106     x = sqlite3_value_int64(argv[i]);
1107     if( x<0 || x>0x10ffff ) x = 0xfffd;
1108     c = (unsigned)(x & 0x1fffff);
1109     if( c<0x00080 ){
1110       *zOut++ = (u8)(c&0xFF);
1111     }else if( c<0x00800 ){
1112       *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
1113       *zOut++ = 0x80 + (u8)(c & 0x3F);
1114     }else if( c<0x10000 ){
1115       *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
1116       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1117       *zOut++ = 0x80 + (u8)(c & 0x3F);
1118     }else{
1119       *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
1120       *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
1121       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1122       *zOut++ = 0x80 + (u8)(c & 0x3F);
1123     }                                                    \
1124   }
1125   sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
1126 }
1127
1128 /*
1129 ** The hex() function.  Interpret the argument as a blob.  Return
1130 ** a hexadecimal rendering as text.
1131 */
1132 static void hexFunc(
1133   sqlite3_context *context,
1134   int argc,
1135   sqlite3_value **argv
1136 ){
1137   int i, n;
1138   const unsigned char *pBlob;
1139   char *zHex, *z;
1140   assert( argc==1 );
1141   UNUSED_PARAMETER(argc);
1142   pBlob = sqlite3_value_blob(argv[0]);
1143   n = sqlite3_value_bytes(argv[0]);
1144   assert( pBlob==sqlite3_value_blob(argv[0]) );  /* No encoding change */
1145   z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
1146   if( zHex ){
1147     for(i=0; i<n; i++, pBlob++){
1148       unsigned char c = *pBlob;
1149       *(z++) = hexdigits[(c>>4)&0xf];
1150       *(z++) = hexdigits[c&0xf];
1151     }
1152     *z = 0;
1153     sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1154   }
1155 }
1156
1157 /*
1158 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1159 */
1160 static void zeroblobFunc(
1161   sqlite3_context *context,
1162   int argc,
1163   sqlite3_value **argv
1164 ){
1165   i64 n;
1166   int rc;
1167   assert( argc==1 );
1168   UNUSED_PARAMETER(argc);
1169   n = sqlite3_value_int64(argv[0]);
1170   if( n<0 ) n = 0;
1171   rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
1172   if( rc ){
1173     sqlite3_result_error_code(context, rc);
1174   }
1175 }
1176
1177 /*
1178 ** The replace() function.  Three arguments are all strings: call
1179 ** them A, B, and C. The result is also a string which is derived
1180 ** from A by replacing every occurrence of B with C.  The match
1181 ** must be exact.  Collating sequences are not used.
1182 */
1183 static void replaceFunc(
1184   sqlite3_context *context,
1185   int argc,
1186   sqlite3_value **argv
1187 ){
1188   const unsigned char *zStr;        /* The input string A */
1189   const unsigned char *zPattern;    /* The pattern string B */
1190   const unsigned char *zRep;        /* The replacement string C */
1191   unsigned char *zOut;              /* The output */
1192   int nStr;                /* Size of zStr */
1193   int nPattern;            /* Size of zPattern */
1194   int nRep;                /* Size of zRep */
1195   i64 nOut;                /* Maximum size of zOut */
1196   int loopLimit;           /* Last zStr[] that might match zPattern[] */
1197   int i, j;                /* Loop counters */
1198
1199   assert( argc==3 );
1200   UNUSED_PARAMETER(argc);
1201   zStr = sqlite3_value_text(argv[0]);
1202   if( zStr==0 ) return;
1203   nStr = sqlite3_value_bytes(argv[0]);
1204   assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
1205   zPattern = sqlite3_value_text(argv[1]);
1206   if( zPattern==0 ){
1207     assert( sqlite3_value_type(argv[1])==SQLITE_NULL
1208             || sqlite3_context_db_handle(context)->mallocFailed );
1209     return;
1210   }
1211   if( zPattern[0]==0 ){
1212     assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
1213     sqlite3_result_value(context, argv[0]);
1214     return;
1215   }
1216   nPattern = sqlite3_value_bytes(argv[1]);
1217   assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */
1218   zRep = sqlite3_value_text(argv[2]);
1219   if( zRep==0 ) return;
1220   nRep = sqlite3_value_bytes(argv[2]);
1221   assert( zRep==sqlite3_value_text(argv[2]) );
1222   nOut = nStr + 1;
1223   assert( nOut<SQLITE_MAX_LENGTH );
1224   zOut = contextMalloc(context, (i64)nOut);
1225   if( zOut==0 ){
1226     return;
1227   }
1228   loopLimit = nStr - nPattern;
1229   for(i=j=0; i<=loopLimit; i++){
1230     if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1231       zOut[j++] = zStr[i];
1232     }else{
1233       u8 *zOld;
1234       sqlite3 *db = sqlite3_context_db_handle(context);
1235       nOut += nRep - nPattern;
1236       testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
1237       testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
1238       if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1239         sqlite3_result_error_toobig(context);
1240         sqlite3_free(zOut);
1241         return;
1242       }
1243       zOld = zOut;
1244       zOut = sqlite3_realloc64(zOut, (int)nOut);
1245       if( zOut==0 ){
1246         sqlite3_result_error_nomem(context);
1247         sqlite3_free(zOld);
1248         return;
1249       }
1250       memcpy(&zOut[j], zRep, nRep);
1251       j += nRep;
1252       i += nPattern-1;
1253     }
1254   }
1255   assert( j+nStr-i+1==nOut );
1256   memcpy(&zOut[j], &zStr[i], nStr-i);
1257   j += nStr - i;
1258   assert( j<=nOut );
1259   zOut[j] = 0;
1260   sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1261 }
1262
1263 /*
1264 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1265 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1266 */
1267 static void trimFunc(
1268   sqlite3_context *context,
1269   int argc,
1270   sqlite3_value **argv
1271 ){
1272   const unsigned char *zIn;         /* Input string */
1273   const unsigned char *zCharSet;    /* Set of characters to trim */
1274   int nIn;                          /* Number of bytes in input */
1275   int flags;                        /* 1: trimleft  2: trimright  3: trim */
1276   int i;                            /* Loop counter */
1277   unsigned char *aLen = 0;          /* Length of each character in zCharSet */
1278   unsigned char **azChar = 0;       /* Individual characters in zCharSet */
1279   int nChar;                        /* Number of characters in zCharSet */
1280
1281   if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1282     return;
1283   }
1284   zIn = sqlite3_value_text(argv[0]);
1285   if( zIn==0 ) return;
1286   nIn = sqlite3_value_bytes(argv[0]);
1287   assert( zIn==sqlite3_value_text(argv[0]) );
1288   if( argc==1 ){
1289     static const unsigned char lenOne[] = { 1 };
1290     static unsigned char * const azOne[] = { (u8*)" " };
1291     nChar = 1;
1292     aLen = (u8*)lenOne;
1293     azChar = (unsigned char **)azOne;
1294     zCharSet = 0;
1295   }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1296     return;
1297   }else{
1298     const unsigned char *z;
1299     for(z=zCharSet, nChar=0; *z; nChar++){
1300       SQLITE_SKIP_UTF8(z);
1301     }
1302     if( nChar>0 ){
1303       azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
1304       if( azChar==0 ){
1305         return;
1306       }
1307       aLen = (unsigned char*)&azChar[nChar];
1308       for(z=zCharSet, nChar=0; *z; nChar++){
1309         azChar[nChar] = (unsigned char *)z;
1310         SQLITE_SKIP_UTF8(z);
1311         aLen[nChar] = (u8)(z - azChar[nChar]);
1312       }
1313     }
1314   }
1315   if( nChar>0 ){
1316     flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
1317     if( flags & 1 ){
1318       while( nIn>0 ){
1319         int len = 0;
1320         for(i=0; i<nChar; i++){
1321           len = aLen[i];
1322           if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
1323         }
1324         if( i>=nChar ) break;
1325         zIn += len;
1326         nIn -= len;
1327       }
1328     }
1329     if( flags & 2 ){
1330       while( nIn>0 ){
1331         int len = 0;
1332         for(i=0; i<nChar; i++){
1333           len = aLen[i];
1334           if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1335         }
1336         if( i>=nChar ) break;
1337         nIn -= len;
1338       }
1339     }
1340     if( zCharSet ){
1341       sqlite3_free(azChar);
1342     }
1343   }
1344   sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1345 }
1346
1347
1348 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1349 /*
1350 ** The "unknown" function is automatically substituted in place of
1351 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN
1352 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
1353 ** When the "sqlite3" command-line shell is built using this functionality,
1354 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries
1355 ** involving application-defined functions to be examined in a generic
1356 ** sqlite3 shell.
1357 */
1358 static void unknownFunc(
1359   sqlite3_context *context,
1360   int argc,
1361   sqlite3_value **argv
1362 ){
1363   /* no-op */
1364 }
1365 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/
1366
1367
1368 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1369 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1370 ** when SQLite is built.
1371 */
1372 #ifdef SQLITE_SOUNDEX
1373 /*
1374 ** Compute the soundex encoding of a word.
1375 **
1376 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1377 ** soundex encoding of the string X.
1378 */
1379 static void soundexFunc(
1380   sqlite3_context *context,
1381   int argc,
1382   sqlite3_value **argv
1383 ){
1384   char zResult[8];
1385   const u8 *zIn;
1386   int i, j;
1387   static const unsigned char iCode[] = {
1388     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1389     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1390     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1391     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1392     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1393     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1394     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1395     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1396   };
1397   assert( argc==1 );
1398   zIn = (u8*)sqlite3_value_text(argv[0]);
1399   if( zIn==0 ) zIn = (u8*)"";
1400   for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
1401   if( zIn[i] ){
1402     u8 prevcode = iCode[zIn[i]&0x7f];
1403     zResult[0] = sqlite3Toupper(zIn[i]);
1404     for(j=1; j<4 && zIn[i]; i++){
1405       int code = iCode[zIn[i]&0x7f];
1406       if( code>0 ){
1407         if( code!=prevcode ){
1408           prevcode = code;
1409           zResult[j++] = code + '0';
1410         }
1411       }else{
1412         prevcode = 0;
1413       }
1414     }
1415     while( j<4 ){
1416       zResult[j++] = '0';
1417     }
1418     zResult[j] = 0;
1419     sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1420   }else{
1421     /* IMP: R-64894-50321 The string "?000" is returned if the argument
1422     ** is NULL or contains no ASCII alphabetic characters. */
1423     sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1424   }
1425 }
1426 #endif /* SQLITE_SOUNDEX */
1427
1428 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1429 /*
1430 ** A function that loads a shared-library extension then returns NULL.
1431 */
1432 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1433   const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1434   const char *zProc;
1435   sqlite3 *db = sqlite3_context_db_handle(context);
1436   char *zErrMsg = 0;
1437
1438   /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
1439   ** flag is set.  See the sqlite3_enable_load_extension() API.
1440   */
1441   if( (db->flags & SQLITE_LoadExtFunc)==0 ){
1442     sqlite3_result_error(context, "not authorized", -1);
1443     return;
1444   }
1445
1446   if( argc==2 ){
1447     zProc = (const char *)sqlite3_value_text(argv[1]);
1448   }else{
1449     zProc = 0;
1450   }
1451   if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1452     sqlite3_result_error(context, zErrMsg, -1);
1453     sqlite3_free(zErrMsg);
1454   }
1455 }
1456 #endif
1457
1458
1459 /*
1460 ** An instance of the following structure holds the context of a
1461 ** sum() or avg() aggregate computation.
1462 */
1463 typedef struct SumCtx SumCtx;
1464 struct SumCtx {
1465   double rSum;      /* Floating point sum */
1466   i64 iSum;         /* Integer sum */
1467   i64 cnt;          /* Number of elements summed */
1468   u8 overflow;      /* True if integer overflow seen */
1469   u8 approx;        /* True if non-integer value was input to the sum */
1470 };
1471
1472 /*
1473 ** Routines used to compute the sum, average, and total.
1474 **
1475 ** The SUM() function follows the (broken) SQL standard which means
1476 ** that it returns NULL if it sums over no inputs.  TOTAL returns
1477 ** 0.0 in that case.  In addition, TOTAL always returns a float where
1478 ** SUM might return an integer if it never encounters a floating point
1479 ** value.  TOTAL never fails, but SUM might through an exception if
1480 ** it overflows an integer.
1481 */
1482 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1483   SumCtx *p;
1484   int type;
1485   assert( argc==1 );
1486   UNUSED_PARAMETER(argc);
1487   p = sqlite3_aggregate_context(context, sizeof(*p));
1488   type = sqlite3_value_numeric_type(argv[0]);
1489   if( p && type!=SQLITE_NULL ){
1490     p->cnt++;
1491     if( type==SQLITE_INTEGER ){
1492       i64 v = sqlite3_value_int64(argv[0]);
1493       p->rSum += v;
1494       if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
1495         p->overflow = 1;
1496       }
1497     }else{
1498       p->rSum += sqlite3_value_double(argv[0]);
1499       p->approx = 1;
1500     }
1501   }
1502 }
1503 static void sumFinalize(sqlite3_context *context){
1504   SumCtx *p;
1505   p = sqlite3_aggregate_context(context, 0);
1506   if( p && p->cnt>0 ){
1507     if( p->overflow ){
1508       sqlite3_result_error(context,"integer overflow",-1);
1509     }else if( p->approx ){
1510       sqlite3_result_double(context, p->rSum);
1511     }else{
1512       sqlite3_result_int64(context, p->iSum);
1513     }
1514   }
1515 }
1516 static void avgFinalize(sqlite3_context *context){
1517   SumCtx *p;
1518   p = sqlite3_aggregate_context(context, 0);
1519   if( p && p->cnt>0 ){
1520     sqlite3_result_double(context, p->rSum/(double)p->cnt);
1521   }
1522 }
1523 static void totalFinalize(sqlite3_context *context){
1524   SumCtx *p;
1525   p = sqlite3_aggregate_context(context, 0);
1526   /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1527   sqlite3_result_double(context, p ? p->rSum : (double)0);
1528 }
1529
1530 /*
1531 ** The following structure keeps track of state information for the
1532 ** count() aggregate function.
1533 */
1534 typedef struct CountCtx CountCtx;
1535 struct CountCtx {
1536   i64 n;
1537 };
1538
1539 /*
1540 ** Routines to implement the count() aggregate function.
1541 */
1542 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1543   CountCtx *p;
1544   p = sqlite3_aggregate_context(context, sizeof(*p));
1545   if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1546     p->n++;
1547   }
1548
1549 #ifndef SQLITE_OMIT_DEPRECATED
1550   /* The sqlite3_aggregate_count() function is deprecated.  But just to make
1551   ** sure it still operates correctly, verify that its count agrees with our
1552   ** internal count when using count(*) and when the total count can be
1553   ** expressed as a 32-bit integer. */
1554   assert( argc==1 || p==0 || p->n>0x7fffffff
1555           || p->n==sqlite3_aggregate_count(context) );
1556 #endif
1557 }
1558 static void countFinalize(sqlite3_context *context){
1559   CountCtx *p;
1560   p = sqlite3_aggregate_context(context, 0);
1561   sqlite3_result_int64(context, p ? p->n : 0);
1562 }
1563
1564 /*
1565 ** Routines to implement min() and max() aggregate functions.
1566 */
1567 static void minmaxStep(
1568   sqlite3_context *context,
1569   int NotUsed,
1570   sqlite3_value **argv
1571 ){
1572   Mem *pArg  = (Mem *)argv[0];
1573   Mem *pBest;
1574   UNUSED_PARAMETER(NotUsed);
1575
1576   pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1577   if( !pBest ) return;
1578
1579   if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1580     if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
1581   }else if( pBest->flags ){
1582     int max;
1583     int cmp;
1584     CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1585     /* This step function is used for both the min() and max() aggregates,
1586     ** the only difference between the two being that the sense of the
1587     ** comparison is inverted. For the max() aggregate, the
1588     ** sqlite3_user_data() function returns (void *)-1. For min() it
1589     ** returns (void *)db, where db is the sqlite3* database pointer.
1590     ** Therefore the next statement sets variable 'max' to 1 for the max()
1591     ** aggregate, or 0 for min().
1592     */
1593     max = sqlite3_user_data(context)!=0;
1594     cmp = sqlite3MemCompare(pBest, pArg, pColl);
1595     if( (max && cmp<0) || (!max && cmp>0) ){
1596       sqlite3VdbeMemCopy(pBest, pArg);
1597     }else{
1598       sqlite3SkipAccumulatorLoad(context);
1599     }
1600   }else{
1601     pBest->db = sqlite3_context_db_handle(context);
1602     sqlite3VdbeMemCopy(pBest, pArg);
1603   }
1604 }
1605 static void minMaxFinalize(sqlite3_context *context){
1606   sqlite3_value *pRes;
1607   pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1608   if( pRes ){
1609     if( pRes->flags ){
1610       sqlite3_result_value(context, pRes);
1611     }
1612     sqlite3VdbeMemRelease(pRes);
1613   }
1614 }
1615
1616 /*
1617 ** group_concat(EXPR, ?SEPARATOR?)
1618 */
1619 static void groupConcatStep(
1620   sqlite3_context *context,
1621   int argc,
1622   sqlite3_value **argv
1623 ){
1624   const char *zVal;
1625   StrAccum *pAccum;
1626   const char *zSep;
1627   int nVal, nSep;
1628   assert( argc==1 || argc==2 );
1629   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1630   pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
1631
1632   if( pAccum ){
1633     sqlite3 *db = sqlite3_context_db_handle(context);
1634     int firstTerm = pAccum->mxAlloc==0;
1635     pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
1636     if( !firstTerm ){
1637       if( argc==2 ){
1638         zSep = (char*)sqlite3_value_text(argv[1]);
1639         nSep = sqlite3_value_bytes(argv[1]);
1640       }else{
1641         zSep = ",";
1642         nSep = 1;
1643       }
1644       if( zSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
1645     }
1646     zVal = (char*)sqlite3_value_text(argv[0]);
1647     nVal = sqlite3_value_bytes(argv[0]);
1648     if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
1649   }
1650 }
1651 static void groupConcatFinalize(sqlite3_context *context){
1652   StrAccum *pAccum;
1653   pAccum = sqlite3_aggregate_context(context, 0);
1654   if( pAccum ){
1655     if( pAccum->accError==STRACCUM_TOOBIG ){
1656       sqlite3_result_error_toobig(context);
1657     }else if( pAccum->accError==STRACCUM_NOMEM ){
1658       sqlite3_result_error_nomem(context);
1659     }else{
1660       sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
1661                           sqlite3_free);
1662     }
1663   }
1664 }
1665
1666 /*
1667 ** This routine does per-connection function registration.  Most
1668 ** of the built-in functions above are part of the global function set.
1669 ** This routine only deals with those that are not global.
1670 */
1671 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
1672   int rc = sqlite3_overload_function(db, "MATCH", 2);
1673   assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1674   if( rc==SQLITE_NOMEM ){
1675     sqlite3OomFault(db);
1676   }
1677 }
1678
1679 /*
1680 ** Set the LIKEOPT flag on the 2-argument function with the given name.
1681 */
1682 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
1683   FuncDef *pDef;
1684   pDef = sqlite3FindFunction(db, zName, 2, SQLITE_UTF8, 0);
1685   if( ALWAYS(pDef) ){
1686     pDef->funcFlags |= flagVal;
1687   }
1688 }
1689
1690 /*
1691 ** Register the built-in LIKE and GLOB functions.  The caseSensitive
1692 ** parameter determines whether or not the LIKE operator is case
1693 ** sensitive.  GLOB is always case sensitive.
1694 */
1695 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1696   struct compareInfo *pInfo;
1697   if( caseSensitive ){
1698     pInfo = (struct compareInfo*)&likeInfoAlt;
1699   }else{
1700     pInfo = (struct compareInfo*)&likeInfoNorm;
1701   }
1702   sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1703   sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1704   sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
1705       (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0);
1706   setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
1707   setLikeOptFlag(db, "like",
1708       caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
1709 }
1710
1711 /*
1712 ** pExpr points to an expression which implements a function.  If
1713 ** it is appropriate to apply the LIKE optimization to that function
1714 ** then set aWc[0] through aWc[2] to the wildcard characters and the
1715 ** escape character and then return TRUE.  If the function is not a
1716 ** LIKE-style function then return FALSE.
1717 **
1718 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
1719 ** operator if c is a string literal that is exactly one byte in length.
1720 ** That one byte is stored in aWc[3].  aWc[3] is set to zero if there is
1721 ** no ESCAPE clause.
1722 **
1723 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
1724 ** the function (default for LIKE).  If the function makes the distinction
1725 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
1726 ** false.
1727 */
1728 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1729   FuncDef *pDef;
1730   int nExpr;
1731   if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){
1732     return 0;
1733   }
1734   assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
1735   nExpr = pExpr->x.pList->nExpr;
1736   pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
1737   if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
1738     return 0;
1739   }
1740   if( nExpr<3 ){
1741     aWc[3] = 0;
1742   }else{
1743     Expr *pEscape = pExpr->x.pList->a[2].pExpr;
1744     char *zEscape;
1745     if( pEscape->op!=TK_STRING ) return 0;
1746     zEscape = pEscape->u.zToken;
1747     if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
1748     aWc[3] = zEscape[0];
1749   }
1750
1751   /* The memcpy() statement assumes that the wildcard characters are
1752   ** the first three statements in the compareInfo structure.  The
1753   ** asserts() that follow verify that assumption
1754   */
1755   memcpy(aWc, pDef->pUserData, 3);
1756   assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1757   assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1758   assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1759   *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
1760   return 1;
1761 }
1762
1763 /*
1764 ** All of the FuncDef structures in the aBuiltinFunc[] array above
1765 ** to the global function hash table.  This occurs at start-time (as
1766 ** a consequence of calling sqlite3_initialize()).
1767 **
1768 ** After this routine runs
1769 */
1770 void sqlite3RegisterBuiltinFunctions(void){
1771   /*
1772   ** The following array holds FuncDef structures for all of the functions
1773   ** defined in this file.
1774   **
1775   ** The array cannot be constant since changes are made to the
1776   ** FuncDef.pHash elements at start-time.  The elements of this array
1777   ** are read-only after initialization is complete.
1778   **
1779   ** For peak efficiency, put the most frequently used function last.
1780   */
1781   static FuncDef aBuiltinFunc[] = {
1782 #ifdef SQLITE_SOUNDEX
1783     FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
1784 #endif
1785 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1786     VFUNCTION(load_extension,    1, 0, 0, loadExt          ),
1787     VFUNCTION(load_extension,    2, 0, 0, loadExt          ),
1788 #endif
1789 #if SQLITE_USER_AUTHENTICATION
1790     FUNCTION(sqlite_crypt,       2, 0, 0, sqlite3CryptFunc ),
1791 #endif
1792 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1793     DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
1794     DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
1795 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1796     FUNCTION2(unlikely,          1, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1797     FUNCTION2(likelihood,        2, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1798     FUNCTION2(likely,            1, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
1799 #ifdef SQLITE_DEBUG
1800     FUNCTION2(affinity,          1, 0, 0, noopFunc,  SQLITE_FUNC_AFFINITY),
1801 #endif
1802     FUNCTION(ltrim,              1, 1, 0, trimFunc         ),
1803     FUNCTION(ltrim,              2, 1, 0, trimFunc         ),
1804     FUNCTION(rtrim,              1, 2, 0, trimFunc         ),
1805     FUNCTION(rtrim,              2, 2, 0, trimFunc         ),
1806     FUNCTION(trim,               1, 3, 0, trimFunc         ),
1807     FUNCTION(trim,               2, 3, 0, trimFunc         ),
1808     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
1809     FUNCTION(min,                0, 0, 1, 0                ),
1810     AGGREGATE2(min,              1, 0, 1, minmaxStep,      minMaxFinalize,
1811                                           SQLITE_FUNC_MINMAX ),
1812     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
1813     FUNCTION(max,                0, 1, 1, 0                ),
1814     AGGREGATE2(max,              1, 1, 1, minmaxStep,      minMaxFinalize,
1815                                           SQLITE_FUNC_MINMAX ),
1816     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
1817     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
1818     FUNCTION(instr,              2, 0, 0, instrFunc        ),
1819     FUNCTION(printf,            -1, 0, 0, printfFunc       ),
1820     FUNCTION(unicode,            1, 0, 0, unicodeFunc      ),
1821     FUNCTION(char,              -1, 0, 0, charFunc         ),
1822     FUNCTION(abs,                1, 0, 0, absFunc          ),
1823 #ifndef SQLITE_OMIT_FLOATING_POINT
1824     FUNCTION(round,              1, 0, 0, roundFunc        ),
1825     FUNCTION(round,              2, 0, 0, roundFunc        ),
1826 #endif
1827     FUNCTION(upper,              1, 0, 0, upperFunc        ),
1828     FUNCTION(lower,              1, 0, 0, lowerFunc        ),
1829     FUNCTION(hex,                1, 0, 0, hexFunc          ),
1830     FUNCTION2(ifnull,            2, 0, 0, noopFunc,  SQLITE_FUNC_COALESCE),
1831     VFUNCTION(random,            0, 0, 0, randomFunc       ),
1832     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
1833     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
1834     DFUNCTION(sqlite_version,    0, 0, 0, versionFunc      ),
1835     DFUNCTION(sqlite_source_id,  0, 0, 0, sourceidFunc     ),
1836     FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
1837     FUNCTION(quote,              1, 0, 0, quoteFunc        ),
1838     VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
1839     VFUNCTION(changes,           0, 0, 0, changes          ),
1840     VFUNCTION(total_changes,     0, 0, 0, total_changes    ),
1841     FUNCTION(replace,            3, 0, 0, replaceFunc      ),
1842     FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
1843     FUNCTION(substr,             2, 0, 0, substrFunc       ),
1844     FUNCTION(substr,             3, 0, 0, substrFunc       ),
1845     AGGREGATE(sum,               1, 0, 0, sumStep,         sumFinalize    ),
1846     AGGREGATE(total,             1, 0, 0, sumStep,         totalFinalize    ),
1847     AGGREGATE(avg,               1, 0, 0, sumStep,         avgFinalize    ),
1848     AGGREGATE2(count,            0, 0, 0, countStep,       countFinalize,
1849                SQLITE_FUNC_COUNT  ),
1850     AGGREGATE(count,             1, 0, 0, countStep,       countFinalize  ),
1851     AGGREGATE(group_concat,      1, 0, 0, groupConcatStep, groupConcatFinalize),
1852     AGGREGATE(group_concat,      2, 0, 0, groupConcatStep, groupConcatFinalize),
1853
1854     LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1855 #ifdef SQLITE_CASE_SENSITIVE_LIKE
1856     LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1857     LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1858 #else
1859     LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
1860     LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
1861 #endif
1862 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1863     FUNCTION(unknown,           -1, 0, 0, unknownFunc      ),
1864 #endif
1865     FUNCTION(coalesce,           1, 0, 0, 0                ),
1866     FUNCTION(coalesce,           0, 0, 0, 0                ),
1867     FUNCTION2(coalesce,         -1, 0, 0, noopFunc,  SQLITE_FUNC_COALESCE),
1868   };
1869 #ifndef SQLITE_OMIT_ALTERTABLE
1870   sqlite3AlterFunctions();
1871 #endif
1872 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4)
1873   sqlite3AnalyzeFunctions();
1874 #endif
1875   sqlite3RegisterDateTimeFunctions();
1876   sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
1877
1878 #if 0  /* Enable to print out how the built-in functions are hashed */
1879   {
1880     int i;
1881     FuncDef *p;
1882     for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
1883       printf("FUNC-HASH %02d:", i);
1884       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
1885         int n = sqlite3Strlen30(p->zName);
1886         int h = p->zName[0] + n;
1887         printf(" %s(%d)", p->zName, h);
1888       }
1889       printf("\n");
1890     }
1891   }
1892 #endif
1893 }