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 698 || (c == matchOne && matchOne!=0) ){ 699 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ 700 return SQLITE_NOWILDCARDMATCH; 701 } 702 } 703 if( c==0 ){ 704 return SQLITE_MATCH; /* "*" at the end of the pattern matches */ 705 }else if( c==matchOther ){ 706 if( pInfo->matchSet==0 ){ 707 c = sqlite3Utf8Read(&zPattern); 708 if( c==0 ) return SQLITE_NOWILDCARDMATCH; 709 }else{ 710 /* "[...]" immediately follows the "*". We have to do a slow 711 ** recursive search in this case, but it is an unusual case. */ 712 assert( matchOther<0x80 ); /* '[' is a single-byte character */ 713 while( *zString ){ 714 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther); 715 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 716 SQLITE_SKIP_UTF8(zString); 717 } 718 return SQLITE_NOWILDCARDMATCH; 719 } 720 } 721 722 /* At this point variable c contains the first character of the 723 ** pattern string past the "*". Search in the input string for the 724 ** first matching character and recursively continue the match from 725 ** that point. 726 ** 727 ** For a case-insensitive search, set variable cx to be the same as 728 ** c but in the other case and search the input string for either 729 ** c or cx. 730 */ 731 if( c<=0x80 ){ 732 char zStop[3]; 733 int bMatch; 734 if( noCase ){ 735 zStop[0] = sqlite3Toupper(c); 736 zStop[1] = sqlite3Tolower(c); 737 zStop[2] = 0; 738 }else{ 739 zStop[0] = c; 740 zStop[1] = 0; 741 } 742 while(1){ 743 zString += strcspn((const char*)zString, zStop); 744 if( zString[0]==0 ) break; 745 zString++; 746 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 747 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 748 } 749 }else{ 750 int bMatch; 751 while( (c2 = Utf8Read(zString))!=0 ){ 752 if( c2!=c ) continue; 753 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 754 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 755 } 756 } 757 return SQLITE_NOWILDCARDMATCH; 758 } 759 if( c==matchOther ){ 760 if( pInfo->matchSet==0 ){ 761 c = sqlite3Utf8Read(&zPattern); 762 if( c==0 ) return SQLITE_NOMATCH; 763 zEscaped = zPattern; 764 }else{ 765 u32 prior_c = 0; 766 int seen = 0; 767 int invert = 0; 768 c = sqlite3Utf8Read(&zString); 769 if( c==0 ) return SQLITE_NOMATCH; 770 c2 = sqlite3Utf8Read(&zPattern); 771 if( c2=='^' ){ 772 invert = 1; 773 c2 = sqlite3Utf8Read(&zPattern); 774 } 775 if( c2==']' ){ 776 if( c==']' ) seen = 1; 777 c2 = sqlite3Utf8Read(&zPattern); 778 } 779 while( c2 && c2!=']' ){ 780 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 781 c2 = sqlite3Utf8Read(&zPattern); 782 if( c>=prior_c && c<=c2 ) seen = 1; 783 prior_c = 0; 784 }else{ 785 if( c==c2 ){ 786 seen = 1; 787 } 788 prior_c = c2; 789 } 790 c2 = sqlite3Utf8Read(&zPattern); 791 } 792 if( c2==0 || (seen ^ invert)==0 ){ 793 return SQLITE_NOMATCH; 794 } 795 continue; 796 } 797 } 798 c2 = Utf8Read(zString); 799 if( c==c2 ) continue; 800 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ 801 continue; 802 } 803 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; 804 return SQLITE_NOMATCH; 805 } 806 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; 807 } 808 809 /* 810 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and 811 ** non-zero if there is no match. 812 */ 813 int sqlite3_strglob(const char *zGlobPattern, const char *zString){ 814 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); 815 } 816 817 /* 818 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for 819 ** a miss - like strcmp(). 820 */ 821 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ 822 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); 823 } 824 825 /* 826 ** Count the number of times that the LIKE operator (or GLOB which is 827 ** just a variation of LIKE) gets called. This is used for testing 828 ** only. 829 */ 830 #ifdef SQLITE_TEST 831 int sqlite3_like_count = 0; 832 #endif 833 834 835 /* 836 ** Implementation of the like() SQL function. This function implements 837 ** the build-in LIKE operator. The first argument to the function is the 838 ** pattern and the second argument is the string. So, the SQL statements: 839 ** 840 ** A LIKE B 841 ** 842 ** is implemented as like(B,A). 843 ** 844 ** This same function (with a different compareInfo structure) computes 845 ** the GLOB operator. 846 */ 847 static void likeFunc( 848 sqlite3_context *context, 849 int argc, 850 sqlite3_value **argv 851 ){ 852 const unsigned char *zA, *zB; 853 u32 escape; 854 int nPat; 855 sqlite3 *db = sqlite3_context_db_handle(context); 856 struct compareInfo *pInfo = sqlite3_user_data(context); 857 struct compareInfo backupInfo; 858 859 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS 860 if( sqlite3_value_type(argv[0])==SQLITE_BLOB 861 || sqlite3_value_type(argv[1])==SQLITE_BLOB 862 ){ 863 #ifdef SQLITE_TEST 864 sqlite3_like_count++; 865 #endif 866 sqlite3_result_int(context, 0); 867 return; 868 } 869 #endif 870 871 /* Limit the length of the LIKE or GLOB pattern to avoid problems 872 ** of deep recursion and N*N behavior in patternCompare(). 873 */ 874 nPat = sqlite3_value_bytes(argv[0]); 875 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); 876 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); 877 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ 878 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 879 return; 880 } 881 if( argc==3 ){ 882 /* The escape character string must consist of a single UTF-8 character. 883 ** Otherwise, return an error. 884 */ 885 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 886 if( zEsc==0 ) return; 887 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 888 sqlite3_result_error(context, 889 "ESCAPE expression must be a single character", -1); 890 return; 891 } 892 escape = sqlite3Utf8Read(&zEsc); 893 if( escape==pInfo->matchAll || escape==pInfo->matchOne ){ 894 memcpy(&backupInfo, pInfo, sizeof(backupInfo)); 895 pInfo = &backupInfo; 896 if( escape==pInfo->matchAll ) pInfo->matchAll = 0; 897 if( escape==pInfo->matchOne ) pInfo->matchOne = 0; 898 } 899 }else{ 900 escape = pInfo->matchSet; 901 } 902 zB = sqlite3_value_text(argv[0]); 903 zA = sqlite3_value_text(argv[1]); 904 if( zA && zB ){ 905 #ifdef SQLITE_TEST 906 sqlite3_like_count++; 907 #endif 908 sqlite3_result_int(context, 909 patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); 910 } 911 } 912 913 /* 914 ** Implementation of the NULLIF(x,y) function. The result is the first 915 ** argument if the arguments are different. The result is NULL if the 916 ** arguments are equal to each other. 917 */ 918 static void nullifFunc( 919 sqlite3_context *context, 920 int NotUsed, 921 sqlite3_value **argv 922 ){ 923 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 924 UNUSED_PARAMETER(NotUsed); 925 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 926 sqlite3_result_value(context, argv[0]); 927 } 928 } 929 930 /* 931 ** Implementation of the sqlite_version() function. The result is the version 932 ** of the SQLite library that is running. 933 */ 934 static void versionFunc( 935 sqlite3_context *context, 936 int NotUsed, 937 sqlite3_value **NotUsed2 938 ){ 939 UNUSED_PARAMETER2(NotUsed, NotUsed2); 940 /* IMP: R-48699-48617 This function is an SQL wrapper around the 941 ** sqlite3_libversion() C-interface. */ 942 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); 943 } 944 945 /* 946 ** Implementation of the sqlite_source_id() function. The result is a string 947 ** that identifies the particular version of the source code used to build 948 ** SQLite. 949 */ 950 static void sourceidFunc( 951 sqlite3_context *context, 952 int NotUsed, 953 sqlite3_value **NotUsed2 954 ){ 955 UNUSED_PARAMETER2(NotUsed, NotUsed2); 956 /* IMP: R-24470-31136 This function is an SQL wrapper around the 957 ** sqlite3_sourceid() C interface. */ 958 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); 959 } 960 961 /* 962 ** Implementation of the sqlite_log() function. This is a wrapper around 963 ** sqlite3_log(). The return value is NULL. The function exists purely for 964 ** its side-effects. 965 */ 966 static void errlogFunc( 967 sqlite3_context *context, 968 int argc, 969 sqlite3_value **argv 970 ){ 971 UNUSED_PARAMETER(argc); 972 UNUSED_PARAMETER(context); 973 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); 974 } 975 976 /* 977 ** Implementation of the sqlite_compileoption_used() function. 978 ** The result is an integer that identifies if the compiler option 979 ** was used to build SQLite. 980 */ 981 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 982 static void compileoptionusedFunc( 983 sqlite3_context *context, 984 int argc, 985 sqlite3_value **argv 986 ){ 987 const char *zOptName; 988 assert( argc==1 ); 989 UNUSED_PARAMETER(argc); 990 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL 991 ** function is a wrapper around the sqlite3_compileoption_used() C/C++ 992 ** function. 993 */ 994 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 995 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); 996 } 997 } 998 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 999 1000 /* 1001 ** Implementation of the sqlite_compileoption_get() function. 1002 ** The result is a string that identifies the compiler options 1003 ** used to build SQLite. 1004 */ 1005 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 1006 static void compileoptiongetFunc( 1007 sqlite3_context *context, 1008 int argc, 1009 sqlite3_value **argv 1010 ){ 1011 int n; 1012 assert( argc==1 ); 1013 UNUSED_PARAMETER(argc); 1014 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function 1015 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. 1016 */ 1017 n = sqlite3_value_int(argv[0]); 1018 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); 1019 } 1020 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 1021 1022 /* Array for converting from half-bytes (nybbles) into ASCII hex 1023 ** digits. */ 1024 static const char hexdigits[] = { 1025 '0', '1', '2', '3', '4', '5', '6', '7', 1026 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 1027 }; 1028 1029 /* 1030 ** Implementation of the QUOTE() function. This function takes a single 1031 ** argument. If the argument is numeric, the return value is the same as 1032 ** the argument. If the argument is NULL, the return value is the string 1033 ** "NULL". Otherwise, the argument is enclosed in single quotes with 1034 ** single-quote escapes. 1035 */ 1036 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 1037 assert( argc==1 ); 1038 UNUSED_PARAMETER(argc); 1039 switch( sqlite3_value_type(argv[0]) ){ 1040 case SQLITE_FLOAT: { 1041 double r1, r2; 1042 char zBuf[50]; 1043 r1 = sqlite3_value_double(argv[0]); 1044 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); 1045 sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); 1046 if( r1!=r2 ){ 1047 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); 1048 } 1049 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); 1050 break; 1051 } 1052 case SQLITE_INTEGER: { 1053 sqlite3_result_value(context, argv[0]); 1054 break; 1055 } 1056 case SQLITE_BLOB: { 1057 char *zText = 0; 1058 char const *zBlob = sqlite3_value_blob(argv[0]); 1059 int nBlob = sqlite3_value_bytes(argv[0]); 1060 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1061 zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); 1062 if( zText ){ 1063 int i; 1064 for(i=0; i<nBlob; i++){ 1065 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 1066 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 1067 } 1068 zText[(nBlob*2)+2] = '\''; 1069 zText[(nBlob*2)+3] = '\0'; 1070 zText[0] = 'X'; 1071 zText[1] = '\''; 1072 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 1073 sqlite3_free(zText); 1074 } 1075 break; 1076 } 1077 case SQLITE_TEXT: { 1078 int i,j; 1079 u64 n; 1080 const unsigned char *zArg = sqlite3_value_text(argv[0]); 1081 char *z; 1082 1083 if( zArg==0 ) return; 1084 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } 1085 z = contextMalloc(context, ((i64)i)+((i64)n)+3); 1086 if( z ){ 1087 z[0] = '\''; 1088 for(i=0, j=1; zArg[i]; i++){ 1089 z[j++] = zArg[i]; 1090 if( zArg[i]=='\'' ){ 1091 z[j++] = '\''; 1092 } 1093 } 1094 z[j++] = '\''; 1095 z[j] = 0; 1096 sqlite3_result_text(context, z, j, sqlite3_free); 1097 } 1098 break; 1099 } 1100 default: { 1101 assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); 1102 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); 1103 break; 1104 } 1105 } 1106 } 1107 1108 /* 1109 ** The unicode() function. Return the integer unicode code-point value 1110 ** for the first character of the input string. 1111 */ 1112 static void unicodeFunc( 1113 sqlite3_context *context, 1114 int argc, 1115 sqlite3_value **argv 1116 ){ 1117 const unsigned char *z = sqlite3_value_text(argv[0]); 1118 (void)argc; 1119 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); 1120 } 1121 1122 /* 1123 ** The char() function takes zero or more arguments, each of which is 1124 ** an integer. It constructs a string where each character of the string 1125 ** is the unicode character for the corresponding integer argument. 1126 */ 1127 static void charFunc( 1128 sqlite3_context *context, 1129 int argc, 1130 sqlite3_value **argv 1131 ){ 1132 unsigned char *z, *zOut; 1133 int i; 1134 zOut = z = sqlite3_malloc64( argc*4+1 ); 1135 if( z==0 ){ 1136 sqlite3_result_error_nomem(context); 1137 return; 1138 } 1139 for(i=0; i<argc; i++){ 1140 sqlite3_int64 x; 1141 unsigned c; 1142 x = sqlite3_value_int64(argv[i]); 1143 if( x<0 || x>0x10ffff ) x = 0xfffd; 1144 c = (unsigned)(x & 0x1fffff); 1145 if( c<0x00080 ){ 1146 *zOut++ = (u8)(c&0xFF); 1147 }else if( c<0x00800 ){ 1148 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); 1149 *zOut++ = 0x80 + (u8)(c & 0x3F); 1150 }else if( c<0x10000 ){ 1151 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); 1152 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1153 *zOut++ = 0x80 + (u8)(c & 0x3F); 1154 }else{ 1155 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); 1156 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); 1157 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1158 *zOut++ = 0x80 + (u8)(c & 0x3F); 1159 } \ 1160 } 1161 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); 1162 } 1163 1164 /* 1165 ** The hex() function. Interpret the argument as a blob. Return 1166 ** a hexadecimal rendering as text. 1167 */ 1168 static void hexFunc( 1169 sqlite3_context *context, 1170 int argc, 1171 sqlite3_value **argv 1172 ){ 1173 int i, n; 1174 const unsigned char *pBlob; 1175 char *zHex, *z; 1176 assert( argc==1 ); 1177 UNUSED_PARAMETER(argc); 1178 pBlob = sqlite3_value_blob(argv[0]); 1179 n = sqlite3_value_bytes(argv[0]); 1180 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1181 z = zHex = contextMalloc(context, ((i64)n)*2 + 1); 1182 if( zHex ){ 1183 for(i=0; i<n; i++, pBlob++){ 1184 unsigned char c = *pBlob; 1185 *(z++) = hexdigits[(c>>4)&0xf]; 1186 *(z++) = hexdigits[c&0xf]; 1187 } 1188 *z = 0; 1189 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 1190 } 1191 } 1192 1193 /* 1194 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 1195 */ 1196 static void zeroblobFunc( 1197 sqlite3_context *context, 1198 int argc, 1199 sqlite3_value **argv 1200 ){ 1201 i64 n; 1202 int rc; 1203 assert( argc==1 ); 1204 UNUSED_PARAMETER(argc); 1205 n = sqlite3_value_int64(argv[0]); 1206 if( n<0 ) n = 0; 1207 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ 1208 if( rc ){ 1209 sqlite3_result_error_code(context, rc); 1210 } 1211 } 1212 1213 /* 1214 ** The replace() function. Three arguments are all strings: call 1215 ** them A, B, and C. The result is also a string which is derived 1216 ** from A by replacing every occurrence of B with C. The match 1217 ** must be exact. Collating sequences are not used. 1218 */ 1219 static void replaceFunc( 1220 sqlite3_context *context, 1221 int argc, 1222 sqlite3_value **argv 1223 ){ 1224 const unsigned char *zStr; /* The input string A */ 1225 const unsigned char *zPattern; /* The pattern string B */ 1226 const unsigned char *zRep; /* The replacement string C */ 1227 unsigned char *zOut; /* The output */ 1228 int nStr; /* Size of zStr */ 1229 int nPattern; /* Size of zPattern */ 1230 int nRep; /* Size of zRep */ 1231 i64 nOut; /* Maximum size of zOut */ 1232 int loopLimit; /* Last zStr[] that might match zPattern[] */ 1233 int i, j; /* Loop counters */ 1234 unsigned cntExpand; /* Number zOut expansions */ 1235 sqlite3 *db = sqlite3_context_db_handle(context); 1236 1237 assert( argc==3 ); 1238 UNUSED_PARAMETER(argc); 1239 zStr = sqlite3_value_text(argv[0]); 1240 if( zStr==0 ) return; 1241 nStr = sqlite3_value_bytes(argv[0]); 1242 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 1243 zPattern = sqlite3_value_text(argv[1]); 1244 if( zPattern==0 ){ 1245 assert( sqlite3_value_type(argv[1])==SQLITE_NULL 1246 || sqlite3_context_db_handle(context)->mallocFailed ); 1247 return; 1248 } 1249 if( zPattern[0]==0 ){ 1250 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); 1251 sqlite3_result_value(context, argv[0]); 1252 return; 1253 } 1254 nPattern = sqlite3_value_bytes(argv[1]); 1255 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 1256 zRep = sqlite3_value_text(argv[2]); 1257 if( zRep==0 ) return; 1258 nRep = sqlite3_value_bytes(argv[2]); 1259 assert( zRep==sqlite3_value_text(argv[2]) ); 1260 nOut = nStr + 1; 1261 assert( nOut<SQLITE_MAX_LENGTH ); 1262 zOut = contextMalloc(context, (i64)nOut); 1263 if( zOut==0 ){ 1264 return; 1265 } 1266 loopLimit = nStr - nPattern; 1267 cntExpand = 0; 1268 for(i=j=0; i<=loopLimit; i++){ 1269 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 1270 zOut[j++] = zStr[i]; 1271 }else{ 1272 if( nRep>nPattern ){ 1273 nOut += nRep - nPattern; 1274 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1275 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1276 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1277 sqlite3_result_error_toobig(context); 1278 sqlite3_free(zOut); 1279 return; 1280 } 1281 cntExpand++; 1282 if( (cntExpand&(cntExpand-1))==0 ){ 1283 /* Grow the size of the output buffer only on substitutions 1284 ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */ 1285 u8 *zOld; 1286 zOld = zOut; 1287 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1)); 1288 if( zOut==0 ){ 1289 sqlite3_result_error_nomem(context); 1290 sqlite3_free(zOld); 1291 return; 1292 } 1293 } 1294 } 1295 memcpy(&zOut[j], zRep, nRep); 1296 j += nRep; 1297 i += nPattern-1; 1298 } 1299 } 1300 assert( j+nStr-i+1<=nOut ); 1301 memcpy(&zOut[j], &zStr[i], nStr-i); 1302 j += nStr - i; 1303 assert( j<=nOut ); 1304 zOut[j] = 0; 1305 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 1306 } 1307 1308 /* 1309 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 1310 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 1311 */ 1312 static void trimFunc( 1313 sqlite3_context *context, 1314 int argc, 1315 sqlite3_value **argv 1316 ){ 1317 const unsigned char *zIn; /* Input string */ 1318 const unsigned char *zCharSet; /* Set of characters to trim */ 1319 int nIn; /* Number of bytes in input */ 1320 int flags; /* 1: trimleft 2: trimright 3: trim */ 1321 int i; /* Loop counter */ 1322 unsigned char *aLen = 0; /* Length of each character in zCharSet */ 1323 unsigned char **azChar = 0; /* Individual characters in zCharSet */ 1324 int nChar; /* Number of characters in zCharSet */ 1325 1326 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1327 return; 1328 } 1329 zIn = sqlite3_value_text(argv[0]); 1330 if( zIn==0 ) return; 1331 nIn = sqlite3_value_bytes(argv[0]); 1332 assert( zIn==sqlite3_value_text(argv[0]) ); 1333 if( argc==1 ){ 1334 static const unsigned char lenOne[] = { 1 }; 1335 static unsigned char * const azOne[] = { (u8*)" " }; 1336 nChar = 1; 1337 aLen = (u8*)lenOne; 1338 azChar = (unsigned char **)azOne; 1339 zCharSet = 0; 1340 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 1341 return; 1342 }else{ 1343 const unsigned char *z; 1344 for(z=zCharSet, nChar=0; *z; nChar++){ 1345 SQLITE_SKIP_UTF8(z); 1346 } 1347 if( nChar>0 ){ 1348 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); 1349 if( azChar==0 ){ 1350 return; 1351 } 1352 aLen = (unsigned char*)&azChar[nChar]; 1353 for(z=zCharSet, nChar=0; *z; nChar++){ 1354 azChar[nChar] = (unsigned char *)z; 1355 SQLITE_SKIP_UTF8(z); 1356 aLen[nChar] = (u8)(z - azChar[nChar]); 1357 } 1358 } 1359 } 1360 if( nChar>0 ){ 1361 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); 1362 if( flags & 1 ){ 1363 while( nIn>0 ){ 1364 int len = 0; 1365 for(i=0; i<nChar; i++){ 1366 len = aLen[i]; 1367 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break; 1368 } 1369 if( i>=nChar ) break; 1370 zIn += len; 1371 nIn -= len; 1372 } 1373 } 1374 if( flags & 2 ){ 1375 while( nIn>0 ){ 1376 int len = 0; 1377 for(i=0; i<nChar; i++){ 1378 len = aLen[i]; 1379 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 1380 } 1381 if( i>=nChar ) break; 1382 nIn -= len; 1383 } 1384 } 1385 if( zCharSet ){ 1386 sqlite3_free(azChar); 1387 } 1388 } 1389 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 1390 } 1391 1392 1393 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1394 /* 1395 ** The "unknown" function is automatically substituted in place of 1396 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN 1397 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used. 1398 ** When the "sqlite3" command-line shell is built using this functionality, 1399 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries 1400 ** involving application-defined functions to be examined in a generic 1401 ** sqlite3 shell. 1402 */ 1403 static void unknownFunc( 1404 sqlite3_context *context, 1405 int argc, 1406 sqlite3_value **argv 1407 ){ 1408 /* no-op */ 1409 } 1410 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ 1411 1412 1413 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It 1414 ** is only available if the SQLITE_SOUNDEX compile-time option is used 1415 ** when SQLite is built. 1416 */ 1417 #ifdef SQLITE_SOUNDEX 1418 /* 1419 ** Compute the soundex encoding of a word. 1420 ** 1421 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the 1422 ** soundex encoding of the string X. 1423 */ 1424 static void soundexFunc( 1425 sqlite3_context *context, 1426 int argc, 1427 sqlite3_value **argv 1428 ){ 1429 char zResult[8]; 1430 const u8 *zIn; 1431 int i, j; 1432 static const unsigned char iCode[] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1437 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1438 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1439 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1440 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1441 }; 1442 assert( argc==1 ); 1443 zIn = (u8*)sqlite3_value_text(argv[0]); 1444 if( zIn==0 ) zIn = (u8*)""; 1445 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} 1446 if( zIn[i] ){ 1447 u8 prevcode = iCode[zIn[i]&0x7f]; 1448 zResult[0] = sqlite3Toupper(zIn[i]); 1449 for(j=1; j<4 && zIn[i]; i++){ 1450 int code = iCode[zIn[i]&0x7f]; 1451 if( code>0 ){ 1452 if( code!=prevcode ){ 1453 prevcode = code; 1454 zResult[j++] = code + '0'; 1455 } 1456 }else{ 1457 prevcode = 0; 1458 } 1459 } 1460 while( j<4 ){ 1461 zResult[j++] = '0'; 1462 } 1463 zResult[j] = 0; 1464 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 1465 }else{ 1466 /* IMP: R-64894-50321 The string "?000" is returned if the argument 1467 ** is NULL or contains no ASCII alphabetic characters. */ 1468 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 1469 } 1470 } 1471 #endif /* SQLITE_SOUNDEX */ 1472 1473 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1474 /* 1475 ** A function that loads a shared-library extension then returns NULL. 1476 */ 1477 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 1478 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 1479 const char *zProc; 1480 sqlite3 *db = sqlite3_context_db_handle(context); 1481 char *zErrMsg = 0; 1482 1483 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc 1484 ** flag is set. See the sqlite3_enable_load_extension() API. 1485 */ 1486 if( (db->flags & SQLITE_LoadExtFunc)==0 ){ 1487 sqlite3_result_error(context, "not authorized", -1); 1488 return; 1489 } 1490 1491 if( argc==2 ){ 1492 zProc = (const char *)sqlite3_value_text(argv[1]); 1493 }else{ 1494 zProc = 0; 1495 } 1496 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1497 sqlite3_result_error(context, zErrMsg, -1); 1498 sqlite3_free(zErrMsg); 1499 } 1500 } 1501 #endif 1502 1503 1504 /* 1505 ** An instance of the following structure holds the context of a 1506 ** sum() or avg() aggregate computation. 1507 */ 1508 typedef struct SumCtx SumCtx; 1509 struct SumCtx { 1510 double rSum; /* Floating point sum */ 1511 i64 iSum; /* Integer sum */ 1512 i64 cnt; /* Number of elements summed */ 1513 u8 overflow; /* True if integer overflow seen */ 1514 u8 approx; /* True if non-integer value was input to the sum */ 1515 }; 1516 1517 /* 1518 ** Routines used to compute the sum, average, and total. 1519 ** 1520 ** The SUM() function follows the (broken) SQL standard which means 1521 ** that it returns NULL if it sums over no inputs. TOTAL returns 1522 ** 0.0 in that case. In addition, TOTAL always returns a float where 1523 ** SUM might return an integer if it never encounters a floating point 1524 ** value. TOTAL never fails, but SUM might through an exception if 1525 ** it overflows an integer. 1526 */ 1527 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1528 SumCtx *p; 1529 int type; 1530 assert( argc==1 ); 1531 UNUSED_PARAMETER(argc); 1532 p = sqlite3_aggregate_context(context, sizeof(*p)); 1533 type = sqlite3_value_numeric_type(argv[0]); 1534 if( p && type!=SQLITE_NULL ){ 1535 p->cnt++; 1536 if( type==SQLITE_INTEGER ){ 1537 i64 v = sqlite3_value_int64(argv[0]); 1538 p->rSum += v; 1539 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ 1540 p->approx = p->overflow = 1; 1541 } 1542 }else{ 1543 p->rSum += sqlite3_value_double(argv[0]); 1544 p->approx = 1; 1545 } 1546 } 1547 } 1548 #ifndef SQLITE_OMIT_WINDOWFUNC 1549 static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){ 1550 SumCtx *p; 1551 int type; 1552 assert( argc==1 ); 1553 UNUSED_PARAMETER(argc); 1554 p = sqlite3_aggregate_context(context, sizeof(*p)); 1555 type = sqlite3_value_numeric_type(argv[0]); 1556 /* p is always non-NULL because sumStep() will have been called first 1557 ** to initialize it */ 1558 if( ALWAYS(p) && type!=SQLITE_NULL ){ 1559 assert( p->cnt>0 ); 1560 p->cnt--; 1561 assert( type==SQLITE_INTEGER || p->approx ); 1562 if( type==SQLITE_INTEGER && p->approx==0 ){ 1563 i64 v = sqlite3_value_int64(argv[0]); 1564 p->rSum -= v; 1565 p->iSum -= v; 1566 }else{ 1567 p->rSum -= sqlite3_value_double(argv[0]); 1568 } 1569 } 1570 } 1571 #else 1572 # define sumInverse 0 1573 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1574 static void sumFinalize(sqlite3_context *context){ 1575 SumCtx *p; 1576 p = sqlite3_aggregate_context(context, 0); 1577 if( p && p->cnt>0 ){ 1578 if( p->overflow ){ 1579 sqlite3_result_error(context,"integer overflow",-1); 1580 }else if( p->approx ){ 1581 sqlite3_result_double(context, p->rSum); 1582 }else{ 1583 sqlite3_result_int64(context, p->iSum); 1584 } 1585 } 1586 } 1587 static void avgFinalize(sqlite3_context *context){ 1588 SumCtx *p; 1589 p = sqlite3_aggregate_context(context, 0); 1590 if( p && p->cnt>0 ){ 1591 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1592 } 1593 } 1594 static void totalFinalize(sqlite3_context *context){ 1595 SumCtx *p; 1596 p = sqlite3_aggregate_context(context, 0); 1597 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ 1598 sqlite3_result_double(context, p ? p->rSum : (double)0); 1599 } 1600 1601 /* 1602 ** The following structure keeps track of state information for the 1603 ** count() aggregate function. 1604 */ 1605 typedef struct CountCtx CountCtx; 1606 struct CountCtx { 1607 i64 n; 1608 #ifdef SQLITE_DEBUG 1609 int bInverse; /* True if xInverse() ever called */ 1610 #endif 1611 }; 1612 1613 /* 1614 ** Routines to implement the count() aggregate function. 1615 */ 1616 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1617 CountCtx *p; 1618 p = sqlite3_aggregate_context(context, sizeof(*p)); 1619 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1620 p->n++; 1621 } 1622 1623 #ifndef SQLITE_OMIT_DEPRECATED 1624 /* The sqlite3_aggregate_count() function is deprecated. But just to make 1625 ** sure it still operates correctly, verify that its count agrees with our 1626 ** internal count when using count(*) and when the total count can be 1627 ** expressed as a 32-bit integer. */ 1628 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse 1629 || p->n==sqlite3_aggregate_count(context) ); 1630 #endif 1631 } 1632 static void countFinalize(sqlite3_context *context){ 1633 CountCtx *p; 1634 p = sqlite3_aggregate_context(context, 0); 1635 sqlite3_result_int64(context, p ? p->n : 0); 1636 } 1637 #ifndef SQLITE_OMIT_WINDOWFUNC 1638 static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){ 1639 CountCtx *p; 1640 p = sqlite3_aggregate_context(ctx, sizeof(*p)); 1641 /* p is always non-NULL since countStep() will have been called first */ 1642 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){ 1643 p->n--; 1644 #ifdef SQLITE_DEBUG 1645 p->bInverse = 1; 1646 #endif 1647 } 1648 } 1649 #else 1650 # define countInverse 0 1651 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1652 1653 /* 1654 ** Routines to implement min() and max() aggregate functions. 1655 */ 1656 static void minmaxStep( 1657 sqlite3_context *context, 1658 int NotUsed, 1659 sqlite3_value **argv 1660 ){ 1661 Mem *pArg = (Mem *)argv[0]; 1662 Mem *pBest; 1663 UNUSED_PARAMETER(NotUsed); 1664 1665 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1666 if( !pBest ) return; 1667 1668 if( sqlite3_value_type(pArg)==SQLITE_NULL ){ 1669 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); 1670 }else if( pBest->flags ){ 1671 int max; 1672 int cmp; 1673 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1674 /* This step function is used for both the min() and max() aggregates, 1675 ** the only difference between the two being that the sense of the 1676 ** comparison is inverted. For the max() aggregate, the 1677 ** sqlite3_user_data() function returns (void *)-1. For min() it 1678 ** returns (void *)db, where db is the sqlite3* database pointer. 1679 ** Therefore the next statement sets variable 'max' to 1 for the max() 1680 ** aggregate, or 0 for min(). 1681 */ 1682 max = sqlite3_user_data(context)!=0; 1683 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1684 if( (max && cmp<0) || (!max && cmp>0) ){ 1685 sqlite3VdbeMemCopy(pBest, pArg); 1686 }else{ 1687 sqlite3SkipAccumulatorLoad(context); 1688 } 1689 }else{ 1690 pBest->db = sqlite3_context_db_handle(context); 1691 sqlite3VdbeMemCopy(pBest, pArg); 1692 } 1693 } 1694 static void minMaxValueFinalize(sqlite3_context *context, int bValue){ 1695 sqlite3_value *pRes; 1696 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1697 if( pRes ){ 1698 if( pRes->flags ){ 1699 sqlite3_result_value(context, pRes); 1700 } 1701 if( bValue==0 ) sqlite3VdbeMemRelease(pRes); 1702 } 1703 } 1704 #ifndef SQLITE_OMIT_WINDOWFUNC 1705 static void minMaxValue(sqlite3_context *context){ 1706 minMaxValueFinalize(context, 1); 1707 } 1708 #else 1709 # define minMaxValue 0 1710 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1711 static void minMaxFinalize(sqlite3_context *context){ 1712 minMaxValueFinalize(context, 0); 1713 } 1714 1715 /* 1716 ** group_concat(EXPR, ?SEPARATOR?) 1717 */ 1718 static void groupConcatStep( 1719 sqlite3_context *context, 1720 int argc, 1721 sqlite3_value **argv 1722 ){ 1723 const char *zVal; 1724 StrAccum *pAccum; 1725 const char *zSep; 1726 int nVal, nSep; 1727 assert( argc==1 || argc==2 ); 1728 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1729 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); 1730 1731 if( pAccum ){ 1732 sqlite3 *db = sqlite3_context_db_handle(context); 1733 int firstTerm = pAccum->mxAlloc==0; 1734 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; 1735 if( !firstTerm ){ 1736 if( argc==2 ){ 1737 zSep = (char*)sqlite3_value_text(argv[1]); 1738 nSep = sqlite3_value_bytes(argv[1]); 1739 }else{ 1740 zSep = ","; 1741 nSep = 1; 1742 } 1743 if( zSep ) sqlite3_str_append(pAccum, zSep, nSep); 1744 } 1745 zVal = (char*)sqlite3_value_text(argv[0]); 1746 nVal = sqlite3_value_bytes(argv[0]); 1747 if( zVal ) sqlite3_str_append(pAccum, zVal, nVal); 1748 } 1749 } 1750 #ifndef SQLITE_OMIT_WINDOWFUNC 1751 static void groupConcatInverse( 1752 sqlite3_context *context, 1753 int argc, 1754 sqlite3_value **argv 1755 ){ 1756 int n; 1757 StrAccum *pAccum; 1758 assert( argc==1 || argc==2 ); 1759 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1760 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); 1761 /* pAccum is always non-NULL since groupConcatStep() will have always 1762 ** run frist to initialize it */ 1763 if( ALWAYS(pAccum) ){ 1764 n = sqlite3_value_bytes(argv[0]); 1765 if( argc==2 ){ 1766 n += sqlite3_value_bytes(argv[1]); 1767 }else{ 1768 n++; 1769 } 1770 if( n>=(int)pAccum->nChar ){ 1771 pAccum->nChar = 0; 1772 }else{ 1773 pAccum->nChar -= n; 1774 memmove(pAccum->zText, &pAccum->zText[n], pAccum->nChar); 1775 } 1776 if( pAccum->nChar==0 ) pAccum->mxAlloc = 0; 1777 } 1778 } 1779 #else 1780 # define groupConcatInverse 0 1781 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1782 static void groupConcatFinalize(sqlite3_context *context){ 1783 StrAccum *pAccum; 1784 pAccum = sqlite3_aggregate_context(context, 0); 1785 if( pAccum ){ 1786 if( pAccum->accError==SQLITE_TOOBIG ){ 1787 sqlite3_result_error_toobig(context); 1788 }else if( pAccum->accError==SQLITE_NOMEM ){ 1789 sqlite3_result_error_nomem(context); 1790 }else{ 1791 sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 1792 sqlite3_free); 1793 } 1794 } 1795 } 1796 #ifndef SQLITE_OMIT_WINDOWFUNC 1797 static void groupConcatValue(sqlite3_context *context){ 1798 sqlite3_str *pAccum; 1799 pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0); 1800 if( pAccum ){ 1801 if( pAccum->accError==SQLITE_TOOBIG ){ 1802 sqlite3_result_error_toobig(context); 1803 }else if( pAccum->accError==SQLITE_NOMEM ){ 1804 sqlite3_result_error_nomem(context); 1805 }else{ 1806 const char *zText = sqlite3_str_value(pAccum); 1807 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 1808 } 1809 } 1810 } 1811 #else 1812 # define groupConcatValue 0 1813 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1814 1815 /* 1816 ** This routine does per-connection function registration. Most 1817 ** of the built-in functions above are part of the global function set. 1818 ** This routine only deals with those that are not global. 1819 */ 1820 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ 1821 int rc = sqlite3_overload_function(db, "MATCH", 2); 1822 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1823 if( rc==SQLITE_NOMEM ){ 1824 sqlite3OomFault(db); 1825 } 1826 } 1827 1828 /* 1829 ** Re-register the built-in LIKE functions. The caseSensitive 1830 ** parameter determines whether or not the LIKE operator is case 1831 ** sensitive. 1832 */ 1833 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1834 struct compareInfo *pInfo; 1835 int flags; 1836 if( caseSensitive ){ 1837 pInfo = (struct compareInfo*)&likeInfoAlt; 1838 flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE; 1839 }else{ 1840 pInfo = (struct compareInfo*)&likeInfoNorm; 1841 flags = SQLITE_FUNC_LIKE; 1842 } 1843 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 1844 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 1845 sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags; 1846 sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags; 1847 } 1848 1849 /* 1850 ** pExpr points to an expression which implements a function. If 1851 ** it is appropriate to apply the LIKE optimization to that function 1852 ** then set aWc[0] through aWc[2] to the wildcard characters and the 1853 ** escape character and then return TRUE. If the function is not a 1854 ** LIKE-style function then return FALSE. 1855 ** 1856 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE 1857 ** operator if c is a string literal that is exactly one byte in length. 1858 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is 1859 ** no ESCAPE clause. 1860 ** 1861 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for 1862 ** the function (default for LIKE). If the function makes the distinction 1863 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to 1864 ** false. 1865 */ 1866 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1867 FuncDef *pDef; 1868 int nExpr; 1869 assert( pExpr!=0 ); 1870 assert( pExpr->op==TK_FUNCTION ); 1871 if( !pExpr->x.pList ){ 1872 return 0; 1873 } 1874 assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); 1875 nExpr = pExpr->x.pList->nExpr; 1876 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); 1877 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1878 if( pDef==0 ) return 0; 1879 #endif 1880 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ 1881 return 0; 1882 } 1883 1884 /* The memcpy() statement assumes that the wildcard characters are 1885 ** the first three statements in the compareInfo structure. The 1886 ** asserts() that follow verify that assumption 1887 */ 1888 memcpy(aWc, pDef->pUserData, 3); 1889 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1890 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1891 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1892 1893 if( nExpr<3 ){ 1894 aWc[3] = 0; 1895 }else{ 1896 Expr *pEscape = pExpr->x.pList->a[2].pExpr; 1897 char *zEscape; 1898 if( pEscape->op!=TK_STRING ) return 0; 1899 zEscape = pEscape->u.zToken; 1900 if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; 1901 if( zEscape[0]==aWc[0] ) return 0; 1902 if( zEscape[0]==aWc[1] ) return 0; 1903 aWc[3] = zEscape[0]; 1904 } 1905 1906 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; 1907 return 1; 1908 } 1909 1910 /* Mathematical Constants */ 1911 #ifndef M_PI 1912 # define M_PI 3.141592653589793238462643383279502884 1913 #endif 1914 #ifndef M_LN10 1915 # define M_LN10 2.302585092994045684017991454684364208 1916 #endif 1917 #ifndef M_LN2 1918 # define M_LN2 0.693147180559945309417232121458176568 1919 #endif 1920 1921 1922 /* Extra math functions that require linking with -lm 1923 */ 1924 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS 1925 /* 1926 ** Implementation SQL functions: 1927 ** 1928 ** ceil(X) 1929 ** ceiling(X) 1930 ** floor(X) 1931 ** 1932 ** The sqlite3_user_data() pointer is a pointer to the libm implementation 1933 ** of the underlying C function. 1934 */ 1935 static void ceilingFunc( 1936 sqlite3_context *context, 1937 int argc, 1938 sqlite3_value **argv 1939 ){ 1940 assert( argc==1 ); 1941 switch( sqlite3_value_numeric_type(argv[0]) ){ 1942 case SQLITE_INTEGER: { 1943 sqlite3_result_int64(context, sqlite3_value_int64(argv[0])); 1944 break; 1945 } 1946 case SQLITE_FLOAT: { 1947 double (*x)(double) = (double(*)(double))sqlite3_user_data(context); 1948 sqlite3_result_double(context, x(sqlite3_value_double(argv[0]))); 1949 break; 1950 } 1951 default: { 1952 break; 1953 } 1954 } 1955 } 1956 1957 /* 1958 ** On some systems, ceil() and floor() are intrinsic function. You are 1959 ** unable to take a pointer to these functions. Hence, we here wrap them 1960 ** in our own actual functions. 1961 */ 1962 static double xCeil(double x){ return ceil(x); } 1963 static double xFloor(double x){ return floor(x); } 1964 1965 /* 1966 ** Implementation of SQL functions: 1967 ** 1968 ** ln(X) - natural logarithm 1969 ** log(X) - log X base 10 1970 ** log10(X) - log X base 10 1971 ** log(B,X) - log X base B 1972 */ 1973 static void logFunc( 1974 sqlite3_context *context, 1975 int argc, 1976 sqlite3_value **argv 1977 ){ 1978 double x, b, ans; 1979 assert( argc==1 || argc==2 ); 1980 switch( sqlite3_value_numeric_type(argv[0]) ){ 1981 case SQLITE_INTEGER: 1982 case SQLITE_FLOAT: 1983 x = sqlite3_value_double(argv[0]); 1984 if( x<=0.0 ) return; 1985 break; 1986 default: 1987 return; 1988 } 1989 if( argc==2 ){ 1990 switch( sqlite3_value_numeric_type(argv[0]) ){ 1991 case SQLITE_INTEGER: 1992 case SQLITE_FLOAT: 1993 b = log(x); 1994 if( b<=0.0 ) return; 1995 x = sqlite3_value_double(argv[1]); 1996 if( x<=0.0 ) return; 1997 break; 1998 default: 1999 return; 2000 } 2001 ans = log(x)/b; 2002 }else{ 2003 ans = log(x); 2004 switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){ 2005 case 1: 2006 /* Convert from natural logarithm to log base 10 */ 2007 ans *= 1.0/M_LN10; 2008 break; 2009 case 2: 2010 /* Convert from natural logarithm to log base 2 */ 2011 ans *= 1.0/M_LN2; 2012 break; 2013 default: 2014 break; 2015 } 2016 } 2017 sqlite3_result_double(context, ans); 2018 } 2019 2020 /* 2021 ** Functions to converts degrees to radians and radians to degrees. 2022 */ 2023 static double degToRad(double x){ return x*(M_PI/180.0); } 2024 static double radToDeg(double x){ return x*(180.0/M_PI); } 2025 2026 /* 2027 ** Implementation of 1-argument SQL math functions: 2028 ** 2029 ** exp(X) - Compute e to the X-th power 2030 */ 2031 static void math1Func( 2032 sqlite3_context *context, 2033 int argc, 2034 sqlite3_value **argv 2035 ){ 2036 int type0; 2037 double v0, ans; 2038 double (*x)(double); 2039 assert( argc==1 ); 2040 type0 = sqlite3_value_numeric_type(argv[0]); 2041 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2042 v0 = sqlite3_value_double(argv[0]); 2043 x = (double(*)(double))sqlite3_user_data(context); 2044 ans = x(v0); 2045 sqlite3_result_double(context, ans); 2046 } 2047 2048 /* 2049 ** Implementation of 2-argument SQL math functions: 2050 ** 2051 ** power(X,Y) - Compute X to the Y-th power 2052 */ 2053 static void math2Func( 2054 sqlite3_context *context, 2055 int argc, 2056 sqlite3_value **argv 2057 ){ 2058 int type0, type1; 2059 double v0, v1, ans; 2060 double (*x)(double,double); 2061 assert( argc==2 ); 2062 type0 = sqlite3_value_numeric_type(argv[0]); 2063 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2064 type1 = sqlite3_value_numeric_type(argv[1]); 2065 if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return; 2066 v0 = sqlite3_value_double(argv[0]); 2067 v1 = sqlite3_value_double(argv[1]); 2068 x = (double(*)(double,double))sqlite3_user_data(context); 2069 ans = x(v0, v1); 2070 sqlite3_result_double(context, ans); 2071 } 2072 2073 /* 2074 ** Implementation of 2-argument SQL math functions: 2075 ** 2076 ** power(X,Y) - Compute X to the Y-th power 2077 */ 2078 static void piFunc( 2079 sqlite3_context *context, 2080 int argc, 2081 sqlite3_value **argv 2082 ){ 2083 assert( argc==0 ); 2084 sqlite3_result_double(context, M_PI); 2085 } 2086 2087 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ 2088 2089 /* 2090 ** Implementation of sign(X) function. 2091 */ 2092 static void signFunc( 2093 sqlite3_context *context, 2094 int argc, 2095 sqlite3_value **argv 2096 ){ 2097 int type0; 2098 double x; 2099 UNUSED_PARAMETER(argc); 2100 assert( argc==1 ); 2101 type0 = sqlite3_value_numeric_type(argv[0]); 2102 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2103 x = sqlite3_value_double(argv[0]); 2104 sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0); 2105 } 2106 2107 /* 2108 ** All of the FuncDef structures in the aBuiltinFunc[] array above 2109 ** to the global function hash table. This occurs at start-time (as 2110 ** a consequence of calling sqlite3_initialize()). 2111 ** 2112 ** After this routine runs 2113 */ 2114 void sqlite3RegisterBuiltinFunctions(void){ 2115 /* 2116 ** The following array holds FuncDef structures for all of the functions 2117 ** defined in this file. 2118 ** 2119 ** The array cannot be constant since changes are made to the 2120 ** FuncDef.pHash elements at start-time. The elements of this array 2121 ** are read-only after initialization is complete. 2122 ** 2123 ** For peak efficiency, put the most frequently used function last. 2124 */ 2125 static FuncDef aBuiltinFunc[] = { 2126 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/ 2127 TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0), 2128 TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0), 2129 TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0), 2130 #ifdef SQLITE_DEBUG 2131 TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), 2132 #endif 2133 /***** Regular functions *****/ 2134 #ifdef SQLITE_SOUNDEX 2135 FUNCTION(soundex, 1, 0, 0, soundexFunc ), 2136 #endif 2137 #ifndef SQLITE_OMIT_LOAD_EXTENSION 2138 SFUNCTION(load_extension, 1, 0, 0, loadExt ), 2139 SFUNCTION(load_extension, 2, 0, 0, loadExt ), 2140 #endif 2141 #if SQLITE_USER_AUTHENTICATION 2142 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), 2143 #endif 2144 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 2145 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), 2146 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), 2147 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 2148 INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2149 INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2150 INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2151 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC 2152 FUNCTION2(sqlite_offset, 1, 0, 0, noopFunc, SQLITE_FUNC_OFFSET| 2153 SQLITE_FUNC_TYPEOF), 2154 #endif 2155 FUNCTION(ltrim, 1, 1, 0, trimFunc ), 2156 FUNCTION(ltrim, 2, 1, 0, trimFunc ), 2157 FUNCTION(rtrim, 1, 2, 0, trimFunc ), 2158 FUNCTION(rtrim, 2, 2, 0, trimFunc ), 2159 FUNCTION(trim, 1, 3, 0, trimFunc ), 2160 FUNCTION(trim, 2, 3, 0, trimFunc ), 2161 FUNCTION(min, -1, 0, 1, minmaxFunc ), 2162 FUNCTION(min, 0, 0, 1, 0 ), 2163 WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 2164 SQLITE_FUNC_MINMAX ), 2165 FUNCTION(max, -1, 1, 1, minmaxFunc ), 2166 FUNCTION(max, 0, 1, 1, 0 ), 2167 WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 2168 SQLITE_FUNC_MINMAX ), 2169 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), 2170 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), 2171 FUNCTION(instr, 2, 0, 0, instrFunc ), 2172 FUNCTION(printf, -1, 0, 0, printfFunc ), 2173 FUNCTION(unicode, 1, 0, 0, unicodeFunc ), 2174 FUNCTION(char, -1, 0, 0, charFunc ), 2175 FUNCTION(abs, 1, 0, 0, absFunc ), 2176 #ifndef SQLITE_OMIT_FLOATING_POINT 2177 FUNCTION(round, 1, 0, 0, roundFunc ), 2178 FUNCTION(round, 2, 0, 0, roundFunc ), 2179 #endif 2180 FUNCTION(upper, 1, 0, 0, upperFunc ), 2181 FUNCTION(lower, 1, 0, 0, lowerFunc ), 2182 FUNCTION(hex, 1, 0, 0, hexFunc ), 2183 INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ), 2184 VFUNCTION(random, 0, 0, 0, randomFunc ), 2185 VFUNCTION(randomblob, 1, 0, 0, randomBlob ), 2186 FUNCTION(nullif, 2, 0, 1, nullifFunc ), 2187 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), 2188 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), 2189 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), 2190 FUNCTION(quote, 1, 0, 0, quoteFunc ), 2191 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), 2192 VFUNCTION(changes, 0, 0, 0, changes ), 2193 VFUNCTION(total_changes, 0, 0, 0, total_changes ), 2194 FUNCTION(replace, 3, 0, 0, replaceFunc ), 2195 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), 2196 FUNCTION(substr, 2, 0, 0, substrFunc ), 2197 FUNCTION(substr, 3, 0, 0, substrFunc ), 2198 FUNCTION(substring, 2, 0, 0, substrFunc ), 2199 FUNCTION(substring, 3, 0, 0, substrFunc ), 2200 WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0), 2201 WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), 2202 WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), 2203 WAGGREGATE(count, 0,0,0, countStep, 2204 countFinalize, countFinalize, countInverse, SQLITE_FUNC_COUNT ), 2205 WAGGREGATE(count, 1,0,0, countStep, 2206 countFinalize, countFinalize, countInverse, 0 ), 2207 WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep, 2208 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 2209 WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep, 2210 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 2211 2212 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2213 #ifdef SQLITE_CASE_SENSITIVE_LIKE 2214 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2215 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2216 #else 2217 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), 2218 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), 2219 #endif 2220 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 2221 FUNCTION(unknown, -1, 0, 0, unknownFunc ), 2222 #endif 2223 FUNCTION(coalesce, 1, 0, 0, 0 ), 2224 FUNCTION(coalesce, 0, 0, 0, 0 ), 2225 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS 2226 MFUNCTION(ceil, 1, xCeil, ceilingFunc ), 2227 MFUNCTION(ceiling, 1, xCeil, ceilingFunc ), 2228 MFUNCTION(floor, 1, xFloor, ceilingFunc ), 2229 #if SQLITE_HAVE_C99_MATH_FUNCS 2230 MFUNCTION(trunc, 1, trunc, ceilingFunc ), 2231 #endif 2232 FUNCTION(ln, 1, 0, 0, logFunc ), 2233 FUNCTION(log, 1, 1, 0, logFunc ), 2234 FUNCTION(log10, 1, 1, 0, logFunc ), 2235 FUNCTION(log2, 1, 2, 0, logFunc ), 2236 FUNCTION(log, 2, 0, 0, logFunc ), 2237 MFUNCTION(exp, 1, exp, math1Func ), 2238 MFUNCTION(pow, 2, pow, math2Func ), 2239 MFUNCTION(power, 2, pow, math2Func ), 2240 MFUNCTION(mod, 2, fmod, math2Func ), 2241 MFUNCTION(acos, 1, acos, math1Func ), 2242 MFUNCTION(asin, 1, asin, math1Func ), 2243 MFUNCTION(atan, 1, atan, math1Func ), 2244 MFUNCTION(atan2, 2, atan2, math2Func ), 2245 MFUNCTION(cos, 1, cos, math1Func ), 2246 MFUNCTION(sin, 1, sin, math1Func ), 2247 MFUNCTION(tan, 1, tan, math1Func ), 2248 MFUNCTION(cosh, 1, cosh, math1Func ), 2249 MFUNCTION(sinh, 1, sinh, math1Func ), 2250 MFUNCTION(tanh, 1, tanh, math1Func ), 2251 #if SQLITE_HAVE_C99_MATH_FUNCS 2252 MFUNCTION(acosh, 1, acosh, math1Func ), 2253 MFUNCTION(asinh, 1, asinh, math1Func ), 2254 MFUNCTION(atanh, 1, atanh, math1Func ), 2255 #endif 2256 MFUNCTION(sqrt, 1, sqrt, math1Func ), 2257 MFUNCTION(radians, 1, degToRad, math1Func ), 2258 MFUNCTION(degrees, 1, radToDeg, math1Func ), 2259 FUNCTION(pi, 0, 0, 0, piFunc ), 2260 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ 2261 FUNCTION(sign, 1, 0, 0, signFunc ), 2262 INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ), 2263 INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ), 2264 }; 2265 #ifndef SQLITE_OMIT_ALTERTABLE 2266 sqlite3AlterFunctions(); 2267 #endif 2268 sqlite3WindowFunctions(); 2269 sqlite3RegisterDateTimeFunctions(); 2270 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); 2271 2272 #if 0 /* Enable to print out how the built-in functions are hashed */ 2273 { 2274 int i; 2275 FuncDef *p; 2276 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){ 2277 printf("FUNC-HASH %02d:", i); 2278 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){ 2279 int n = sqlite3Strlen30(p->zName); 2280 int h = p->zName[0] + n; 2281 printf(" %s(%d)", p->zName, h); 2282 } 2283 printf("\n"); 2284 } 2285 } 2286 #endif 2287 } 2288