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