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