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