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