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