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