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