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