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   if( zString==0 ){
 827     return zGlobPattern!=0;
 828   }else if( zGlobPattern==0 ){
 829     return 1;
 830   }else {
 831     return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[');
 832   }
 833 }
 834
 835 /*
 836 ** The sqlite3_strlike() interface.  Return 0 on a match and non-zero for
 837 ** a miss - like strcmp().
 838 */
 839 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){
 840   if( zStr==0 ){
 841     return zPattern!=0;
 842   }else if( zPattern==0 ){
 843     return 1;
 844   }else{
 845     return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc);
 846   }
 847 }
 848
 849 /*
 850 ** Count the number of times that the LIKE operator (or GLOB which is
 851 ** just a variation of LIKE) gets called.  This is used for testing
 852 ** only.
 853 */
 854 #ifdef SQLITE_TEST
 855 int sqlite3_like_count = 0;
 856 #endif
 857
 858
 859 /*
 860 ** Implementation of the like() SQL function.  This function implements
 861 ** the build-in LIKE operator.  The first argument to the function is the
 862 ** pattern and the second argument is the string.  So, the SQL statements:
 863 **
 864 **       A LIKE B
 865 **
 866 ** is implemented as like(B,A).
 867 **
 868 ** This same function (with a different compareInfo structure) computes
 869 ** the GLOB operator.
 870 */
 871 static void likeFunc(
 872   sqlite3_context *context,
 873   int argc,
 874   sqlite3_value **argv
 875 ){
 876   const unsigned char *zA, *zB;
 877   u32 escape;
 878   int nPat;
 879   sqlite3 *db = sqlite3_context_db_handle(context);
 880   struct compareInfo *pInfo = sqlite3_user_data(context);
 881   struct compareInfo backupInfo;
 882
 883 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
 884   if( sqlite3_value_type(argv[0])==SQLITE_BLOB
 885    || sqlite3_value_type(argv[1])==SQLITE_BLOB
 886   ){
 887 #ifdef SQLITE_TEST
 888     sqlite3_like_count++;
 889 #endif
 890     sqlite3_result_int(context, 0);
 891     return;
 892   }
 893 #endif
 894
 895   /* Limit the length of the LIKE or GLOB pattern to avoid problems
 896   ** of deep recursion and N*N behavior in patternCompare().
 897   */
 898   nPat = sqlite3_value_bytes(argv[0]);
 899   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
 900   testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
 901   if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
 902     sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
 903     return;
 904   }
 905   if( argc==3 ){
 906     /* The escape character string must consist of a single UTF-8 character.
 907     ** Otherwise, return an error.
 908     */
 909     const unsigned char *zEsc = sqlite3_value_text(argv[2]);
 910     if( zEsc==0 ) return;
 911     if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
 912       sqlite3_result_error(context,
 913           "ESCAPE expression must be a single character", -1);
 914       return;
 915     }
 916     escape = sqlite3Utf8Read(&zEsc);
 917     if( escape==pInfo->matchAll || escape==pInfo->matchOne ){
 918       memcpy(&backupInfo, pInfo, sizeof(backupInfo));
 919       pInfo = &backupInfo;
 920       if( escape==pInfo->matchAll ) pInfo->matchAll = 0;
 921       if( escape==pInfo->matchOne ) pInfo->matchOne = 0;
 922     }
 923   }else{
 924     escape = pInfo->matchSet;
 925   }
 926   zB = sqlite3_value_text(argv[0]);
 927   zA = sqlite3_value_text(argv[1]);
 928   if( zA && zB ){
 929 #ifdef SQLITE_TEST
 930     sqlite3_like_count++;
 931 #endif
 932     sqlite3_result_int(context,
 933                       patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH);
 934   }
 935 }
 936
 937 /*
 938 ** Implementation of the NULLIF(x,y) function.  The result is the first
 939 ** argument if the arguments are different.  The result is NULL if the
 940 ** arguments are equal to each other.
 941 */
 942 static void nullifFunc(
 943   sqlite3_context *context,
 944   int NotUsed,
 945   sqlite3_value **argv
 946 ){
 947   CollSeq *pColl = sqlite3GetFuncCollSeq(context);
 948   UNUSED_PARAMETER(NotUsed);
 949   if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
 950     sqlite3_result_value(context, argv[0]);
 951   }
 952 }
 953
 954 /*
 955 ** Implementation of the sqlite_version() function.  The result is the version
 956 ** of the SQLite library that is running.
 957 */
 958 static void versionFunc(
 959   sqlite3_context *context,
 960   int NotUsed,
 961   sqlite3_value **NotUsed2
 962 ){
 963   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 964   /* IMP: R-48699-48617 This function is an SQL wrapper around the
 965   ** sqlite3_libversion() C-interface. */
 966   sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
 967 }
 968
 969 /*
 970 ** Implementation of the sqlite_source_id() function. The result is a string
 971 ** that identifies the particular version of the source code used to build
 972 ** SQLite.
 973 */
 974 static void sourceidFunc(
 975   sqlite3_context *context,
 976   int NotUsed,
 977   sqlite3_value **NotUsed2
 978 ){
 979   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 980   /* IMP: R-24470-31136 This function is an SQL wrapper around the
 981   ** sqlite3_sourceid() C interface. */
 982   sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
 983 }
 984
 985 /*
 986 ** Implementation of the sqlite_log() function.  This is a wrapper around
 987 ** sqlite3_log().  The return value is NULL.  The function exists purely for
 988 ** its side-effects.
 989 */
 990 static void errlogFunc(
 991   sqlite3_context *context,
 992   int argc,
 993   sqlite3_value **argv
 994 ){
 995   UNUSED_PARAMETER(argc);
 996   UNUSED_PARAMETER(context);
 997   sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
 998 }
 999
