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