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