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