1000 /*
1001 ** Implementation of the sqlite_compileoption_used() function.
1002 ** The result is an integer that identifies if the compiler option
1003 ** was used to build SQLite.
1004 */
1005 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1006 static void compileoptionusedFunc(
1007   sqlite3_context *context,
1008   int argc,
1009   sqlite3_value **argv
1010 ){
1011   const char *zOptName;
1012   assert( argc==1 );
1013   UNUSED_PARAMETER(argc);
1014   /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
1015   ** function is a wrapper around the sqlite3_compileoption_used() C/C++
1016   ** function.
1017   */
1018   if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
1019     sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
1020   }
1021 }
1022 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1023
1024 /*
1025 ** Implementation of the sqlite_compileoption_get() function.
1026 ** The result is a string that identifies the compiler options
1027 ** used to build SQLite.
1028 */
1029 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1030 static void compileoptiongetFunc(
1031   sqlite3_context *context,
1032   int argc,
1033   sqlite3_value **argv
1034 ){
1035   int n;
1036   assert( argc==1 );
1037   UNUSED_PARAMETER(argc);
1038   /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
1039   ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
1040   */
1041   n = sqlite3_value_int(argv[0]);
1042   sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
1043 }
1044 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1045
1046 /* Array for converting from half-bytes (nybbles) into ASCII hex
1047 ** digits. */
1048 static const char hexdigits[] = {
1049   '0', '1', '2', '3', '4', '5', '6', '7',
1050   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
1051 };
1052
1053 /*
1054 ** Append to pStr text that is the SQL literal representation of the
1055 ** value contained in pValue.
1056 */
1057 void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){
1058   /* As currently implemented, the string must be initially empty.
1059   ** we might relax this requirement in the future, but that will
1060   ** require enhancements to the implementation. */
1061   assert( pStr!=0 && pStr->nChar==0 );
1062
1063   switch( sqlite3_value_type(pValue) ){
1064     case SQLITE_FLOAT: {
1065       double r1, r2;
1066       const char *zVal;
1067       r1 = sqlite3_value_double(pValue);
1068       sqlite3_str_appendf(pStr, "%!.15g", r1);
1069       zVal = sqlite3_str_value(pStr);
1070       if( zVal ){
1071         sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8);
1072         if( r1!=r2 ){
1073           sqlite3_str_reset(pStr);
1074           sqlite3_str_appendf(pStr, "%!.20e", r1);
1075         }
1076       }
1077       break;
1078     }
1079     case SQLITE_INTEGER: {
1080       sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue));
1081       break;
1082     }
1083     case SQLITE_BLOB: {
1084       char const *zBlob = sqlite3_value_blob(pValue);
1085       int nBlob = sqlite3_value_bytes(pValue);
1086       assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */
1087       sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4);
1088       if( pStr->accError==0 ){
1089         char *zText = pStr->zText;
1090         int i;
1091         for(i=0; i<nBlob; i++){
1092           zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
1093           zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
1094         }
1095         zText[(nBlob*2)+2] = '\'';
1096         zText[(nBlob*2)+3] = '\0';
1097         zText[0] = 'X';
1098         zText[1] = '\'';
1099         pStr->nChar = nBlob*2 + 3;
1100       }
1101       break;
1102     }
1103     case SQLITE_TEXT: {
1104       const unsigned char *zArg = sqlite3_value_text(pValue);
1105       sqlite3_str_appendf(pStr, "%Q", zArg);
1106       break;
1107     }
1108     default: {
1109       assert( sqlite3_value_type(pValue)==SQLITE_NULL );
1110       sqlite3_str_append(pStr, "NULL", 4);
1111       break;
1112     }
1113   }
1114 }
1115
1116 /*
1117 ** Implementation of the QUOTE() function.
1118 **
1119 ** The quote(X) function returns the text of an SQL literal which is the
1120 ** value of its argument suitable for inclusion into an SQL statement.
1121 ** Strings are surrounded by single-quotes with escapes on interior quotes
1122 ** as needed. BLOBs are encoded as hexadecimal literals. Strings with
1123 ** embedded NUL characters cannot be represented as string literals in SQL
1124 ** and hence the returned string literal is truncated prior to the first NUL.
1125 */
1126 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1127   sqlite3_str str;
1128   sqlite3 *db = sqlite3_context_db_handle(context);
1129   assert( argc==1 );
1130   UNUSED_PARAMETER(argc);
1131   sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
1132   sqlite3QuoteValue(&str,argv[0]);
1133   sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar,
1134                       SQLITE_DYNAMIC);
1135   if( str.accError!=SQLITE_OK ){
1136     sqlite3_result_null(context);
1137     sqlite3_result_error_code(context, str.accError);
1138   }
1139 }
1140
1141 /*
1142 ** The unicode() function.  Return the integer unicode code-point value
1143 ** for the first character of the input string.
1144 */
1145 static void unicodeFunc(
1146   sqlite3_context *context,
1147   int argc,
1148   sqlite3_value **argv
1149 ){
1150   const unsigned char *z = sqlite3_value_text(argv[0]);
1151   (void)argc;
1152   if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
1153 }
1154
1155 /*
1156 ** The char() function takes zero or more arguments, each of which is
1157 ** an integer.  It constructs a string where each character of the string
1158 ** is the unicode character for the corresponding integer argument.
1159 */
1160 static void charFunc(
1161   sqlite3_context *context,
1162   int argc,
1163   sqlite3_value **argv
1164 ){
1165   unsigned char *z, *zOut;
1166   int i;
1167   zOut = z = sqlite3_malloc64( argc*4+1 );
1168   if( z==0 ){
1169     sqlite3_result_error_nomem(context);
1170     return;
1171   }
1172   for(i=0; i<argc; i++){
1173     sqlite3_int64 x;
1174     unsigned c;
1175     x = sqlite3_value_int64(argv[i]);
1176     if( x<0 || x>0x10ffff ) x = 0xfffd;
1177     c = (unsigned)(x & 0x1fffff);
1178     if( c<0x00080 ){
1179       *zOut++ = (u8)(c&0xFF);
1180     }else if( c<0x00800 ){
1181       *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
1182       *zOut++ = 0x80 + (u8)(c & 0x3F);
1183     }else if( c<0x10000 ){
1184       *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
1185       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1186       *zOut++ = 0x80 + (u8)(c & 0x3F);
1187     }else{
1188       *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
1189       *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
1190       *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1191       *zOut++ = 0x80 + (u8)(c & 0x3F);
1192     }                                                    \
1193   }
1194   sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
1195 }
1196
1197 /*
1198 ** The hex() function.  Interpret the argument as a blob.  Return
1199 ** a hexadecimal rendering as text.
1200 */
1201 static void hexFunc(
1202   sqlite3_context *context,
1203   int argc,
1204   sqlite3_value **argv
1205 ){
1206   int i, n;
1207   const unsigned char *pBlob;
1208   char *zHex, *z;
1209   assert( argc==1 );
1210   UNUSED_PARAMETER(argc);
1211   pBlob = sqlite3_value_blob(argv[0]);
1212   n = sqlite3_value_bytes(argv[0]);
1213   assert( pBlob==sqlite3_value_blob(argv[0]) );  /* No encoding change */
1214   z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
1215   if( zHex ){
1216     for(i=0; i<n; i++, pBlob++){
1217       unsigned char c = *pBlob;
1218       *(z++) = hexdigits[(c>>4)&0xf];
1219       *(z++) = hexdigits[c&0xf];
1220     }
1221     *z = 0;
1222     sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1223   }
1224 }
1225
1226 /*
1227 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1228 */
1229 static void zeroblobFunc(
1230   sqlite3_context *context,
1231   int argc,
1232   sqlite3_value **argv
1233 ){
1234   i64 n;
1235   int rc;
1236   assert( argc==1 );
1237   UNUSED_PARAMETER(argc);
1238   n = sqlite3_value_int64(argv[0]);
1239   if( n<0 ) n = 0;
1240   rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
1241   if( rc ){
1242     sqlite3_result_error_code(context, rc);
1243   }
1244 }
1245
1246 /*
1247 ** The replace() function.  Three arguments are all strings: call
1248 ** them A, B, and C. The result is also a string which is derived
1249 ** from A by replacing every occurrence of B with C.  The match
1250 ** must be exact.  Collating sequences are not used.
1251 */
1252 static void replaceFunc(
1253   sqlite3_context *context,
1254   int argc,
1255   sqlite3_value **argv
1256 ){
1257   const unsigned char *zStr;        /* The input string A */
1258   const unsigned char *zPattern;    /* The pattern string B */
1259   const unsigned char *zRep;        /* The replacement string C */
1260   unsigned char *zOut;              /* The output */
1261   int nStr;                /* Size of zStr */
1262   int nPattern;            /* Size of zPattern */
1263   int nRep;                /* Size of zRep */
1264   i64 nOut;                /* Maximum size of zOut */
1265   int loopLimit;           /* Last zStr[] that might match zPattern[] */
1266   int i, j;                /* Loop counters */
1267   unsigned cntExpand;      /* Number zOut expansions */
1268   sqlite3 *db = sqlite3_context_db_handle(context);
1269
1270   assert( argc==3 );
1271   UNUSED_PARAMETER(argc);
1272   zStr = sqlite3_value_text(argv[0]);
1273   if( zStr==0 ) return;
1274   nStr = sqlite3_value_bytes(argv[0]);
1275   assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */
1276   zPattern = sqlite3_value_text(argv[1]);
1277   if( zPattern==0 ){
1278     assert( sqlite3_value_type(argv[1])==SQLITE_NULL
1279             || sqlite3_context_db_handle(context)->mallocFailed );
1280     return;
1281   }
1282   if( zPattern[0]==0 ){
1283     assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
1284     sqlite3_result_value(context, argv[0]);
1285     return;
1286   }
1287   nPattern = sqlite3_value_bytes(argv[1]);
1288   assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */
1289   zRep = sqlite3_value_text(argv[2]);
1290   if( zRep==0 ) return;
1291   nRep = sqlite3_value_bytes(argv[2]);
1292   assert( zRep==sqlite3_value_text(argv[2]) );
1293   nOut = nStr + 1;
1294   assert( nOut<SQLITE_MAX_LENGTH );
1295   zOut = contextMalloc(context, (i64)nOut);
1296   if( zOut==0 ){
1297     return;
1298   }
1299   loopLimit = nStr - nPattern;
1300   cntExpand = 0;
1301   for(i=j=0; i<=loopLimit; i++){
1302     if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1303       zOut[j++] = zStr[i];
1304     }else{
1305       if( nRep>nPattern ){
1306         nOut += nRep - nPattern;
1307         testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
1308         testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
1309         if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1310           sqlite3_result_error_toobig(context);
1311           sqlite3_free(zOut);
1312           return;
1313         }
1314         cntExpand++;
1315         if( (cntExpand&(cntExpand-1))==0 ){
1316           /* Grow the size of the output buffer only on substitutions
1317           ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
1318           u8 *zOld;
1319           zOld = zOut;
1320           zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
1321           if( zOut==0 ){
1322             sqlite3_result_error_nomem(context);
1323             sqlite3_free(zOld);
1324             return;
1325           }
1326         }
1327       }
1328       memcpy(&zOut[j], zRep, nRep);
1329       j += nRep;
1330       i += nPattern-1;
1331     }
1332   }
1333   assert( j+nStr-i+1<=nOut );
1334   memcpy(&zOut[j], &zStr[i], nStr-i);
1335   j += nStr - i;
1336   assert( j<=nOut );
1337   zOut[j] = 0;
1338   sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1339 }
1340
1341 /*
1342 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1343 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1344 */
1345 static void trimFunc(
1346   sqlite3_context *context,
1347   int argc,
1348   sqlite3_value **argv
1349 ){
1350   const unsigned char *zIn;         /* Input string */
1351   const unsigned char *zCharSet;    /* Set of characters to trim */
1352   unsigned int nIn;                 /* Number of bytes in input */
1353   int flags;                        /* 1: trimleft  2: trimright  3: trim */
1354   int i;                            /* Loop counter */
1355   unsigned int *aLen = 0;           /* Length of each character in zCharSet */
1356   unsigned char **azChar = 0;       /* Individual characters in zCharSet */
1357   int nChar;                        /* Number of characters in zCharSet */
1358
1359   if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1360     return;
1361   }
1362   zIn = sqlite3_value_text(argv[0]);
1363   if( zIn==0 ) return;
1364   nIn = (unsigned)sqlite3_value_bytes(argv[0]);
1365   assert( zIn==sqlite3_value_text(argv[0]) );
1366   if( argc==1 ){
1367     static const unsigned lenOne[] = { 1 };
1368     static unsigned char * const azOne[] = { (u8*)" " };
1369     nChar = 1;
1370     aLen = (unsigned*)lenOne;
1371     azChar = (unsigned char **)azOne;
1372     zCharSet = 0;
1373   }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1374     return;
1375   }else{
1376     const unsigned char *z;
1377     for(z=zCharSet, nChar=0; *z; nChar++){
1378       SQLITE_SKIP_UTF8(z);
1379     }
1380     if( nChar>0 ){
1381       azChar = contextMalloc(context,
1382                      ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
1383       if( azChar==0 ){
1384         return;
1385       }
1386       aLen = (unsigned*)&azChar[nChar];
1387       for(z=zCharSet, nChar=0; *z; nChar++){
1388         azChar[nChar] = (unsigned char *)z;
1389         SQLITE_SKIP_UTF8(z);
1390         aLen[nChar] = (unsigned)(z - azChar[nChar]);
1391       }
1392     }
1393   }
1394   if( nChar>0 ){
1395     flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
1396     if( flags & 1 ){
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, azChar[i], len)==0 ) break;
1402         }
1403         if( i>=nChar ) break;
1404         zIn += len;
1405         nIn -= len;
1406       }
1407     }
1408     if( flags & 2 ){
1409       while( nIn>0 ){
1410         unsigned int len = 0;
1411         for(i=0; i<nChar; i++){
1412           len = aLen[i];
1413           if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1414         }
1415         if( i>=nChar ) break;
1416         nIn -= len;
1417       }
1418     }
1419     if( zCharSet ){
1420       sqlite3_free(azChar);
1421     }
1422   }
1423   sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1424 }
1425
1426
1427 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1428 /*
1429 ** The "unknown" function is automatically substituted in place of
1430 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN
1431 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
1432 ** When the "sqlite3" command-line shell is built using this functionality,
1433 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries
1434 ** involving application-defined functions to be examined in a generic
1435 ** sqlite3 shell.
1436 */
1437 static void unknownFunc(
1438   sqlite3_context *context,
1439   int argc,
1440   sqlite3_value **argv
1441 ){
1442   /* no-op */
1443 }
1444 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/
1445
1446
1447 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1448 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1449 ** when SQLite is built.
1450 */
1451 #ifdef SQLITE_SOUNDEX
1452 /*
1453 ** Compute the soundex encoding of a word.
1454 **
1455 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1456 ** soundex encoding of the string X.
1457 */
1458 static void soundexFunc(
1459   sqlite3_context *context,
1460   int argc,
1461   sqlite3_value **argv
1462 ){
1463   char zResult[8];
1464   const u8 *zIn;
1465   int i, j;
1466   static const unsigned char iCode[] = {
1467     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1468     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1469     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1470     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1471     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1472     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1473     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1474     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1475   };
1476   assert( argc==1 );
1477   zIn = (u8*)sqlite3_value_text(argv[0]);
1478   if( zIn==0 ) zIn = (u8*)"";
1479   for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
1480   if( zIn[i] ){
1481     u8 prevcode = iCode[zIn[i]&0x7f];
1482     zResult[0] = sqlite3Toupper(zIn[i]);
1483     for(j=1; j<4 && zIn[i]; i++){
1484       int code = iCode[zIn[i]&0x7f];
1485       if( code>0 ){
1486         if( code!=prevcode ){
1487           prevcode = code;
1488           zResult[j++] = code + '0';
1489         }
1490       }else{
1491         prevcode = 0;
1492       }
1493     }
1494     while( j<4 ){
1495       zResult[j++] = '0';
1496     }
1497     zResult[j] = 0;
1498     sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1499   }else{
1500     /* IMP: R-64894-50321 The string "?000" is returned if the argument
1501     ** is NULL or contains no ASCII alphabetic characters. */
1502     sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1503   }
1504 }
1505 #endif /* SQLITE_SOUNDEX */
1506
1507 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1508 /*
1509 ** A function that loads a shared-library extension then returns NULL.
1510 */
1511 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1512   const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1513   const char *zProc;
1514   sqlite3 *db = sqlite3_context_db_handle(context);
1515   char *zErrMsg = 0;
1516
1517   /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
1518   ** flag is set.  See the sqlite3_enable_load_extension() API.
1519   */
1520   if( (db->flags & SQLITE_LoadExtFunc)==0 ){
1521     sqlite3_result_error(context, "not authorized", -1);
1522     return;
1523   }
1524
1525   if( argc==2 ){
1526     zProc = (const char *)sqlite3_value_text(argv[1]);
1527   }else{
1528     zProc = 0;
1529   }
1530   if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1531     sqlite3_result_error(context, zErrMsg, -1);
1532     sqlite3_free(zErrMsg);
1533   }
1534 }
1535 #endif
1536
1537
1538 /*
1539 ** An instance of the following structure holds the context of a
1540 ** sum() or avg() aggregate computation.
1541 */
1542 typedef struct SumCtx SumCtx;
1543 struct SumCtx {
1544   double rSum;      /* Floating point sum */
1545   i64 iSum;         /* Integer sum */
1546   i64 cnt;          /* Number of elements summed */
1547   u8 overflow;      /* True if integer overflow seen */
1548   u8 approx;        /* True if non-integer value was input to the sum */
1549 };
1550
1551 /*
1552 ** Routines used to compute the sum, average, and total.
1553 **
1554 ** The SUM() function follows the (broken) SQL standard which means
1555 ** that it returns NULL if it sums over no inputs.  TOTAL returns
1556 ** 0.0 in that case.  In addition, TOTAL always returns a float where
1557 ** SUM might return an integer if it never encounters a floating point
1558 ** value.  TOTAL never fails, but SUM might through an exception if
1559 ** it overflows an integer.
1560 */
1561 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1562   SumCtx *p;
1563   int type;
1564   assert( argc==1 );
1565   UNUSED_PARAMETER(argc);
1566   p = sqlite3_aggregate_context(context, sizeof(*p));
1567   type = sqlite3_value_numeric_type(argv[0]);
1568   if( p && type!=SQLITE_NULL ){
1569     p->cnt++;
1570     if( type==SQLITE_INTEGER ){
1571       i64 v = sqlite3_value_int64(argv[0]);
1572       p->rSum += v;
1573       if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
1574         p->approx = p->overflow = 1;
1575       }
1576     }else{
1577       p->rSum += sqlite3_value_double(argv[0]);
1578       p->approx = 1;
1579     }
1580   }
1581 }
1582 #ifndef SQLITE_OMIT_WINDOWFUNC
1583 static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){
1584   SumCtx *p;
1585   int type;
1586   assert( argc==1 );
1587   UNUSED_PARAMETER(argc);
1588   p = sqlite3_aggregate_context(context, sizeof(*p));
1589   type = sqlite3_value_numeric_type(argv[0]);
1590   /* p is always non-NULL because sumStep() will have been called first
1591   ** to initialize it */
1592   if( ALWAYS(p) && type!=SQLITE_NULL ){
1593     assert( p->cnt>0 );
1594     p->cnt--;
1595     assert( type==SQLITE_INTEGER || p->approx );
1596     if( type==SQLITE_INTEGER && p->approx==0 ){
1597       i64 v = sqlite3_value_int64(argv[0]);
1598       p->rSum -= v;
1599       p->iSum -= v;
1600     }else{
1601       p->rSum -= sqlite3_value_double(argv[0]);
1602     }
1603   }
1604 }
1605 #else
1606 # define sumInverse 0
1607 #endif /* SQLITE_OMIT_WINDOWFUNC */
1608 static void sumFinalize(sqlite3_context *context){
1609   SumCtx *p;
1610   p = sqlite3_aggregate_context(context, 0);
1611   if( p && p->cnt>0 ){
1612     if( p->overflow ){
1613       sqlite3_result_error(context,"integer overflow",-1);
1614     }else if( p->approx ){
1615       sqlite3_result_double(context, p->rSum);
1616     }else{
1617       sqlite3_result_int64(context, p->iSum);
1618     }
1619   }
1620 }
1621 static void avgFinalize(sqlite3_context *context){
1622   SumCtx *p;
1623   p = sqlite3_aggregate_context(context, 0);
1624   if( p && p->cnt>0 ){
1625     sqlite3_result_double(context, p->rSum/(double)p->cnt);
1626   }
1627 }
1628 static void totalFinalize(sqlite3_context *context){
1629   SumCtx *p;
1630   p = sqlite3_aggregate_context(context, 0);
1631   /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1632   sqlite3_result_double(context, p ? p->rSum : (double)0);
1633 }
1634
1635 /*
1636 ** The following structure keeps track of state information for the
1637 ** count() aggregate function.
1638 */
1639 typedef struct CountCtx CountCtx;
1640 struct CountCtx {
1641   i64 n;
1642 #ifdef SQLITE_DEBUG
1643   int bInverse;                   /* True if xInverse() ever called */
1644 #endif
1645 };
1646
1647 /*
1648 ** Routines to implement the count() aggregate function.
1649 */
1650 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1651   CountCtx *p;
1652   p = sqlite3_aggregate_context(context, sizeof(*p));
1653   if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1654     p->n++;
1655   }
1656
1657 #ifndef SQLITE_OMIT_DEPRECATED
1658   /* The sqlite3_aggregate_count() function is deprecated.  But just to make
1659   ** sure it still operates correctly, verify that its count agrees with our
1660   ** internal count when using count(*) and when the total count can be
1661   ** expressed as a 32-bit integer. */
1662   assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
1663           || p->n==sqlite3_aggregate_count(context) );
1664 #endif
1665 }
1666 static void countFinalize(sqlite3_context *context){
1667   CountCtx *p;
1668   p = sqlite3_aggregate_context(context, 0);
1669   sqlite3_result_int64(context, p ? p->n : 0);
1670 }
1671 #ifndef SQLITE_OMIT_WINDOWFUNC
1672 static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
1673   CountCtx *p;
1674   p = sqlite3_aggregate_context(ctx, sizeof(*p));
1675   /* p is always non-NULL since countStep() will have been called first */
1676   if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){
1677     p->n--;
1678 #ifdef SQLITE_DEBUG
1679     p->bInverse = 1;
1680 #endif
1681   }
1682 }
1683 #else
1684 # define countInverse 0
1685 #endif /* SQLITE_OMIT_WINDOWFUNC */
1686
1687 /*
1688 ** Routines to implement min() and max() aggregate functions.
1689 */
1690 static void minmaxStep(
1691   sqlite3_context *context,
1692   int NotUsed,
1693   sqlite3_value **argv
1694 ){
1695   Mem *pArg  = (Mem *)argv[0];
1696   Mem *pBest;
1697   UNUSED_PARAMETER(NotUsed);
1698
1699   pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1700   if( !pBest ) return;
1701
1702   if( sqlite3_value_type(pArg)==SQLITE_NULL ){
1703     if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
1704   }else if( pBest->flags ){
1705     int max;
1706     int cmp;
1707     CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1708     /* This step function is used for both the min() and max() aggregates,
1709     ** the only difference between the two being that the sense of the
1710     ** comparison is inverted. For the max() aggregate, the
1711     ** sqlite3_user_data() function returns (void *)-1. For min() it
1712     ** returns (void *)db, where db is the sqlite3* database pointer.
1713     ** Therefore the next statement sets variable 'max' to 1 for the max()
1714     ** aggregate, or 0 for min().
1715     */
1716     max = sqlite3_user_data(context)!=0;
1717     cmp = sqlite3MemCompare(pBest, pArg, pColl);
1718     if( (max && cmp<0) || (!max && cmp>0) ){
1719       sqlite3VdbeMemCopy(pBest, pArg);
1720     }else{
1721       sqlite3SkipAccumulatorLoad(context);
1722     }
1723   }else{
1724     pBest->db = sqlite3_context_db_handle(context);
1725     sqlite3VdbeMemCopy(pBest, pArg);
1726   }
1727 }
1728 static void minMaxValueFinalize(sqlite3_context *context, int bValue){
1729   sqlite3_value *pRes;
1730   pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1731   if( pRes ){
1732     if( pRes->flags ){
1733       sqlite3_result_value(context, pRes);
1734     }
1735     if( bValue==0 ) sqlite3VdbeMemRelease(pRes);
1736   }
1737 }
1738 #ifndef SQLITE_OMIT_WINDOWFUNC
1739 static void minMaxValue(sqlite3_context *context){
1740   minMaxValueFinalize(context, 1);
1741 }
1742 #else
1743 # define minMaxValue 0
1744 #endif /* SQLITE_OMIT_WINDOWFUNC */
1745 static void minMaxFinalize(sqlite3_context *context){
1746   minMaxValueFinalize(context, 0);
1747 }
1748
1749 /*
1750 ** group_concat(EXPR, ?SEPARATOR?)
1751 **
1752 ** The SEPARATOR goes before the EXPR string.  This is tragic.  The
1753 ** groupConcatInverse() implementation would have been easier if the
1754 ** SEPARATOR were appended after EXPR.  And the order is undocumented,
1755 ** so we could change it, in theory.  But the old behavior has been
1756 ** around for so long that we dare not, for fear of breaking something.
1757 */
1758 typedef struct {
1759   StrAccum str;          /* The accumulated concatenation */
1760 #ifndef SQLITE_OMIT_WINDOWFUNC
1761   int nAccum;            /* Number of strings presently concatenated */
1762   int nFirstSepLength;   /* Used to detect separator length change */
1763   /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
1764   ** stored as actually incorporated into presently accumulated result.
1765   ** (Hence, its slots in use number nAccum-1 between method calls.)
1766   ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
1767   */
1768   int *pnSepLengths;
1769 #endif
1770 } GroupConcatCtx;
1771
1772 static void groupConcatStep(
1773   sqlite3_context *context,
1774   int argc,
1775   sqlite3_value **argv
1776 ){
1777   const char *zVal;
1778   GroupConcatCtx *pGCC;
1779   const char *zSep;
1780   int nVal, nSep;
1781   assert( argc==1 || argc==2 );
1782   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1783   pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
1784   if( pGCC ){
1785     sqlite3 *db = sqlite3_context_db_handle(context);
1786     int firstTerm = pGCC->str.mxAlloc==0;
1787     pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
1788     if( argc==1 ){
1789       if( !firstTerm ){
1790         sqlite3_str_appendchar(&pGCC->str, 1, ',');
1791       }
1792 #ifndef SQLITE_OMIT_WINDOWFUNC
1793       else{
1794         pGCC->nFirstSepLength = 1;
1795       }
1796 #endif
1797     }else if( !firstTerm ){
1798       zSep = (char*)sqlite3_value_text(argv[1]);
1799       nSep = sqlite3_value_bytes(argv[1]);
1800       if( zSep ){
1801         sqlite3_str_append(&pGCC->str, zSep, nSep);
1802       }
1803 #ifndef SQLITE_OMIT_WINDOWFUNC
1804       else{
1805         nSep = 0;
1806       }
1807       if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){
1808         int *pnsl = pGCC->pnSepLengths;
1809         if( pnsl == 0 ){
1810           /* First separator length variation seen, start tracking them. */
1811           pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int));
1812           if( pnsl!=0 ){
1813             int i = 0, nA = pGCC->nAccum-1;
1814             while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
1815           }
1816         }else{
1817           pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int));
1818         }
1819         if( pnsl!=0 ){
1820           if( ALWAYS(pGCC->nAccum>0) ){
1821             pnsl[pGCC->nAccum-1] = nSep;
1822           }
1823           pGCC->pnSepLengths = pnsl;
1824         }else{
1825           sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM);
1826         }
1827       }
1828 #endif
1829     }
1830 #ifndef SQLITE_OMIT_WINDOWFUNC
1831     else{
1832       pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]);
1833     }
1834     pGCC->nAccum += 1;
1835 #endif
1836     zVal = (char*)sqlite3_value_text(argv[0]);
1837     nVal = sqlite3_value_bytes(argv[0]);
1838     if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal);
1839   }
1840 }
1841
1842 #ifndef SQLITE_OMIT_WINDOWFUNC
1843 static void groupConcatInverse(
1844   sqlite3_context *context,
1845   int argc,
1846   sqlite3_value **argv
1847 ){
1848   GroupConcatCtx *pGCC;
1849   assert( argc==1 || argc==2 );
1850   (void)argc;  /* Suppress unused parameter warning */
1851   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1852   pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
1853   /* pGCC is always non-NULL since groupConcatStep() will have always
1854   ** run frist to initialize it */
1855   if( ALWAYS(pGCC) ){
1856     int nVS;
1857     /* Must call sqlite3_value_text() to convert the argument into text prior
1858     ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
1859     (void)sqlite3_value_text(argv[0]);
1860     nVS = sqlite3_value_bytes(argv[0]);
1861     pGCC->nAccum -= 1;
1862     if( pGCC->pnSepLengths!=0 ){
1863       assert(pGCC->nAccum >= 0);
1864       if( pGCC->nAccum>0 ){
1865         nVS += *pGCC->pnSepLengths;
1866         memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
1867                (pGCC->nAccum-1)*sizeof(int));
1868       }
1869     }else{
1870       /* If removing single accumulated string, harmlessly over-do. */
1871       nVS += pGCC->nFirstSepLength;
1872     }
1873     if( nVS>=(int)pGCC->str.nChar ){
1874       pGCC->str.nChar = 0;
1875     }else{
1876       pGCC->str.nChar -= nVS;
1877       memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
1878     }
1879     if( pGCC->str.nChar==0 ){
1880       pGCC->str.mxAlloc = 0;
1881       sqlite3_free(pGCC->pnSepLengths);
1882       pGCC->pnSepLengths = 0;
1883     }
1884   }
1885 }
1886 #else
1887 # define groupConcatInverse 0
1888 #endif /* SQLITE_OMIT_WINDOWFUNC */
1889 static void groupConcatFinalize(sqlite3_context *context){
1890   GroupConcatCtx *pGCC
1891     = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
1892   if( pGCC ){
1893     sqlite3ResultStrAccum(context, &pGCC->str);
1894 #ifndef SQLITE_OMIT_WINDOWFUNC
1895     sqlite3_free(pGCC->pnSepLengths);
1896 #endif
1897   }
1898 }
1899 #ifndef SQLITE_OMIT_WINDOWFUNC
1900 static void groupConcatValue(sqlite3_context *context){
1901   GroupConcatCtx *pGCC
1902     = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
1903   if( pGCC ){
1904     StrAccum *pAccum = &pGCC->str;
1905     if( pAccum->accError==SQLITE_TOOBIG ){
1906       sqlite3_result_error_toobig(context);
1907     }else if( pAccum->accError==SQLITE_NOMEM ){
1908       sqlite3_result_error_nomem(context);
1909     }else{
1910       const char *zText = sqlite3_str_value(pAccum);
1911       sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
1912     }
1913   }
1914 }
1915 #else
1916 # define groupConcatValue 0
1917 #endif /* SQLITE_OMIT_WINDOWFUNC */
1918
1919 /*
1920 ** This routine does per-connection function registration.  Most
1921 ** of the built-in functions above are part of the global function set.
1922 ** This routine only deals with those that are not global.
1923 */
1924 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
1925   int rc = sqlite3_overload_function(db, "MATCH", 2);
1926   assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1927   if( rc==SQLITE_NOMEM ){
1928     sqlite3OomFault(db);
1929   }
1930 }
1931
1932 /*
1933 ** Re-register the built-in LIKE functions.  The caseSensitive
1934 ** parameter determines whether or not the LIKE operator is case
1935 ** sensitive.
1936 */
1937 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1938   struct compareInfo *pInfo;
1939   int flags;
1940   if( caseSensitive ){
1941     pInfo = (struct compareInfo*)&likeInfoAlt;
1942     flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
1943   }else{
1944     pInfo = (struct compareInfo*)&likeInfoNorm;
1945     flags = SQLITE_FUNC_LIKE;
1946   }
1947   sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
1948   sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
1949   sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags;
1950   sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags;
1951 }
1952
1953 /*
1954 ** pExpr points to an expression which implements a function.  If
1955 ** it is appropriate to apply the LIKE optimization to that function
1956 ** then set aWc[0] through aWc[2] to the wildcard characters and the
1957 ** escape character and then return TRUE.  If the function is not a
1958 ** LIKE-style function then return FALSE.
1959 **
1960 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
1961 ** operator if c is a string literal that is exactly one byte in length.
1962 ** That one byte is stored in aWc[3].  aWc[3] is set to zero if there is
1963 ** no ESCAPE clause.
1964 **
1965 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
1966 ** the function (default for LIKE).  If the function makes the distinction
1967 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
1968 ** false.
1969 */
1970 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1971   FuncDef *pDef;
1972   int nExpr;
1973   assert( pExpr!=0 );
1974   assert( pExpr->op==TK_FUNCTION );
1975   assert( ExprUseXList(pExpr) );
1976   if( !pExpr->x.pList ){
1977     return 0;
1978   }
1979   nExpr = pExpr->x.pList->nExpr;
1980   assert( !ExprHasProperty(pExpr, EP_IntValue) );
1981   pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
1982 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1983   if( pDef==0 ) return 0;
1984 #endif
1985   if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
1986     return 0;
1987   }
1988
1989   /* The memcpy() statement assumes that the wildcard characters are
1990   ** the first three statements in the compareInfo structure.  The
1991   ** asserts() that follow verify that assumption
1992   */
1993   memcpy(aWc, pDef->pUserData, 3);
1994   assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1995   assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1996   assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1997
1998   if( nExpr<3 ){
1999     aWc[3] = 0;
2000   }else{
2001     Expr *pEscape = pExpr->x.pList->a[2].pExpr;
2002     char *zEscape;
2003     if( pEscape->op!=TK_STRING ) return 0;
2004     assert( !ExprHasProperty(pEscape, EP_IntValue) );
2005     zEscape = pEscape->u.zToken;
2006     if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
2007     if( zEscape[0]==aWc[0] ) return 0;
2008     if( zEscape[0]==aWc[1] ) return 0;
2009     aWc[3] = zEscape[0];
2010   }
2011
2012   *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
2013   return 1;
2014 }
2015
2016 /* Mathematical Constants */
2017 #ifndef M_PI
2018 # define M_PI   3.141592653589793238462643383279502884
2019 #endif
2020 #ifndef M_LN10
2021 # define M_LN10 2.302585092994045684017991454684364208
2022 #endif
2023 #ifndef M_LN2
2024 # define M_LN2  0.693147180559945309417232121458176568
2025 #endif
2026
2027
2028 /* Extra math functions that require linking with -lm
2029 */
2030 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2031 /*
2032 ** Implementation SQL functions:
2033 **
2034 **   ceil(X)
2035 **   ceiling(X)
2036 **   floor(X)
2037 **
2038 ** The sqlite3_user_data() pointer is a pointer to the libm implementation
2039 ** of the underlying C function.
2040 */
2041 static void ceilingFunc(
2042   sqlite3_context *context,
2043   int argc,
2044   sqlite3_value **argv
2045 ){
2046   assert( argc==1 );
2047   switch( sqlite3_value_numeric_type(argv[0]) ){
2048     case SQLITE_INTEGER: {
2049        sqlite3_result_int64(context, sqlite3_value_int64(argv[0]));
2050        break;
2051     }
2052     case SQLITE_FLOAT: {
2053        double (*x)(double) = (double(*)(double))sqlite3_user_data(context);
2054        sqlite3_result_double(context, x(sqlite3_value_double(argv[0])));
2055        break;
2056     }
2057     default: {
2058        break;
2059     }
2060   }
2061 }
2062
2063 /*
2064 ** On some systems, ceil() and floor() are intrinsic function.  You are
2065 ** unable to take a pointer to these functions.  Hence, we here wrap them
2066 ** in our own actual functions.
2067 */
2068 static double xCeil(double x){ return ceil(x); }
2069 static double xFloor(double x){ return floor(x); }
2070
2071 /*
2072 ** Implementation of SQL functions:
2073 **
2074 **   ln(X)       - natural logarithm
2075 **   log(X)      - log X base 10
2076 **   log10(X)    - log X base 10
2077 **   log(B,X)    - log X base B
2078 */
2079 static void logFunc(
2080   sqlite3_context *context,
2081   int argc,
2082   sqlite3_value **argv
2083 ){
2084   double x, b, ans;
2085   assert( argc==1 || argc==2 );
2086   switch( sqlite3_value_numeric_type(argv[0]) ){
2087     case SQLITE_INTEGER:
2088     case SQLITE_FLOAT:
2089       x = sqlite3_value_double(argv[0]);
2090       if( x<=0.0 ) return;
2091       break;
2092     default:
2093       return;
2094   }
2095   if( argc==2 ){
2096     switch( sqlite3_value_numeric_type(argv[0]) ){
2097       case SQLITE_INTEGER:
2098       case SQLITE_FLOAT:
2099         b = log(x);
2100         if( b<=0.0 ) return;
2101         x = sqlite3_value_double(argv[1]);
2102         if( x<=0.0 ) return;
2103         break;
2104      default:
2105         return;
2106     }
2107     ans = log(x)/b;
2108   }else{
2109     ans = log(x);
2110     switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){
2111       case 1:
2112         /* Convert from natural logarithm to log base 10 */
2113         ans /= M_LN10;
2114         break;
2115       case 2:
2116         /* Convert from natural logarithm to log base 2 */
2117         ans /= M_LN2;
2118         break;
2119       default:
2120         break;
2121     }
2122   }
2123   sqlite3_result_double(context, ans);
2124 }
2125
2126 /*
2127 ** Functions to converts degrees to radians and radians to degrees.
2128 */
2129 static double degToRad(double x){ return x*(M_PI/180.0); }
2130 static double radToDeg(double x){ return x*(180.0/M_PI); }
2131
2132 /*
2133 ** Implementation of 1-argument SQL math functions:
2134 **
2135 **   exp(X)  - Compute e to the X-th power
2136 */
2137 static void math1Func(
2138   sqlite3_context *context,
2139   int argc,
2140   sqlite3_value **argv
2141 ){
2142   int type0;
2143   double v0, ans;
2144   double (*x)(double);
2145   assert( argc==1 );
2146   type0 = sqlite3_value_numeric_type(argv[0]);
2147   if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2148   v0 = sqlite3_value_double(argv[0]);
2149   x = (double(*)(double))sqlite3_user_data(context);
2150   ans = x(v0);
2151   sqlite3_result_double(context, ans);
2152 }
2153
2154 /*
2155 ** Implementation of 2-argument SQL math functions:
2156 **
2157 **   power(X,Y)  - Compute X to the Y-th power
2158 */
2159 static void math2Func(
2160   sqlite3_context *context,
2161   int argc,
2162   sqlite3_value **argv
2163 ){
2164   int type0, type1;
2165   double v0, v1, ans;
2166   double (*x)(double,double);
2167   assert( argc==2 );
2168   type0 = sqlite3_value_numeric_type(argv[0]);
2169   if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2170   type1 = sqlite3_value_numeric_type(argv[1]);
2171   if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return;
2172   v0 = sqlite3_value_double(argv[0]);
2173   v1 = sqlite3_value_double(argv[1]);
2174   x = (double(*)(double,double))sqlite3_user_data(context);
2175   ans = x(v0, v1);
2176   sqlite3_result_double(context, ans);
2177 }
2178
2179 /*
2180 ** Implementation of 0-argument pi() function.
2181 */
2182 static void piFunc(
2183   sqlite3_context *context,
2184   int argc,
2185   sqlite3_value **argv
2186 ){
2187   assert( argc==0 );
2188   sqlite3_result_double(context, M_PI);
2189 }
2190
2191 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2192
2193 /*
2194 ** Implementation of sign(X) function.
2195 */
2196 static void signFunc(
2197   sqlite3_context *context,
2198   int argc,
2199   sqlite3_value **argv
2200 ){
2201   int type0;
2202   double x;
2203   UNUSED_PARAMETER(argc);
2204   assert( argc==1 );
2205   type0 = sqlite3_value_numeric_type(argv[0]);
2206   if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2207   x = sqlite3_value_double(argv[0]);
2208   sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
2209 }
2210
2211 /*
2212 ** All of the FuncDef structures in the aBuiltinFunc[] array above
2213 ** to the global function hash table.  This occurs at start-time (as
2214 ** a consequence of calling sqlite3_initialize()).
2215 **
2216 ** After this routine runs
2217 */
2218 void sqlite3RegisterBuiltinFunctions(void){
2219   /*
2220   ** The following array holds FuncDef structures for all of the functions
2221   ** defined in this file.
2222   **
2223   ** The array cannot be constant since changes are made to the
2224   ** FuncDef.pHash elements at start-time.  The elements of this array
2225   ** are read-only after initialization is complete.
2226   **
2227   ** For peak efficiency, put the most frequently used function last.
2228   */
2229   static FuncDef aBuiltinFunc[] = {
2230 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
2231 #if !defined(SQLITE_UNTESTABLE)
2232     TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0),
2233     TEST_FUNC(expr_compare,        2, INLINEFUNC_expr_compare,        0),
2234     TEST_FUNC(expr_implies_expr,   2, INLINEFUNC_expr_implies_expr,   0),
2235     TEST_FUNC(affinity,            1, INLINEFUNC_affinity,            0),
2236 #endif /* !defined(SQLITE_UNTESTABLE) */
2237 /***** Regular functions *****/
2238 #ifdef SQLITE_SOUNDEX
2239     FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
2240 #endif
2241 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2242     SFUNCTION(load_extension,    1, 0, 0, loadExt          ),
2243     SFUNCTION(load_extension,    2, 0, 0, loadExt          ),
2244 #endif
2245 #if SQLITE_USER_AUTHENTICATION
2246     FUNCTION(sqlite_crypt,       2, 0, 0, sqlite3CryptFunc ),
2247 #endif
2248 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
2249     DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
2250     DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
2251 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
2252     INLINE_FUNC(unlikely,        1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2253     INLINE_FUNC(likelihood,      2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2254     INLINE_FUNC(likely,          1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2255 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
2256     INLINE_FUNC(sqlite_offset,   1, INLINEFUNC_sqlite_offset, 0 ),
2257 #endif
2258     FUNCTION(ltrim,              1, 1, 0, trimFunc         ),
2259     FUNCTION(ltrim,              2, 1, 0, trimFunc         ),
2260     FUNCTION(rtrim,              1, 2, 0, trimFunc         ),
2261     FUNCTION(rtrim,              2, 2, 0, trimFunc         ),
2262     FUNCTION(trim,               1, 3, 0, trimFunc         ),
2263     FUNCTION(trim,               2, 3, 0, trimFunc         ),
2264     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
2265     FUNCTION(min,                0, 0, 1, 0                ),
2266     WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
2267                                  SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
2268     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
2269     FUNCTION(max,                0, 1, 1, 0                ),
2270     WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
2271                                  SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
2272     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
2273     FUNCTION2(subtype,           1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
2274     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
2275     FUNCTION(instr,              2, 0, 0, instrFunc        ),
2276     FUNCTION(printf,            -1, 0, 0, printfFunc       ),
2277     FUNCTION(format,            -1, 0, 0, printfFunc       ),
2278     FUNCTION(unicode,            1, 0, 0, unicodeFunc      ),
2279     FUNCTION(char,              -1, 0, 0, charFunc         ),
2280     FUNCTION(abs,                1, 0, 0, absFunc          ),
2281 #ifndef SQLITE_OMIT_FLOATING_POINT
2282     FUNCTION(round,              1, 0, 0, roundFunc        ),
2283     FUNCTION(round,              2, 0, 0, roundFunc        ),
2284 #endif
2285     FUNCTION(upper,              1, 0, 0, upperFunc        ),
2286     FUNCTION(lower,              1, 0, 0, lowerFunc        ),
2287     FUNCTION(hex,                1, 0, 0, hexFunc          ),
2288     INLINE_FUNC(ifnull,          2, INLINEFUNC_coalesce, 0 ),
2289     VFUNCTION(random,            0, 0, 0, randomFunc       ),
2290     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
2291     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
2292     DFUNCTION(sqlite_version,    0, 0, 0, versionFunc      ),
2293     DFUNCTION(sqlite_source_id,  0, 0, 0, sourceidFunc     ),
2294     FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
2295     FUNCTION(quote,              1, 0, 0, quoteFunc        ),
2296     VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
2297     VFUNCTION(changes,           0, 0, 0, changes          ),
2298     VFUNCTION(total_changes,     0, 0, 0, total_changes    ),
2299     FUNCTION(replace,            3, 0, 0, replaceFunc      ),
2300     FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
2301     FUNCTION(substr,             2, 0, 0, substrFunc       ),
2302     FUNCTION(substr,             3, 0, 0, substrFunc       ),
2303     FUNCTION(substring,          2, 0, 0, substrFunc       ),
2304     FUNCTION(substring,          3, 0, 0, substrFunc       ),
2305     WAGGREGATE(sum,   1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0),
2306     WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
2307     WAGGREGATE(avg,   1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
2308     WAGGREGATE(count, 0,0,0, countStep,
2309         countFinalize, countFinalize, countInverse,
2310         SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER  ),
2311     WAGGREGATE(count, 1,0,0, countStep,
2312         countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ),
2313     WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
2314         groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
2315     WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
2316         groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
2317
2318     LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2319 #ifdef SQLITE_CASE_SENSITIVE_LIKE
2320     LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2321     LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2322 #else
2323     LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
2324     LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
2325 #endif
2326 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
2327     FUNCTION(unknown,           -1, 0, 0, unknownFunc      ),
2328 #endif
2329     FUNCTION(coalesce,           1, 0, 0, 0                ),
2330     FUNCTION(coalesce,           0, 0, 0, 0                ),
2331 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2332     MFUNCTION(ceil,              1, xCeil,     ceilingFunc ),
2333     MFUNCTION(ceiling,           1, xCeil,     ceilingFunc ),
2334     MFUNCTION(floor,             1, xFloor,    ceilingFunc ),
2335 #if SQLITE_HAVE_C99_MATH_FUNCS
2336     MFUNCTION(trunc,             1, trunc,     ceilingFunc ),
2337 #endif
2338     FUNCTION(ln,                 1, 0, 0,      logFunc     ),
2339     FUNCTION(log,                1, 1, 0,      logFunc     ),
2340     FUNCTION(log10,              1, 1, 0,      logFunc     ),
2341     FUNCTION(log2,               1, 2, 0,      logFunc     ),
2342     FUNCTION(log,                2, 0, 0,      logFunc     ),
2343     MFUNCTION(exp,               1, exp,       math1Func   ),
2344     MFUNCTION(pow,               2, pow,       math2Func   ),
2345     MFUNCTION(power,             2, pow,       math2Func   ),
2346     MFUNCTION(mod,               2, fmod,      math2Func   ),
2347     MFUNCTION(acos,              1, acos,      math1Func   ),
2348     MFUNCTION(asin,              1, asin,      math1Func   ),
2349     MFUNCTION(atan,              1, atan,      math1Func   ),
2350     MFUNCTION(atan2,             2, atan2,     math2Func   ),
2351     MFUNCTION(cos,               1, cos,       math1Func   ),
2352     MFUNCTION(sin,               1, sin,       math1Func   ),
2353     MFUNCTION(tan,               1, tan,       math1Func   ),
2354     MFUNCTION(cosh,              1, cosh,      math1Func   ),
2355     MFUNCTION(sinh,              1, sinh,      math1Func   ),
2356     MFUNCTION(tanh,              1, tanh,      math1Func   ),
2357 #if SQLITE_HAVE_C99_MATH_FUNCS
2358     MFUNCTION(acosh,             1, acosh,     math1Func   ),
2359     MFUNCTION(asinh,             1, asinh,     math1Func   ),
2360     MFUNCTION(atanh,             1, atanh,     math1Func   ),
2361 #endif
2362     MFUNCTION(sqrt,              1, sqrt,      math1Func   ),
2363     MFUNCTION(radians,           1, degToRad,  math1Func   ),
2364     MFUNCTION(degrees,           1, radToDeg,  math1Func   ),
2365     FUNCTION(pi,                 0, 0, 0,      piFunc      ),
2366 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2367     FUNCTION(sign,               1, 0, 0,      signFunc    ),
2368     INLINE_FUNC(coalesce,       -1, INLINEFUNC_coalesce, 0 ),
2369     INLINE_FUNC(iif,             3, INLINEFUNC_iif,      0 ),
2370   };
2371 #ifndef SQLITE_OMIT_ALTERTABLE
2372   sqlite3AlterFunctions();
2373 #endif
2374   sqlite3WindowFunctions();
2375   sqlite3RegisterDateTimeFunctions();
2376   sqlite3RegisterJsonFunctions();
2377   sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
2378
2379 #if 0  /* Enable to print out how the built-in functions are hashed */
2380   {
2381     int i;
2382     FuncDef *p;
2383     for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
2384       printf("FUNC-HASH %02d:", i);
2385       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
2386         int n = sqlite3Strlen30(p->zName);
2387         int h = p->zName[0] + n;
2388         assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
2389         printf(" %s(%d)", p->zName, h);
2390       }
2391       printf("\n");
2392     }
2393   }
2394 #endif
2395 }