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