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