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