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