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