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