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