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 236 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 237 x.nArg = argc-1; 238 x.nUsed = 0; 239 x.apArg = argv+1; 240 sqlite3StrAccumInit(&str, 0, 0, SQLITE_MAX_LENGTH); 241 str.db = sqlite3_context_db_handle(context); 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 sqlite3_malloc(). 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, all characters are 579 ** able to participate in upper-case-to-lower-case mappings in EBCDIC 580 ** whereas only characters less than 0x80 do in ASCII. 581 */ 582 #if defined(SQLITE_EBCDIC) 583 # define sqlite3Utf8Read(A) (*((*A)++)) 584 # define GlobUpperToLower(A) A = sqlite3UpperToLower[A] 585 # define GlobUpperToLowerAscii(A) A = sqlite3UpperToLower[A] 586 #else 587 # define GlobUpperToLower(A) if( A<=0x7f ){ A = sqlite3UpperToLower[A]; } 588 # define GlobUpperToLowerAscii(A) A = sqlite3UpperToLower[A] 589 #endif 590 591 static const struct compareInfo globInfo = { '*', '?', '[', 0 }; 592 /* The correct SQL-92 behavior is for the LIKE operator to ignore 593 ** case. Thus 'a' LIKE 'A' would be true. */ 594 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }; 595 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator 596 ** is case sensitive causing 'a' LIKE 'A' to be false */ 597 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }; 598 599 /* 600 ** Compare two UTF-8 strings for equality where the first string can 601 ** potentially be a "glob" or "like" expression. Return true (1) if they 602 ** are the same and false (0) if they are different. 603 ** 604 ** Globbing rules: 605 ** 606 ** '*' Matches any sequence of zero or more characters. 607 ** 608 ** '?' Matches exactly one character. 609 ** 610 ** [...] Matches one character from the enclosed list of 611 ** characters. 612 ** 613 ** [^...] Matches one character not in the enclosed list. 614 ** 615 ** With the [...] and [^...] matching, a ']' character can be included 616 ** in the list by making it the first character after '[' or '^'. A 617 ** range of characters can be specified using '-'. Example: 618 ** "[a-z]" matches any single lower-case letter. To match a '-', make 619 ** it the last character in the list. 620 ** 621 ** Like matching rules: 622 ** 623 ** '%' Matches any sequence of zero or more characters 624 ** 625 *** '_' Matches any one character 626 ** 627 ** Ec Where E is the "esc" character and c is any other 628 ** character, including '%', '_', and esc, match exactly c. 629 ** 630 ** The comments through this routine usually assume glob matching. 631 ** 632 ** This routine is usually quick, but can be N**2 in the worst case. 633 */ 634 static int patternCompare( 635 const u8 *zPattern, /* The glob pattern */ 636 const u8 *zString, /* The string to compare against the glob */ 637 const struct compareInfo *pInfo, /* Information about how to do the compare */ 638 u32 esc /* The escape character */ 639 ){ 640 u32 c, c2; /* Next pattern and input string chars */ 641 u32 matchOne = pInfo->matchOne; /* "?" or "_" */ 642 u32 matchAll = pInfo->matchAll; /* "*" or "%" */ 643 u32 matchOther; /* "[" or the escape character */ 644 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ 645 const u8 *zEscaped = 0; /* One past the last escaped input char */ 646 647 /* The GLOB operator does not have an ESCAPE clause. And LIKE does not 648 ** have the matchSet operator. So we either have to look for one or 649 ** the other, never both. Hence the single variable matchOther is used 650 ** to store the one we have to look for. 651 */ 652 matchOther = esc ? esc : pInfo->matchSet; 653 654 while( (c = sqlite3Utf8Read(&zPattern))!=0 ){ 655 if( c==matchAll ){ /* Match "*" */ 656 /* Skip over multiple "*" characters in the pattern. If there 657 ** are also "?" characters, skip those as well, but consume a 658 ** single character of the input string for each "?" skipped */ 659 while( (c=sqlite3Utf8Read(&zPattern)) == matchAll 660 || c == matchOne ){ 661 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ 662 return 0; 663 } 664 } 665 if( c==0 ){ 666 return 1; /* "*" at the end of the pattern matches */ 667 }else if( c==matchOther ){ 668 if( esc ){ 669 c = sqlite3Utf8Read(&zPattern); 670 if( c==0 ) return 0; 671 }else{ 672 /* "[...]" immediately follows the "*". We have to do a slow 673 ** recursive search in this case, but it is an unusual case. */ 674 assert( matchOther<0x80 ); /* '[' is a single-byte character */ 675 while( *zString 676 && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){ 677 SQLITE_SKIP_UTF8(zString); 678 } 679 return *zString!=0; 680 } 681 } 682 683 /* At this point variable c contains the first character of the 684 ** pattern string past the "*". Search in the input string for the 685 ** first matching character and recursively contine the match from 686 ** that point. 687 ** 688 ** For a case-insensitive search, set variable cx to be the same as 689 ** c but in the other case and search the input string for either 690 ** c or cx. 691 */ 692 if( c<=0x80 ){ 693 u32 cx; 694 if( noCase ){ 695 cx = sqlite3Toupper(c); 696 c = sqlite3Tolower(c); 697 }else{ 698 cx = c; 699 } 700 while( (c2 = *(zString++))!=0 ){ 701 if( c2!=c && c2!=cx ) continue; 702 if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; 703 } 704 }else{ 705 while( (c2 = sqlite3Utf8Read(&zString))!=0 ){ 706 if( c2!=c ) continue; 707 if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; 708 } 709 } 710 return 0; 711 } 712 if( c==matchOther ){ 713 if( esc ){ 714 c = sqlite3Utf8Read(&zPattern); 715 if( c==0 ) return 0; 716 zEscaped = zPattern; 717 }else{ 718 u32 prior_c = 0; 719 int seen = 0; 720 int invert = 0; 721 c = sqlite3Utf8Read(&zString); 722 if( c==0 ) return 0; 723 c2 = sqlite3Utf8Read(&zPattern); 724 if( c2=='^' ){ 725 invert = 1; 726 c2 = sqlite3Utf8Read(&zPattern); 727 } 728 if( c2==']' ){ 729 if( c==']' ) seen = 1; 730 c2 = sqlite3Utf8Read(&zPattern); 731 } 732 while( c2 && c2!=']' ){ 733 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 734 c2 = sqlite3Utf8Read(&zPattern); 735 if( c>=prior_c && c<=c2 ) seen = 1; 736 prior_c = 0; 737 }else{ 738 if( c==c2 ){ 739 seen = 1; 740 } 741 prior_c = c2; 742 } 743 c2 = sqlite3Utf8Read(&zPattern); 744 } 745 if( c2==0 || (seen ^ invert)==0 ){ 746 return 0; 747 } 748 continue; 749 } 750 } 751 c2 = sqlite3Utf8Read(&zString); 752 if( c==c2 ) continue; 753 if( noCase && c<0x80 && c2<0x80 && sqlite3Tolower(c)==sqlite3Tolower(c2) ){ 754 continue; 755 } 756 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; 757 return 0; 758 } 759 return *zString==0; 760 } 761 762 /* 763 ** The sqlite3_strglob() interface. 764 */ 765 int sqlite3_strglob(const char *zGlobPattern, const char *zString){ 766 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0; 767 } 768 769 /* 770 ** Count the number of times that the LIKE operator (or GLOB which is 771 ** just a variation of LIKE) gets called. This is used for testing 772 ** only. 773 */ 774 #ifdef SQLITE_TEST 775 int sqlite3_like_count = 0; 776 #endif 777 778 779 /* 780 ** Implementation of the like() SQL function. This function implements 781 ** the build-in LIKE operator. The first argument to the function is the 782 ** pattern and the second argument is the string. So, the SQL statements: 783 ** 784 ** A LIKE B 785 ** 786 ** is implemented as like(B,A). 787 ** 788 ** This same function (with a different compareInfo structure) computes 789 ** the GLOB operator. 790 */ 791 static void likeFunc( 792 sqlite3_context *context, 793 int argc, 794 sqlite3_value **argv 795 ){ 796 const unsigned char *zA, *zB; 797 u32 escape = 0; 798 int nPat; 799 sqlite3 *db = sqlite3_context_db_handle(context); 800 801 zB = sqlite3_value_text(argv[0]); 802 zA = sqlite3_value_text(argv[1]); 803 804 /* Limit the length of the LIKE or GLOB pattern to avoid problems 805 ** of deep recursion and N*N behavior in patternCompare(). 806 */ 807 nPat = sqlite3_value_bytes(argv[0]); 808 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); 809 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); 810 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ 811 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 812 return; 813 } 814 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ 815 816 if( argc==3 ){ 817 /* The escape character string must consist of a single UTF-8 character. 818 ** Otherwise, return an error. 819 */ 820 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 821 if( zEsc==0 ) return; 822 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 823 sqlite3_result_error(context, 824 "ESCAPE expression must be a single character", -1); 825 return; 826 } 827 escape = sqlite3Utf8Read(&zEsc); 828 } 829 if( zA && zB ){ 830 struct compareInfo *pInfo = sqlite3_user_data(context); 831 #ifdef SQLITE_TEST 832 sqlite3_like_count++; 833 #endif 834 835 sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)); 836 } 837 } 838 839 /* 840 ** Implementation of the NULLIF(x,y) function. The result is the first 841 ** argument if the arguments are different. The result is NULL if the 842 ** arguments are equal to each other. 843 */ 844 static void nullifFunc( 845 sqlite3_context *context, 846 int NotUsed, 847 sqlite3_value **argv 848 ){ 849 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 850 UNUSED_PARAMETER(NotUsed); 851 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 852 sqlite3_result_value(context, argv[0]); 853 } 854 } 855 856 /* 857 ** Implementation of the sqlite_version() function. The result is the version 858 ** of the SQLite library that is running. 859 */ 860 static void versionFunc( 861 sqlite3_context *context, 862 int NotUsed, 863 sqlite3_value **NotUsed2 864 ){ 865 UNUSED_PARAMETER2(NotUsed, NotUsed2); 866 /* IMP: R-48699-48617 This function is an SQL wrapper around the 867 ** sqlite3_libversion() C-interface. */ 868 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); 869 } 870 871 /* 872 ** Implementation of the sqlite_source_id() function. The result is a string 873 ** that identifies the particular version of the source code used to build 874 ** SQLite. 875 */ 876 static void sourceidFunc( 877 sqlite3_context *context, 878 int NotUsed, 879 sqlite3_value **NotUsed2 880 ){ 881 UNUSED_PARAMETER2(NotUsed, NotUsed2); 882 /* IMP: R-24470-31136 This function is an SQL wrapper around the 883 ** sqlite3_sourceid() C interface. */ 884 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); 885 } 886 887 /* 888 ** Implementation of the sqlite_log() function. This is a wrapper around 889 ** sqlite3_log(). The return value is NULL. The function exists purely for 890 ** its side-effects. 891 */ 892 static void errlogFunc( 893 sqlite3_context *context, 894 int argc, 895 sqlite3_value **argv 896 ){ 897 UNUSED_PARAMETER(argc); 898 UNUSED_PARAMETER(context); 899 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); 900 } 901 902 /* 903 ** Implementation of the sqlite_compileoption_used() function. 904 ** The result is an integer that identifies if the compiler option 905 ** was used to build SQLite. 906 */ 907 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 908 static void compileoptionusedFunc( 909 sqlite3_context *context, 910 int argc, 911 sqlite3_value **argv 912 ){ 913 const char *zOptName; 914 assert( argc==1 ); 915 UNUSED_PARAMETER(argc); 916 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL 917 ** function is a wrapper around the sqlite3_compileoption_used() C/C++ 918 ** function. 919 */ 920 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 921 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); 922 } 923 } 924 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 925 926 /* 927 ** Implementation of the sqlite_compileoption_get() function. 928 ** The result is a string that identifies the compiler options 929 ** used to build SQLite. 930 */ 931 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 932 static void compileoptiongetFunc( 933 sqlite3_context *context, 934 int argc, 935 sqlite3_value **argv 936 ){ 937 int n; 938 assert( argc==1 ); 939 UNUSED_PARAMETER(argc); 940 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function 941 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. 942 */ 943 n = sqlite3_value_int(argv[0]); 944 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); 945 } 946 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 947 948 /* Array for converting from half-bytes (nybbles) into ASCII hex 949 ** digits. */ 950 static const char hexdigits[] = { 951 '0', '1', '2', '3', '4', '5', '6', '7', 952 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 953 }; 954 955 /* 956 ** Implementation of the QUOTE() function. This function takes a single 957 ** argument. If the argument is numeric, the return value is the same as 958 ** the argument. If the argument is NULL, the return value is the string 959 ** "NULL". Otherwise, the argument is enclosed in single quotes with 960 ** single-quote escapes. 961 */ 962 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 963 assert( argc==1 ); 964 UNUSED_PARAMETER(argc); 965 switch( sqlite3_value_type(argv[0]) ){ 966 case SQLITE_FLOAT: { 967 double r1, r2; 968 char zBuf[50]; 969 r1 = sqlite3_value_double(argv[0]); 970 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); 971 sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); 972 if( r1!=r2 ){ 973 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); 974 } 975 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); 976 break; 977 } 978 case SQLITE_INTEGER: { 979 sqlite3_result_value(context, argv[0]); 980 break; 981 } 982 case SQLITE_BLOB: { 983 char *zText = 0; 984 char const *zBlob = sqlite3_value_blob(argv[0]); 985 int nBlob = sqlite3_value_bytes(argv[0]); 986 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 987 zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); 988 if( zText ){ 989 int i; 990 for(i=0; i<nBlob; i++){ 991 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 992 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 993 } 994 zText[(nBlob*2)+2] = '\''; 995 zText[(nBlob*2)+3] = '\0'; 996 zText[0] = 'X'; 997 zText[1] = '\''; 998 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 999 sqlite3_free(zText); 1000 } 1001 break; 1002 } 1003 case SQLITE_TEXT: { 1004 int i,j; 1005 u64 n; 1006 const unsigned char *zArg = sqlite3_value_text(argv[0]); 1007 char *z; 1008 1009 if( zArg==0 ) return; 1010 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } 1011 z = contextMalloc(context, ((i64)i)+((i64)n)+3); 1012 if( z ){ 1013 z[0] = '\''; 1014 for(i=0, j=1; zArg[i]; i++){ 1015 z[j++] = zArg[i]; 1016 if( zArg[i]=='\'' ){ 1017 z[j++] = '\''; 1018 } 1019 } 1020 z[j++] = '\''; 1021 z[j] = 0; 1022 sqlite3_result_text(context, z, j, sqlite3_free); 1023 } 1024 break; 1025 } 1026 default: { 1027 assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); 1028 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); 1029 break; 1030 } 1031 } 1032 } 1033 1034 /* 1035 ** The unicode() function. Return the integer unicode code-point value 1036 ** for the first character of the input string. 1037 */ 1038 static void unicodeFunc( 1039 sqlite3_context *context, 1040 int argc, 1041 sqlite3_value **argv 1042 ){ 1043 const unsigned char *z = sqlite3_value_text(argv[0]); 1044 (void)argc; 1045 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); 1046 } 1047 1048 /* 1049 ** The char() function takes zero or more arguments, each of which is 1050 ** an integer. It constructs a string where each character of the string 1051 ** is the unicode character for the corresponding integer argument. 1052 */ 1053 static void charFunc( 1054 sqlite3_context *context, 1055 int argc, 1056 sqlite3_value **argv 1057 ){ 1058 unsigned char *z, *zOut; 1059 int i; 1060 zOut = z = sqlite3_malloc( argc*4+1 ); 1061 if( z==0 ){ 1062 sqlite3_result_error_nomem(context); 1063 return; 1064 } 1065 for(i=0; i<argc; i++){ 1066 sqlite3_int64 x; 1067 unsigned c; 1068 x = sqlite3_value_int64(argv[i]); 1069 if( x<0 || x>0x10ffff ) x = 0xfffd; 1070 c = (unsigned)(x & 0x1fffff); 1071 if( c<0x00080 ){ 1072 *zOut++ = (u8)(c&0xFF); 1073 }else if( c<0x00800 ){ 1074 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); 1075 *zOut++ = 0x80 + (u8)(c & 0x3F); 1076 }else if( c<0x10000 ){ 1077 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); 1078 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1079 *zOut++ = 0x80 + (u8)(c & 0x3F); 1080 }else{ 1081 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); 1082 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); 1083 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1084 *zOut++ = 0x80 + (u8)(c & 0x3F); 1085 } \ 1086 } 1087 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); 1088 } 1089 1090 /* 1091 ** The hex() function. Interpret the argument as a blob. Return 1092 ** a hexadecimal rendering as text. 1093 */ 1094 static void hexFunc( 1095 sqlite3_context *context, 1096 int argc, 1097 sqlite3_value **argv 1098 ){ 1099 int i, n; 1100 const unsigned char *pBlob; 1101 char *zHex, *z; 1102 assert( argc==1 ); 1103 UNUSED_PARAMETER(argc); 1104 pBlob = sqlite3_value_blob(argv[0]); 1105 n = sqlite3_value_bytes(argv[0]); 1106 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1107 z = zHex = contextMalloc(context, ((i64)n)*2 + 1); 1108 if( zHex ){ 1109 for(i=0; i<n; i++, pBlob++){ 1110 unsigned char c = *pBlob; 1111 *(z++) = hexdigits[(c>>4)&0xf]; 1112 *(z++) = hexdigits[c&0xf]; 1113 } 1114 *z = 0; 1115 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 1116 } 1117 } 1118 1119 /* 1120 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 1121 */ 1122 static void zeroblobFunc( 1123 sqlite3_context *context, 1124 int argc, 1125 sqlite3_value **argv 1126 ){ 1127 i64 n; 1128 sqlite3 *db = sqlite3_context_db_handle(context); 1129 assert( argc==1 ); 1130 UNUSED_PARAMETER(argc); 1131 n = sqlite3_value_int64(argv[0]); 1132 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1133 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); 1134 if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1135 sqlite3_result_error_toobig(context); 1136 }else{ 1137 sqlite3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */ 1138 } 1139 } 1140 1141 /* 1142 ** The replace() function. Three arguments are all strings: call 1143 ** them A, B, and C. The result is also a string which is derived 1144 ** from A by replacing every occurrence of B with C. The match 1145 ** must be exact. Collating sequences are not used. 1146 */ 1147 static void replaceFunc( 1148 sqlite3_context *context, 1149 int argc, 1150 sqlite3_value **argv 1151 ){ 1152 const unsigned char *zStr; /* The input string A */ 1153 const unsigned char *zPattern; /* The pattern string B */ 1154 const unsigned char *zRep; /* The replacement string C */ 1155 unsigned char *zOut; /* The output */ 1156 int nStr; /* Size of zStr */ 1157 int nPattern; /* Size of zPattern */ 1158 int nRep; /* Size of zRep */ 1159 i64 nOut; /* Maximum size of zOut */ 1160 int loopLimit; /* Last zStr[] that might match zPattern[] */ 1161 int i, j; /* Loop counters */ 1162 1163 assert( argc==3 ); 1164 UNUSED_PARAMETER(argc); 1165 zStr = sqlite3_value_text(argv[0]); 1166 if( zStr==0 ) return; 1167 nStr = sqlite3_value_bytes(argv[0]); 1168 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 1169 zPattern = sqlite3_value_text(argv[1]); 1170 if( zPattern==0 ){ 1171 assert( sqlite3_value_type(argv[1])==SQLITE_NULL 1172 || sqlite3_context_db_handle(context)->mallocFailed ); 1173 return; 1174 } 1175 if( zPattern[0]==0 ){ 1176 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); 1177 sqlite3_result_value(context, argv[0]); 1178 return; 1179 } 1180 nPattern = sqlite3_value_bytes(argv[1]); 1181 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 1182 zRep = sqlite3_value_text(argv[2]); 1183 if( zRep==0 ) return; 1184 nRep = sqlite3_value_bytes(argv[2]); 1185 assert( zRep==sqlite3_value_text(argv[2]) ); 1186 nOut = nStr + 1; 1187 assert( nOut<SQLITE_MAX_LENGTH ); 1188 zOut = contextMalloc(context, (i64)nOut); 1189 if( zOut==0 ){ 1190 return; 1191 } 1192 loopLimit = nStr - nPattern; 1193 for(i=j=0; i<=loopLimit; i++){ 1194 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 1195 zOut[j++] = zStr[i]; 1196 }else{ 1197 u8 *zOld; 1198 sqlite3 *db = sqlite3_context_db_handle(context); 1199 nOut += nRep - nPattern; 1200 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1201 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1202 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1203 sqlite3_result_error_toobig(context); 1204 sqlite3_free(zOut); 1205 return; 1206 } 1207 zOld = zOut; 1208 zOut = sqlite3_realloc(zOut, (int)nOut); 1209 if( zOut==0 ){ 1210 sqlite3_result_error_nomem(context); 1211 sqlite3_free(zOld); 1212 return; 1213 } 1214 memcpy(&zOut[j], zRep, nRep); 1215 j += nRep; 1216 i += nPattern-1; 1217 } 1218 } 1219 assert( j+nStr-i+1==nOut ); 1220 memcpy(&zOut[j], &zStr[i], nStr-i); 1221 j += nStr - i; 1222 assert( j<=nOut ); 1223 zOut[j] = 0; 1224 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 1225 } 1226 1227 /* 1228 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 1229 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 1230 */ 1231 static void trimFunc( 1232 sqlite3_context *context, 1233 int argc, 1234 sqlite3_value **argv 1235 ){ 1236 const unsigned char *zIn; /* Input string */ 1237 const unsigned char *zCharSet; /* Set of characters to trim */ 1238 int nIn; /* Number of bytes in input */ 1239 int flags; /* 1: trimleft 2: trimright 3: trim */ 1240 int i; /* Loop counter */ 1241 unsigned char *aLen = 0; /* Length of each character in zCharSet */ 1242 unsigned char **azChar = 0; /* Individual characters in zCharSet */ 1243 int nChar; /* Number of characters in zCharSet */ 1244 1245 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1246 return; 1247 } 1248 zIn = sqlite3_value_text(argv[0]); 1249 if( zIn==0 ) return; 1250 nIn = sqlite3_value_bytes(argv[0]); 1251 assert( zIn==sqlite3_value_text(argv[0]) ); 1252 if( argc==1 ){ 1253 static const unsigned char lenOne[] = { 1 }; 1254 static unsigned char * const azOne[] = { (u8*)" " }; 1255 nChar = 1; 1256 aLen = (u8*)lenOne; 1257 azChar = (unsigned char **)azOne; 1258 zCharSet = 0; 1259 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 1260 return; 1261 }else{ 1262 const unsigned char *z; 1263 for(z=zCharSet, nChar=0; *z; nChar++){ 1264 SQLITE_SKIP_UTF8(z); 1265 } 1266 if( nChar>0 ){ 1267 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); 1268 if( azChar==0 ){ 1269 return; 1270 } 1271 aLen = (unsigned char*)&azChar[nChar]; 1272 for(z=zCharSet, nChar=0; *z; nChar++){ 1273 azChar[nChar] = (unsigned char *)z; 1274 SQLITE_SKIP_UTF8(z); 1275 aLen[nChar] = (u8)(z - azChar[nChar]); 1276 } 1277 } 1278 } 1279 if( nChar>0 ){ 1280 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); 1281 if( flags & 1 ){ 1282 while( nIn>0 ){ 1283 int len = 0; 1284 for(i=0; i<nChar; i++){ 1285 len = aLen[i]; 1286 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break; 1287 } 1288 if( i>=nChar ) break; 1289 zIn += len; 1290 nIn -= len; 1291 } 1292 } 1293 if( flags & 2 ){ 1294 while( nIn>0 ){ 1295 int len = 0; 1296 for(i=0; i<nChar; i++){ 1297 len = aLen[i]; 1298 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 1299 } 1300 if( i>=nChar ) break; 1301 nIn -= len; 1302 } 1303 } 1304 if( zCharSet ){ 1305 sqlite3_free(azChar); 1306 } 1307 } 1308 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 1309 } 1310 1311 1312 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It 1313 ** is only available if the SQLITE_SOUNDEX compile-time option is used 1314 ** when SQLite is built. 1315 */ 1316 #ifdef SQLITE_SOUNDEX 1317 /* 1318 ** Compute the soundex encoding of a word. 1319 ** 1320 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the 1321 ** soundex encoding of the string X. 1322 */ 1323 static void soundexFunc( 1324 sqlite3_context *context, 1325 int argc, 1326 sqlite3_value **argv 1327 ){ 1328 char zResult[8]; 1329 const u8 *zIn; 1330 int i, j; 1331 static const unsigned char iCode[] = { 1332 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1333 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1334 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1335 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1336 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1337 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1338 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1339 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1340 }; 1341 assert( argc==1 ); 1342 zIn = (u8*)sqlite3_value_text(argv[0]); 1343 if( zIn==0 ) zIn = (u8*)""; 1344 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} 1345 if( zIn[i] ){ 1346 u8 prevcode = iCode[zIn[i]&0x7f]; 1347 zResult[0] = sqlite3Toupper(zIn[i]); 1348 for(j=1; j<4 && zIn[i]; i++){ 1349 int code = iCode[zIn[i]&0x7f]; 1350 if( code>0 ){ 1351 if( code!=prevcode ){ 1352 prevcode = code; 1353 zResult[j++] = code + '0'; 1354 } 1355 }else{ 1356 prevcode = 0; 1357 } 1358 } 1359 while( j<4 ){ 1360 zResult[j++] = '0'; 1361 } 1362 zResult[j] = 0; 1363 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 1364 }else{ 1365 /* IMP: R-64894-50321 The string "?000" is returned if the argument 1366 ** is NULL or contains no ASCII alphabetic characters. */ 1367 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 1368 } 1369 } 1370 #endif /* SQLITE_SOUNDEX */ 1371 1372 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1373 /* 1374 ** A function that loads a shared-library extension then returns NULL. 1375 */ 1376 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 1377 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 1378 const char *zProc; 1379 sqlite3 *db = sqlite3_context_db_handle(context); 1380 char *zErrMsg = 0; 1381 1382 if( argc==2 ){ 1383 zProc = (const char *)sqlite3_value_text(argv[1]); 1384 }else{ 1385 zProc = 0; 1386 } 1387 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1388 sqlite3_result_error(context, zErrMsg, -1); 1389 sqlite3_free(zErrMsg); 1390 } 1391 } 1392 #endif 1393 1394 1395 /* 1396 ** An instance of the following structure holds the context of a 1397 ** sum() or avg() aggregate computation. 1398 */ 1399 typedef struct SumCtx SumCtx; 1400 struct SumCtx { 1401 double rSum; /* Floating point sum */ 1402 i64 iSum; /* Integer sum */ 1403 i64 cnt; /* Number of elements summed */ 1404 u8 overflow; /* True if integer overflow seen */ 1405 u8 approx; /* True if non-integer value was input to the sum */ 1406 }; 1407 1408 /* 1409 ** Routines used to compute the sum, average, and total. 1410 ** 1411 ** The SUM() function follows the (broken) SQL standard which means 1412 ** that it returns NULL if it sums over no inputs. TOTAL returns 1413 ** 0.0 in that case. In addition, TOTAL always returns a float where 1414 ** SUM might return an integer if it never encounters a floating point 1415 ** value. TOTAL never fails, but SUM might through an exception if 1416 ** it overflows an integer. 1417 */ 1418 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1419 SumCtx *p; 1420 int type; 1421 assert( argc==1 ); 1422 UNUSED_PARAMETER(argc); 1423 p = sqlite3_aggregate_context(context, sizeof(*p)); 1424 type = sqlite3_value_numeric_type(argv[0]); 1425 if( p && type!=SQLITE_NULL ){ 1426 p->cnt++; 1427 if( type==SQLITE_INTEGER ){ 1428 i64 v = sqlite3_value_int64(argv[0]); 1429 p->rSum += v; 1430 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ 1431 p->overflow = 1; 1432 } 1433 }else{ 1434 p->rSum += sqlite3_value_double(argv[0]); 1435 p->approx = 1; 1436 } 1437 } 1438 } 1439 static void sumFinalize(sqlite3_context *context){ 1440 SumCtx *p; 1441 p = sqlite3_aggregate_context(context, 0); 1442 if( p && p->cnt>0 ){ 1443 if( p->overflow ){ 1444 sqlite3_result_error(context,"integer overflow",-1); 1445 }else if( p->approx ){ 1446 sqlite3_result_double(context, p->rSum); 1447 }else{ 1448 sqlite3_result_int64(context, p->iSum); 1449 } 1450 } 1451 } 1452 static void avgFinalize(sqlite3_context *context){ 1453 SumCtx *p; 1454 p = sqlite3_aggregate_context(context, 0); 1455 if( p && p->cnt>0 ){ 1456 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1457 } 1458 } 1459 static void totalFinalize(sqlite3_context *context){ 1460 SumCtx *p; 1461 p = sqlite3_aggregate_context(context, 0); 1462 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ 1463 sqlite3_result_double(context, p ? p->rSum : (double)0); 1464 } 1465 1466 /* 1467 ** The following structure keeps track of state information for the 1468 ** count() aggregate function. 1469 */ 1470 typedef struct CountCtx CountCtx; 1471 struct CountCtx { 1472 i64 n; 1473 }; 1474 1475 /* 1476 ** Routines to implement the count() aggregate function. 1477 */ 1478 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1479 CountCtx *p; 1480 p = sqlite3_aggregate_context(context, sizeof(*p)); 1481 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1482 p->n++; 1483 } 1484 1485 #ifndef SQLITE_OMIT_DEPRECATED 1486 /* The sqlite3_aggregate_count() function is deprecated. But just to make 1487 ** sure it still operates correctly, verify that its count agrees with our 1488 ** internal count when using count(*) and when the total count can be 1489 ** expressed as a 32-bit integer. */ 1490 assert( argc==1 || p==0 || p->n>0x7fffffff 1491 || p->n==sqlite3_aggregate_count(context) ); 1492 #endif 1493 } 1494 static void countFinalize(sqlite3_context *context){ 1495 CountCtx *p; 1496 p = sqlite3_aggregate_context(context, 0); 1497 sqlite3_result_int64(context, p ? p->n : 0); 1498 } 1499 1500 /* 1501 ** Routines to implement min() and max() aggregate functions. 1502 */ 1503 static void minmaxStep( 1504 sqlite3_context *context, 1505 int NotUsed, 1506 sqlite3_value **argv 1507 ){ 1508 Mem *pArg = (Mem *)argv[0]; 1509 Mem *pBest; 1510 UNUSED_PARAMETER(NotUsed); 1511 1512 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1513 if( !pBest ) return; 1514 1515 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1516 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); 1517 }else if( pBest->flags ){ 1518 int max; 1519 int cmp; 1520 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1521 /* This step function is used for both the min() and max() aggregates, 1522 ** the only difference between the two being that the sense of the 1523 ** comparison is inverted. For the max() aggregate, the 1524 ** sqlite3_user_data() function returns (void *)-1. For min() it 1525 ** returns (void *)db, where db is the sqlite3* database pointer. 1526 ** Therefore the next statement sets variable 'max' to 1 for the max() 1527 ** aggregate, or 0 for min(). 1528 */ 1529 max = sqlite3_user_data(context)!=0; 1530 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1531 if( (max && cmp<0) || (!max && cmp>0) ){ 1532 sqlite3VdbeMemCopy(pBest, pArg); 1533 }else{ 1534 sqlite3SkipAccumulatorLoad(context); 1535 } 1536 }else{ 1537 pBest->db = sqlite3_context_db_handle(context); 1538 sqlite3VdbeMemCopy(pBest, pArg); 1539 } 1540 } 1541 static void minMaxFinalize(sqlite3_context *context){ 1542 sqlite3_value *pRes; 1543 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1544 if( pRes ){ 1545 if( pRes->flags ){ 1546 sqlite3_result_value(context, pRes); 1547 } 1548 sqlite3VdbeMemRelease(pRes); 1549 } 1550 } 1551 1552 /* 1553 ** group_concat(EXPR, ?SEPARATOR?) 1554 */ 1555 static void groupConcatStep( 1556 sqlite3_context *context, 1557 int argc, 1558 sqlite3_value **argv 1559 ){ 1560 const char *zVal; 1561 StrAccum *pAccum; 1562 const char *zSep; 1563 int nVal, nSep; 1564 assert( argc==1 || argc==2 ); 1565 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1566 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); 1567 1568 if( pAccum ){ 1569 sqlite3 *db = sqlite3_context_db_handle(context); 1570 int firstTerm = pAccum->useMalloc==0; 1571 pAccum->useMalloc = 2; 1572 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; 1573 if( !firstTerm ){ 1574 if( argc==2 ){ 1575 zSep = (char*)sqlite3_value_text(argv[1]); 1576 nSep = sqlite3_value_bytes(argv[1]); 1577 }else{ 1578 zSep = ","; 1579 nSep = 1; 1580 } 1581 if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep); 1582 } 1583 zVal = (char*)sqlite3_value_text(argv[0]); 1584 nVal = sqlite3_value_bytes(argv[0]); 1585 if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal); 1586 } 1587 } 1588 static void groupConcatFinalize(sqlite3_context *context){ 1589 StrAccum *pAccum; 1590 pAccum = sqlite3_aggregate_context(context, 0); 1591 if( pAccum ){ 1592 if( pAccum->accError==STRACCUM_TOOBIG ){ 1593 sqlite3_result_error_toobig(context); 1594 }else if( pAccum->accError==STRACCUM_NOMEM ){ 1595 sqlite3_result_error_nomem(context); 1596 }else{ 1597 sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 1598 sqlite3_free); 1599 } 1600 } 1601 } 1602 1603 /* 1604 ** This routine does per-connection function registration. Most 1605 ** of the built-in functions above are part of the global function set. 1606 ** This routine only deals with those that are not global. 1607 */ 1608 void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ 1609 int rc = sqlite3_overload_function(db, "MATCH", 2); 1610 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1611 if( rc==SQLITE_NOMEM ){ 1612 db->mallocFailed = 1; 1613 } 1614 } 1615 1616 /* 1617 ** Set the LIKEOPT flag on the 2-argument function with the given name. 1618 */ 1619 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){ 1620 FuncDef *pDef; 1621 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName), 1622 2, SQLITE_UTF8, 0); 1623 if( ALWAYS(pDef) ){ 1624 pDef->funcFlags |= flagVal; 1625 } 1626 } 1627 1628 /* 1629 ** Register the built-in LIKE and GLOB functions. The caseSensitive 1630 ** parameter determines whether or not the LIKE operator is case 1631 ** sensitive. GLOB is always case sensitive. 1632 */ 1633 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1634 struct compareInfo *pInfo; 1635 if( caseSensitive ){ 1636 pInfo = (struct compareInfo*)&likeInfoAlt; 1637 }else{ 1638 pInfo = (struct compareInfo*)&likeInfoNorm; 1639 } 1640 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1641 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1642 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 1643 (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0); 1644 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); 1645 setLikeOptFlag(db, "like", 1646 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); 1647 } 1648 1649 /* 1650 ** pExpr points to an expression which implements a function. If 1651 ** it is appropriate to apply the LIKE optimization to that function 1652 ** then set aWc[0] through aWc[2] to the wildcard characters and 1653 ** return TRUE. If the function is not a LIKE-style function then 1654 ** return FALSE. 1655 ** 1656 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for 1657 ** the function (default for LIKE). If the function makes the distinction 1658 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to 1659 ** false. 1660 */ 1661 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1662 FuncDef *pDef; 1663 if( pExpr->op!=TK_FUNCTION 1664 || !pExpr->x.pList 1665 || pExpr->x.pList->nExpr!=2 1666 ){ 1667 return 0; 1668 } 1669 assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); 1670 pDef = sqlite3FindFunction(db, pExpr->u.zToken, 1671 sqlite3Strlen30(pExpr->u.zToken), 1672 2, SQLITE_UTF8, 0); 1673 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ 1674 return 0; 1675 } 1676 1677 /* The memcpy() statement assumes that the wildcard characters are 1678 ** the first three statements in the compareInfo structure. The 1679 ** asserts() that follow verify that assumption 1680 */ 1681 memcpy(aWc, pDef->pUserData, 3); 1682 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1683 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1684 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1685 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; 1686 return 1; 1687 } 1688 1689 /* 1690 ** All of the FuncDef structures in the aBuiltinFunc[] array above 1691 ** to the global function hash table. This occurs at start-time (as 1692 ** a consequence of calling sqlite3_initialize()). 1693 ** 1694 ** After this routine runs 1695 */ 1696 void sqlite3RegisterGlobalFunctions(void){ 1697 /* 1698 ** The following array holds FuncDef structures for all of the functions 1699 ** defined in this file. 1700 ** 1701 ** The array cannot be constant since changes are made to the 1702 ** FuncDef.pHash elements at start-time. The elements of this array 1703 ** are read-only after initialization is complete. 1704 */ 1705 static SQLITE_WSD FuncDef aBuiltinFunc[] = { 1706 FUNCTION(ltrim, 1, 1, 0, trimFunc ), 1707 FUNCTION(ltrim, 2, 1, 0, trimFunc ), 1708 FUNCTION(rtrim, 1, 2, 0, trimFunc ), 1709 FUNCTION(rtrim, 2, 2, 0, trimFunc ), 1710 FUNCTION(trim, 1, 3, 0, trimFunc ), 1711 FUNCTION(trim, 2, 3, 0, trimFunc ), 1712 FUNCTION(min, -1, 0, 1, minmaxFunc ), 1713 FUNCTION(min, 0, 0, 1, 0 ), 1714 AGGREGATE2(min, 1, 0, 1, minmaxStep, minMaxFinalize, 1715 SQLITE_FUNC_MINMAX ), 1716 FUNCTION(max, -1, 1, 1, minmaxFunc ), 1717 FUNCTION(max, 0, 1, 1, 0 ), 1718 AGGREGATE2(max, 1, 1, 1, minmaxStep, minMaxFinalize, 1719 SQLITE_FUNC_MINMAX ), 1720 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), 1721 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), 1722 FUNCTION(instr, 2, 0, 0, instrFunc ), 1723 FUNCTION(substr, 2, 0, 0, substrFunc ), 1724 FUNCTION(substr, 3, 0, 0, substrFunc ), 1725 FUNCTION(printf, -1, 0, 0, printfFunc ), 1726 FUNCTION(unicode, 1, 0, 0, unicodeFunc ), 1727 FUNCTION(char, -1, 0, 0, charFunc ), 1728 FUNCTION(abs, 1, 0, 0, absFunc ), 1729 #ifndef SQLITE_OMIT_FLOATING_POINT 1730 FUNCTION(round, 1, 0, 0, roundFunc ), 1731 FUNCTION(round, 2, 0, 0, roundFunc ), 1732 #endif 1733 FUNCTION(upper, 1, 0, 0, upperFunc ), 1734 FUNCTION(lower, 1, 0, 0, lowerFunc ), 1735 FUNCTION(coalesce, 1, 0, 0, 0 ), 1736 FUNCTION(coalesce, 0, 0, 0, 0 ), 1737 FUNCTION2(coalesce, -1, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1738 FUNCTION(hex, 1, 0, 0, hexFunc ), 1739 FUNCTION2(ifnull, 2, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1740 FUNCTION2(unlikely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1741 FUNCTION2(likelihood, 2, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1742 FUNCTION2(likely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1743 VFUNCTION(random, 0, 0, 0, randomFunc ), 1744 VFUNCTION(randomblob, 1, 0, 0, randomBlob ), 1745 FUNCTION(nullif, 2, 0, 1, nullifFunc ), 1746 FUNCTION(sqlite_version, 0, 0, 0, versionFunc ), 1747 FUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), 1748 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), 1749 #if SQLITE_USER_AUTHENTICATION 1750 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), 1751 #endif 1752 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 1753 FUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), 1754 FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), 1755 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 1756 FUNCTION(quote, 1, 0, 0, quoteFunc ), 1757 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), 1758 VFUNCTION(changes, 0, 0, 0, changes ), 1759 VFUNCTION(total_changes, 0, 0, 0, total_changes ), 1760 FUNCTION(replace, 3, 0, 0, replaceFunc ), 1761 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), 1762 #ifdef SQLITE_SOUNDEX 1763 FUNCTION(soundex, 1, 0, 0, soundexFunc ), 1764 #endif 1765 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1766 FUNCTION(load_extension, 1, 0, 0, loadExt ), 1767 FUNCTION(load_extension, 2, 0, 0, loadExt ), 1768 #endif 1769 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ), 1770 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ), 1771 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ), 1772 AGGREGATE2(count, 0, 0, 0, countStep, countFinalize, 1773 SQLITE_FUNC_COUNT ), 1774 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ), 1775 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize), 1776 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize), 1777 1778 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1779 #ifdef SQLITE_CASE_SENSITIVE_LIKE 1780 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1781 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1782 #else 1783 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), 1784 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), 1785 #endif 1786 }; 1787 1788 int i; 1789 FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); 1790 FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aBuiltinFunc); 1791 1792 for(i=0; i<ArraySize(aBuiltinFunc); i++){ 1793 sqlite3FuncDefInsert(pHash, &aFunc[i]); 1794 } 1795 sqlite3RegisterDateTimeFunctions(); 1796 #ifndef SQLITE_OMIT_ALTERTABLE 1797 sqlite3AlterFunctions(); 1798 #endif 1799 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4) 1800 sqlite3AnalyzeFunctions(); 1801 #endif 1802 } 1803