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-language implementations for many of the SQL 13 ** functions of SQLite. (Some function, and in particular the date and 14 ** time functions, are implemented separately.) 15 */ 16 #include "sqliteInt.h" 17 #include <stdlib.h> 18 #include <assert.h> 19 #include "vdbeInt.h" 20 21 /* 22 ** Return the collating function associated with a function. 23 */ 24 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ 25 VdbeOp *pOp; 26 assert( context->pVdbe!=0 ); 27 pOp = &context->pVdbe->aOp[context->iOp-1]; 28 assert( pOp->opcode==OP_CollSeq ); 29 assert( pOp->p4type==P4_COLLSEQ ); 30 return pOp->p4.pColl; 31 } 32 33 /* 34 ** Indicate that the accumulator load should be skipped on this 35 ** iteration of the aggregate loop. 36 */ 37 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){ 38 context->skipFlag = 1; 39 } 40 41 /* 42 ** Implementation of the non-aggregate min() and max() functions 43 */ 44 static void minmaxFunc( 45 sqlite3_context *context, 46 int argc, 47 sqlite3_value **argv 48 ){ 49 int i; 50 int mask; /* 0 for min() or 0xffffffff for max() */ 51 int iBest; 52 CollSeq *pColl; 53 54 assert( argc>1 ); 55 mask = sqlite3_user_data(context)==0 ? 0 : -1; 56 pColl = sqlite3GetFuncCollSeq(context); 57 assert( pColl ); 58 assert( mask==-1 || mask==0 ); 59 iBest = 0; 60 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 61 for(i=1; i<argc; i++){ 62 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return; 63 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){ 64 testcase( mask==0 ); 65 iBest = i; 66 } 67 } 68 sqlite3_result_value(context, argv[iBest]); 69 } 70 71 /* 72 ** Return the type of the argument. 73 */ 74 static void typeofFunc( 75 sqlite3_context *context, 76 int NotUsed, 77 sqlite3_value **argv 78 ){ 79 const char *z = 0; 80 UNUSED_PARAMETER(NotUsed); 81 switch( sqlite3_value_type(argv[0]) ){ 82 case SQLITE_INTEGER: z = "integer"; break; 83 case SQLITE_TEXT: z = "text"; break; 84 case SQLITE_FLOAT: z = "real"; break; 85 case SQLITE_BLOB: z = "blob"; break; 86 default: z = "null"; break; 87 } 88 sqlite3_result_text(context, z, -1, SQLITE_STATIC); 89 } 90 91 92 /* 93 ** Implementation of the length() function 94 */ 95 static void lengthFunc( 96 sqlite3_context *context, 97 int argc, 98 sqlite3_value **argv 99 ){ 100 int len; 101 102 assert( argc==1 ); 103 UNUSED_PARAMETER(argc); 104 switch( sqlite3_value_type(argv[0]) ){ 105 case SQLITE_BLOB: 106 case SQLITE_INTEGER: 107 case SQLITE_FLOAT: { 108 sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); 109 break; 110 } 111 case SQLITE_TEXT: { 112 const unsigned char *z = sqlite3_value_text(argv[0]); 113 if( z==0 ) return; 114 len = 0; 115 while( *z ){ 116 len++; 117 SQLITE_SKIP_UTF8(z); 118 } 119 sqlite3_result_int(context, len); 120 break; 121 } 122 default: { 123 sqlite3_result_null(context); 124 break; 125 } 126 } 127 } 128 129 /* 130 ** Implementation of the abs() function. 131 ** 132 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of 133 ** the numeric argument X. 134 */ 135 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 136 assert( argc==1 ); 137 UNUSED_PARAMETER(argc); 138 switch( sqlite3_value_type(argv[0]) ){ 139 case SQLITE_INTEGER: { 140 i64 iVal = sqlite3_value_int64(argv[0]); 141 if( iVal<0 ){ 142 if( iVal==SMALLEST_INT64 ){ 143 /* IMP: R-31676-45509 If X is the integer -9223372036854775808 144 ** then abs(X) throws an integer overflow error since there is no 145 ** equivalent positive 64-bit two complement value. */ 146 sqlite3_result_error(context, "integer overflow", -1); 147 return; 148 } 149 iVal = -iVal; 150 } 151 sqlite3_result_int64(context, iVal); 152 break; 153 } 154 case SQLITE_NULL: { 155 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */ 156 sqlite3_result_null(context); 157 break; 158 } 159 default: { 160 /* Because sqlite3_value_double() returns 0.0 if the argument is not 161 ** something that can be converted into a number, we have: 162 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob 163 ** that cannot be converted to a numeric value. 164 */ 165 double rVal = sqlite3_value_double(argv[0]); 166 if( rVal<0 ) rVal = -rVal; 167 sqlite3_result_double(context, rVal); 168 break; 169 } 170 } 171 } 172 173 /* 174 ** Implementation of the instr() function. 175 ** 176 ** instr(haystack,needle) finds the first occurrence of needle 177 ** in haystack and returns the number of previous characters plus 1, 178 ** or 0 if needle does not occur within haystack. 179 ** 180 ** If both haystack and needle are BLOBs, then the result is one more than 181 ** the number of bytes in haystack prior to the first occurrence of needle, 182 ** or 0 if needle never occurs in haystack. 183 */ 184 static void instrFunc( 185 sqlite3_context *context, 186 int argc, 187 sqlite3_value **argv 188 ){ 189 const unsigned char *zHaystack; 190 const unsigned char *zNeedle; 191 int nHaystack; 192 int nNeedle; 193 int typeHaystack, typeNeedle; 194 int N = 1; 195 int isText; 196 197 UNUSED_PARAMETER(argc); 198 typeHaystack = sqlite3_value_type(argv[0]); 199 typeNeedle = sqlite3_value_type(argv[1]); 200 if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return; 201 nHaystack = sqlite3_value_bytes(argv[0]); 202 nNeedle = sqlite3_value_bytes(argv[1]); 203 if( nNeedle>0 ){ 204 if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){ 205 zHaystack = sqlite3_value_blob(argv[0]); 206 zNeedle = sqlite3_value_blob(argv[1]); 207 isText = 0; 208 }else{ 209 zHaystack = sqlite3_value_text(argv[0]); 210 zNeedle = sqlite3_value_text(argv[1]); 211 isText = 1; 212 } 213 if( zNeedle==0 || (nHaystack && zHaystack==0) ) return; 214 while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){ 215 N++; 216 do{ 217 nHaystack--; 218 zHaystack++; 219 }while( isText && (zHaystack[0]&0xc0)==0x80 ); 220 } 221 if( nNeedle>nHaystack ) N = 0; 222 } 223 sqlite3_result_int(context, N); 224 } 225 226 /* 227 ** Implementation of the printf() function. 228 */ 229 static void printfFunc( 230 sqlite3_context *context, 231 int argc, 232 sqlite3_value **argv 233 ){ 234 PrintfArguments x; 235 StrAccum str; 236 const char *zFormat; 237 int n; 238 sqlite3 *db = sqlite3_context_db_handle(context); 239 240 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 241 x.nArg = argc-1; 242 x.nUsed = 0; 243 x.apArg = argv+1; 244 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); 245 str.printfFlags = SQLITE_PRINTF_SQLFUNC; 246 sqlite3XPrintf(&str, zFormat, &x); 247 n = str.nChar; 248 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, 249 SQLITE_DYNAMIC); 250 } 251 } 252 253 /* 254 ** Implementation of the substr() function. 255 ** 256 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. 257 ** p1 is 1-indexed. So substr(x,1,1) returns the first character 258 ** of x. If x is text, then we actually count UTF-8 characters. 259 ** If x is a blob, then we count bytes. 260 ** 261 ** If p1 is negative, then we begin abs(p1) from the end of x[]. 262 ** 263 ** If p2 is negative, return the p2 characters preceding p1. 264 */ 265 static void substrFunc( 266 sqlite3_context *context, 267 int argc, 268 sqlite3_value **argv 269 ){ 270 const unsigned char *z; 271 const unsigned char *z2; 272 int len; 273 int p0type; 274 i64 p1, p2; 275 int negP2 = 0; 276 277 assert( argc==3 || argc==2 ); 278 if( sqlite3_value_type(argv[1])==SQLITE_NULL 279 || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL) 280 ){ 281 return; 282 } 283 p0type = sqlite3_value_type(argv[0]); 284 p1 = sqlite3_value_int(argv[1]); 285 if( p0type==SQLITE_BLOB ){ 286 len = sqlite3_value_bytes(argv[0]); 287 z = sqlite3_value_blob(argv[0]); 288 if( z==0 ) return; 289 assert( len==sqlite3_value_bytes(argv[0]) ); 290 }else{ 291 z = sqlite3_value_text(argv[0]); 292 if( z==0 ) return; 293 len = 0; 294 if( p1<0 ){ 295 for(z2=z; *z2; len++){ 296 SQLITE_SKIP_UTF8(z2); 297 } 298 } 299 } 300 #ifdef SQLITE_SUBSTR_COMPATIBILITY 301 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as 302 ** as substr(X,1,N) - it returns the first N characters of X. This 303 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8] 304 ** from 2009-02-02 for compatibility of applications that exploited the 305 ** old buggy behavior. */ 306 if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */ 307 #endif 308 if( argc==3 ){ 309 p2 = sqlite3_value_int(argv[2]); 310 if( p2<0 ){ 311 p2 = -p2; 312 negP2 = 1; 313 } 314 }else{ 315 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH]; 316 } 317 if( p1<0 ){ 318 p1 += len; 319 if( p1<0 ){ 320 p2 += p1; 321 if( p2<0 ) p2 = 0; 322 p1 = 0; 323 } 324 }else if( p1>0 ){ 325 p1--; 326 }else if( p2>0 ){ 327 p2--; 328 } 329 if( negP2 ){ 330 p1 -= p2; 331 if( p1<0 ){ 332 p2 += p1; 333 p1 = 0; 334 } 335 } 336 assert( p1>=0 && p2>=0 ); 337 if( p0type!=SQLITE_BLOB ){ 338 while( *z && p1 ){ 339 SQLITE_SKIP_UTF8(z); 340 p1--; 341 } 342 for(z2=z; *z2 && p2; p2--){ 343 SQLITE_SKIP_UTF8(z2); 344 } 345 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT, 346 SQLITE_UTF8); 347 }else{ 348 if( p1+p2>len ){ 349 p2 = len-p1; 350 if( p2<0 ) p2 = 0; 351 } 352 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT); 353 } 354 } 355 356 /* 357 ** Implementation of the round() function 358 */ 359 #ifndef SQLITE_OMIT_FLOATING_POINT 360 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 361 int n = 0; 362 double r; 363 char *zBuf; 364 assert( argc==1 || argc==2 ); 365 if( argc==2 ){ 366 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; 367 n = sqlite3_value_int(argv[1]); 368 if( n>30 ) n = 30; 369 if( n<0 ) n = 0; 370 } 371 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 372 r = sqlite3_value_double(argv[0]); 373 /* If Y==0 and X will fit in a 64-bit int, 374 ** handle the rounding directly, 375 ** otherwise use printf. 376 */ 377 if( n==0 && r>=0 && r<LARGEST_INT64-1 ){ 378 r = (double)((sqlite_int64)(r+0.5)); 379 }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){ 380 r = -(double)((sqlite_int64)((-r)+0.5)); 381 }else{ 382 zBuf = sqlite3_mprintf("%.*f",n,r); 383 if( zBuf==0 ){ 384 sqlite3_result_error_nomem(context); 385 return; 386 } 387 sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8); 388 sqlite3_free(zBuf); 389 } 390 sqlite3_result_double(context, r); 391 } 392 #endif 393 394 /* 395 ** Allocate nByte bytes of space using sqlite3Malloc(). If the 396 ** allocation fails, call sqlite3_result_error_nomem() to notify 397 ** the database handle that malloc() has failed and return NULL. 398 ** If nByte is larger than the maximum string or blob length, then 399 ** raise an SQLITE_TOOBIG exception and return NULL. 400 */ 401 static void *contextMalloc(sqlite3_context *context, i64 nByte){ 402 char *z; 403 sqlite3 *db = sqlite3_context_db_handle(context); 404 assert( nByte>0 ); 405 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] ); 406 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); 407 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 408 sqlite3_result_error_toobig(context); 409 z = 0; 410 }else{ 411 z = sqlite3Malloc(nByte); 412 if( !z ){ 413 sqlite3_result_error_nomem(context); 414 } 415 } 416 return z; 417 } 418 419 /* 420 ** Implementation of the upper() and lower() SQL functions. 421 */ 422 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 423 char *z1; 424 const char *z2; 425 int i, n; 426 UNUSED_PARAMETER(argc); 427 z2 = (char*)sqlite3_value_text(argv[0]); 428 n = sqlite3_value_bytes(argv[0]); 429 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 430 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 431 if( z2 ){ 432 z1 = contextMalloc(context, ((i64)n)+1); 433 if( z1 ){ 434 for(i=0; i<n; i++){ 435 z1[i] = (char)sqlite3Toupper(z2[i]); 436 } 437 sqlite3_result_text(context, z1, n, sqlite3_free); 438 } 439 } 440 } 441 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 442 char *z1; 443 const char *z2; 444 int i, n; 445 UNUSED_PARAMETER(argc); 446 z2 = (char*)sqlite3_value_text(argv[0]); 447 n = sqlite3_value_bytes(argv[0]); 448 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 449 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 450 if( z2 ){ 451 z1 = contextMalloc(context, ((i64)n)+1); 452 if( z1 ){ 453 for(i=0; i<n; i++){ 454 z1[i] = sqlite3Tolower(z2[i]); 455 } 456 sqlite3_result_text(context, z1, n, sqlite3_free); 457 } 458 } 459 } 460 461 /* 462 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented 463 ** as VDBE code so that unused argument values do not have to be computed. 464 ** However, we still need some kind of function implementation for this 465 ** routines in the function table. The noopFunc macro provides this. 466 ** noopFunc will never be called so it doesn't matter what the implementation 467 ** is. We might as well use the "version()" function as a substitute. 468 */ 469 #define noopFunc versionFunc /* Substitute function - never called */ 470 471 /* 472 ** Implementation of random(). Return a random integer. 473 */ 474 static void randomFunc( 475 sqlite3_context *context, 476 int NotUsed, 477 sqlite3_value **NotUsed2 478 ){ 479 sqlite_int64 r; 480 UNUSED_PARAMETER2(NotUsed, NotUsed2); 481 sqlite3_randomness(sizeof(r), &r); 482 if( r<0 ){ 483 /* We need to prevent a random number of 0x8000000000000000 484 ** (or -9223372036854775808) since when you do abs() of that 485 ** number of you get the same value back again. To do this 486 ** in a way that is testable, mask the sign bit off of negative 487 ** values, resulting in a positive value. Then take the 488 ** 2s complement of that positive value. The end result can 489 ** therefore be no less than -9223372036854775807. 490 */ 491 r = -(r & LARGEST_INT64); 492 } 493 sqlite3_result_int64(context, r); 494 } 495 496 /* 497 ** Implementation of randomblob(N). Return a random blob 498 ** that is N bytes long. 499 */ 500 static void randomBlob( 501 sqlite3_context *context, 502 int argc, 503 sqlite3_value **argv 504 ){ 505 int n; 506 unsigned char *p; 507 assert( argc==1 ); 508 UNUSED_PARAMETER(argc); 509 n = sqlite3_value_int(argv[0]); 510 if( n<1 ){ 511 n = 1; 512 } 513 p = contextMalloc(context, n); 514 if( p ){ 515 sqlite3_randomness(n, p); 516 sqlite3_result_blob(context, (char*)p, n, sqlite3_free); 517 } 518 } 519 520 /* 521 ** Implementation of the last_insert_rowid() SQL function. The return 522 ** value is the same as the sqlite3_last_insert_rowid() API function. 523 */ 524 static void last_insert_rowid( 525 sqlite3_context *context, 526 int NotUsed, 527 sqlite3_value **NotUsed2 528 ){ 529 sqlite3 *db = sqlite3_context_db_handle(context); 530 UNUSED_PARAMETER2(NotUsed, NotUsed2); 531 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a 532 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface 533 ** function. */ 534 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db)); 535 } 536 537 /* 538 ** Implementation of the changes() SQL function. 539 ** 540 ** IMP: R-62073-11209 The changes() SQL function is a wrapper 541 ** around the sqlite3_changes() C/C++ function and hence follows the same 542 ** rules for counting changes. 543 */ 544 static void changes( 545 sqlite3_context *context, 546 int NotUsed, 547 sqlite3_value **NotUsed2 548 ){ 549 sqlite3 *db = sqlite3_context_db_handle(context); 550 UNUSED_PARAMETER2(NotUsed, NotUsed2); 551 sqlite3_result_int(context, sqlite3_changes(db)); 552 } 553 554 /* 555 ** Implementation of the total_changes() SQL function. The return value is 556 ** the same as the sqlite3_total_changes() API function. 557 */ 558 static void total_changes( 559 sqlite3_context *context, 560 int NotUsed, 561 sqlite3_value **NotUsed2 562 ){ 563 sqlite3 *db = sqlite3_context_db_handle(context); 564 UNUSED_PARAMETER2(NotUsed, NotUsed2); 565 /* IMP: R-52756-41993 This function is a wrapper around the 566 ** sqlite3_total_changes() C/C++ interface. */ 567 sqlite3_result_int(context, sqlite3_total_changes(db)); 568 } 569 570 /* 571 ** A structure defining how to do GLOB-style comparisons. 572 */ 573 struct compareInfo { 574 u8 matchAll; /* "*" or "%" */ 575 u8 matchOne; /* "?" or "_" */ 576 u8 matchSet; /* "[" or 0 */ 577 u8 noCase; /* true to ignore case differences */ 578 }; 579 580 /* 581 ** For LIKE and GLOB matching on EBCDIC machines, assume that every 582 ** character is exactly one byte in size. Also, provde the Utf8Read() 583 ** macro for fast reading of the next character in the common case where 584 ** the next character is ASCII. 585 */ 586 #if defined(SQLITE_EBCDIC) 587 # define sqlite3Utf8Read(A) (*((*A)++)) 588 # define Utf8Read(A) (*(A++)) 589 #else 590 # define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A)) 591 #endif 592 593 static const struct compareInfo globInfo = { '*', '?', '[', 0 }; 594 /* The correct SQL-92 behavior is for the LIKE operator to ignore 595 ** case. Thus 'a' LIKE 'A' would be true. */ 596 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }; 597 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator 598 ** is case sensitive causing 'a' LIKE 'A' to be false */ 599 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }; 600 601 /* 602 ** Possible error returns from patternMatch() 603 */ 604 #define SQLITE_MATCH 0 605 #define SQLITE_NOMATCH 1 606 #define SQLITE_NOWILDCARDMATCH 2 607 608 /* 609 ** Compare two UTF-8 strings for equality where the first string is 610 ** a GLOB or LIKE expression. Return values: 611 ** 612 ** SQLITE_MATCH: Match 613 ** SQLITE_NOMATCH: No match 614 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards. 615 ** 616 ** Globbing rules: 617 ** 618 ** '*' Matches any sequence of zero or more characters. 619 ** 620 ** '?' Matches exactly one character. 621 ** 622 ** [...] Matches one character from the enclosed list of 623 ** characters. 624 ** 625 ** [^...] Matches one character not in the enclosed list. 626 ** 627 ** With the [...] and [^...] matching, a ']' character can be included 628 ** in the list by making it the first character after '[' or '^'. A 629 ** range of characters can be specified using '-'. Example: 630 ** "[a-z]" matches any single lower-case letter. To match a '-', make 631 ** it the last character in the list. 632 ** 633 ** Like matching rules: 634 ** 635 ** '%' Matches any sequence of zero or more characters 636 ** 637 *** '_' Matches any one character 638 ** 639 ** Ec Where E is the "esc" character and c is any other 640 ** character, including '%', '_', and esc, match exactly c. 641 ** 642 ** The comments within this routine usually assume glob matching. 643 ** 644 ** This routine is usually quick, but can be N**2 in the worst case. 645 */ 646 static int patternCompare( 647 const u8 *zPattern, /* The glob pattern */ 648 const u8 *zString, /* The string to compare against the glob */ 649 const struct compareInfo *pInfo, /* Information about how to do the compare */ 650 u32 matchOther /* The escape char (LIKE) or '[' (GLOB) */ 651 ){ 652 u32 c, c2; /* Next pattern and input string chars */ 653 u32 matchOne = pInfo->matchOne; /* "?" or "_" */ 654 u32 matchAll = pInfo->matchAll; /* "*" or "%" */ 655 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ 656 const u8 *zEscaped = 0; /* One past the last escaped input char */ 657 658 while( (c = Utf8Read(zPattern))!=0 ){ 659 if( c==matchAll ){ /* Match "*" */ 660 /* Skip over multiple "*" characters in the pattern. If there 661 ** are also "?" characters, skip those as well, but consume a 662 ** single character of the input string for each "?" skipped */ 663 while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){ 664 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ 665 return SQLITE_NOWILDCARDMATCH; 666 } 667 } 668 if( c==0 ){ 669 return SQLITE_MATCH; /* "*" at the end of the pattern matches */ 670 }else if( c==matchOther ){ 671 if( pInfo->matchSet==0 ){ 672 c = sqlite3Utf8Read(&zPattern); 673 if( c==0 ) return SQLITE_NOWILDCARDMATCH; 674 }else{ 675 /* "[...]" immediately follows the "*". We have to do a slow 676 ** recursive search in this case, but it is an unusual case. */ 677 assert( matchOther<0x80 ); /* '[' is a single-byte character */ 678 while( *zString ){ 679 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther); 680 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 681 SQLITE_SKIP_UTF8(zString); 682 } 683 return SQLITE_NOWILDCARDMATCH; 684 } 685 } 686 687 /* At this point variable c contains the first character of the 688 ** pattern string past the "*". Search in the input string for the 689 ** first matching character and recursively continue the match from 690 ** that point. 691 ** 692 ** For a case-insensitive search, set variable cx to be the same as 693 ** c but in the other case and search the input string for either 694 ** c or cx. 695 */ 696 if( c<=0x80 ){ 697 u32 cx; 698 int bMatch; 699 if( noCase ){ 700 cx = sqlite3Toupper(c); 701 c = sqlite3Tolower(c); 702 }else{ 703 cx = c; 704 } 705 while( (c2 = *(zString++))!=0 ){ 706 if( c2!=c && c2!=cx ) continue; 707 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 708 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 709 } 710 }else{ 711 int bMatch; 712 while( (c2 = Utf8Read(zString))!=0 ){ 713 if( c2!=c ) continue; 714 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 715 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 716 } 717 } 718 return SQLITE_NOWILDCARDMATCH; 719 } 720 if( c==matchOther ){ 721 if( pInfo->matchSet==0 ){ 722 c = sqlite3Utf8Read(&zPattern); 723 if( c==0 ) return SQLITE_NOMATCH; 724 zEscaped = zPattern; 725 }else{ 726 u32 prior_c = 0; 727 int seen = 0; 728 int invert = 0; 729 c = sqlite3Utf8Read(&zString); 730 if( c==0 ) return SQLITE_NOMATCH; 731 c2 = sqlite3Utf8Read(&zPattern); 732 if( c2=='^' ){ 733 invert = 1; 734 c2 = sqlite3Utf8Read(&zPattern); 735 } 736 if( c2==']' ){ 737 if( c==']' ) seen = 1; 738 c2 = sqlite3Utf8Read(&zPattern); 739 } 740 while( c2 && c2!=']' ){ 741 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 742 c2 = sqlite3Utf8Read(&zPattern); 743 if( c>=prior_c && c<=c2 ) seen = 1; 744 prior_c = 0; 745 }else{ 746 if( c==c2 ){ 747 seen = 1; 748 } 749 prior_c = c2; 750 } 751 c2 = sqlite3Utf8Read(&zPattern); 752 } 753 if( c2==0 || (seen ^ invert)==0 ){ 754 return SQLITE_NOMATCH; 755 } 756 continue; 757 } 758 } 759 c2 = Utf8Read(zString); 760 if( c==c2 ) continue; 761 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ 762 continue; 763 } 764 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; 765 return SQLITE_NOMATCH; 766 } 767 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; 768 } 769 770 /* 771 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and 772 ** non-zero if there is no match. 773 */ 774 int sqlite3_strglob(const char *zGlobPattern, const char *zString){ 775 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); 776 } 777 778 /* 779 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for 780 ** a miss - like strcmp(). 781 */ 782 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ 783 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); 784 } 785 786 /* 787 ** Count the number of times that the LIKE operator (or GLOB which is 788 ** just a variation of LIKE) gets called. This is used for testing 789 ** only. 790 */ 791 #ifdef SQLITE_TEST 792 int sqlite3_like_count = 0; 793 #endif 794 795 796 /* 797 ** Implementation of the like() SQL function. This function implements 798 ** the build-in LIKE operator. The first argument to the function is the 799 ** pattern and the second argument is the string. So, the SQL statements: 800 ** 801 ** A LIKE B 802 ** 803 ** is implemented as like(B,A). 804 ** 805 ** This same function (with a different compareInfo structure) computes 806 ** the GLOB operator. 807 */ 808 static void likeFunc( 809 sqlite3_context *context, 810 int argc, 811 sqlite3_value **argv 812 ){ 813 const unsigned char *zA, *zB; 814 u32 escape; 815 int nPat; 816 sqlite3 *db = sqlite3_context_db_handle(context); 817 struct compareInfo *pInfo = sqlite3_user_data(context); 818 819 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS 820 if( sqlite3_value_type(argv[0])==SQLITE_BLOB 821 || sqlite3_value_type(argv[1])==SQLITE_BLOB 822 ){ 823 #ifdef SQLITE_TEST 824 sqlite3_like_count++; 825 #endif 826 sqlite3_result_int(context, 0); 827 return; 828 } 829 #endif 830 zB = sqlite3_value_text(argv[0]); 831 zA = sqlite3_value_text(argv[1]); 832 833 /* Limit the length of the LIKE or GLOB pattern to avoid problems 834 ** of deep recursion and N*N behavior in patternCompare(). 835 */ 836 nPat = sqlite3_value_bytes(argv[0]); 837 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); 838 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); 839 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ 840 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 841 return; 842 } 843 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ 844 845 if( argc==3 ){ 846 /* The escape character string must consist of a single UTF-8 character. 847 ** Otherwise, return an error. 848 */ 849 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 850 if( zEsc==0 ) return; 851 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 852 sqlite3_result_error(context, 853 "ESCAPE expression must be a single character", -1); 854 return; 855 } 856 escape = sqlite3Utf8Read(&zEsc); 857 }else{ 858 escape = pInfo->matchSet; 859 } 860 if( zA && zB ){ 861 #ifdef SQLITE_TEST 862 sqlite3_like_count++; 863 #endif 864 sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); 865 } 866 } 867 868 /* 869 ** Implementation of the NULLIF(x,y) function. The result is the first 870 ** argument if the arguments are different. The result is NULL if the 871 ** arguments are equal to each other. 872 */ 873 static void nullifFunc( 874 sqlite3_context *context, 875 int NotUsed, 876 sqlite3_value **argv 877 ){ 878 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 879 UNUSED_PARAMETER(NotUsed); 880 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 881 sqlite3_result_value(context, argv[0]); 882 } 883 } 884 885 /* 886 ** Implementation of the sqlite_version() function. The result is the version 887 ** of the SQLite library that is running. 888 */ 889 static void versionFunc( 890 sqlite3_context *context, 891 int NotUsed, 892 sqlite3_value **NotUsed2 893 ){ 894 UNUSED_PARAMETER2(NotUsed, NotUsed2); 895 /* IMP: R-48699-48617 This function is an SQL wrapper around the 896 ** sqlite3_libversion() C-interface. */ 897 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); 898 } 899 900 /* 901 ** Implementation of the sqlite_source_id() function. The result is a string 902 ** that identifies the particular version of the source code used to build 903 ** SQLite. 904 */ 905 static void sourceidFunc( 906 sqlite3_context *context, 907 int NotUsed, 908 sqlite3_value **NotUsed2 909 ){ 910 UNUSED_PARAMETER2(NotUsed, NotUsed2); 911 /* IMP: R-24470-31136 This function is an SQL wrapper around the 912 ** sqlite3_sourceid() C interface. */ 913 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); 914 } 915 916 /* 917 ** Implementation of the sqlite_log() function. This is a wrapper around 918 ** sqlite3_log(). The return value is NULL. The function exists purely for 919 ** its side-effects. 920 */ 921 static void errlogFunc( 922 sqlite3_context *context, 923 int argc, 924 sqlite3_value **argv 925 ){ 926 UNUSED_PARAMETER(argc); 927 UNUSED_PARAMETER(context); 928 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); 929 } 930 931 /* 932 ** Implementation of the sqlite_compileoption_used() function. 933 ** The result is an integer that identifies if the compiler option 934 ** was used to build SQLite. 935 */ 936 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 937 static void compileoptionusedFunc( 938 sqlite3_context *context, 939 int argc, 940 sqlite3_value **argv 941 ){ 942 const char *zOptName; 943 assert( argc==1 ); 944 UNUSED_PARAMETER(argc); 945 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL 946 ** function is a wrapper around the sqlite3_compileoption_used() C/C++ 947 ** function. 948 */ 949 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 950 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); 951 } 952 } 953 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 954 955 /* 956 ** Implementation of the sqlite_compileoption_get() function. 957 ** The result is a string that identifies the compiler options 958 ** used to build SQLite. 959 */ 960 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 961 static void compileoptiongetFunc( 962 sqlite3_context *context, 963 int argc, 964 sqlite3_value **argv 965 ){ 966 int n; 967 assert( argc==1 ); 968 UNUSED_PARAMETER(argc); 969 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function 970 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. 971 */ 972 n = sqlite3_value_int(argv[0]); 973 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); 974 } 975 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 976 977 /* Array for converting from half-bytes (nybbles) into ASCII hex 978 ** digits. */ 979 static const char hexdigits[] = { 980 '0', '1', '2', '3', '4', '5', '6', '7', 981 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 982 }; 983 984 /* 985 ** Implementation of the QUOTE() function. This function takes a single 986 ** argument. If the argument is numeric, the return value is the same as 987 ** the argument. If the argument is NULL, the return value is the string 988 ** "NULL". Otherwise, the argument is enclosed in single quotes with 989 ** single-quote escapes. 990 */ 991 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 992 assert( argc==1 ); 993 UNUSED_PARAMETER(argc); 994 switch( sqlite3_value_type(argv[0]) ){ 995 case SQLITE_FLOAT: { 996 double r1, r2; 997 char zBuf[50]; 998 r1 = sqlite3_value_double(argv[0]); 999 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); 1000 sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); 1001 if( r1!=r2 ){ 1002 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); 1003 } 1004 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); 1005 break; 1006 } 1007 case SQLITE_INTEGER: { 1008 sqlite3_result_value(context, argv[0]); 1009 break; 1010 } 1011 case SQLITE_BLOB: { 1012 char *zText = 0; 1013 char const *zBlob = sqlite3_value_blob(argv[0]); 1014 int nBlob = sqlite3_value_bytes(argv[0]); 1015 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1016 zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); 1017 if( zText ){ 1018 int i; 1019 for(i=0; i<nBlob; i++){ 1020 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 1021 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 1022 } 1023 zText[(nBlob*2)+2] = '\''; 1024 zText[(nBlob*2)+3] = '\0'; 1025 zText[0] = 'X'; 1026 zText[1] = '\''; 1027 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 1028 sqlite3_free(zText); 1029 } 1030 break; 1031 } 1032 case SQLITE_TEXT: { 1033 int i,j; 1034 u64 n; 1035 const unsigned char *zArg = sqlite3_value_text(argv[0]); 1036 char *z; 1037 1038 if( zArg==0 ) return; 1039 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } 1040 z = contextMalloc(context, ((i64)i)+((i64)n)+3); 1041 if( z ){ 1042 z[0] = '\''; 1043 for(i=0, j=1; zArg[i]; i++){ 1044 z[j++] = zArg[i]; 1045 if( zArg[i]=='\'' ){ 1046 z[j++] = '\''; 1047 } 1048 } 1049 z[j++] = '\''; 1050 z[j] = 0; 1051 sqlite3_result_text(context, z, j, sqlite3_free); 1052 } 1053 break; 1054 } 1055 default: { 1056 assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); 1057 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); 1058 break; 1059 } 1060 } 1061 } 1062 1063 /* 1064 ** The unicode() function. Return the integer unicode code-point value 1065 ** for the first character of the input string. 1066 */ 1067 static void unicodeFunc( 1068 sqlite3_context *context, 1069 int argc, 1070 sqlite3_value **argv 1071 ){ 1072 const unsigned char *z = sqlite3_value_text(argv[0]); 1073 (void)argc; 1074 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); 1075 } 1076 1077 /* 1078 ** The char() function takes zero or more arguments, each of which is 1079 ** an integer. It constructs a string where each character of the string 1080 ** is the unicode character for the corresponding integer argument. 1081 */ 1082 static void charFunc( 1083 sqlite3_context *context, 1084 int argc, 1085 sqlite3_value **argv 1086 ){ 1087 unsigned char *z, *zOut; 1088 int i; 1089 zOut = z = sqlite3_malloc64( argc*4+1 ); 1090 if( z==0 ){ 1091 sqlite3_result_error_nomem(context); 1092 return; 1093 } 1094 for(i=0; i<argc; i++){ 1095 sqlite3_int64 x; 1096 unsigned c; 1097 x = sqlite3_value_int64(argv[i]); 1098 if( x<0 || x>0x10ffff ) x = 0xfffd; 1099 c = (unsigned)(x & 0x1fffff); 1100 if( c<0x00080 ){ 1101 *zOut++ = (u8)(c&0xFF); 1102 }else if( c<0x00800 ){ 1103 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); 1104 *zOut++ = 0x80 + (u8)(c & 0x3F); 1105 }else if( c<0x10000 ){ 1106 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); 1107 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1108 *zOut++ = 0x80 + (u8)(c & 0x3F); 1109 }else{ 1110 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); 1111 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); 1112 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1113 *zOut++ = 0x80 + (u8)(c & 0x3F); 1114 } \ 1115 } 1116 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); 1117 } 1118 1119 /* 1120 ** The hex() function. Interpret the argument as a blob. Return 1121 ** a hexadecimal rendering as text. 1122 */ 1123 static void hexFunc( 1124 sqlite3_context *context, 1125 int argc, 1126 sqlite3_value **argv 1127 ){ 1128 int i, n; 1129 const unsigned char *pBlob; 1130 char *zHex, *z; 1131 assert( argc==1 ); 1132 UNUSED_PARAMETER(argc); 1133 pBlob = sqlite3_value_blob(argv[0]); 1134 n = sqlite3_value_bytes(argv[0]); 1135 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1136 z = zHex = contextMalloc(context, ((i64)n)*2 + 1); 1137 if( zHex ){ 1138 for(i=0; i<n; i++, pBlob++){ 1139 unsigned char c = *pBlob; 1140 *(z++) = hexdigits[(c>>4)&0xf]; 1141 *(z++) = hexdigits[c&0xf]; 1142 } 1143 *z = 0; 1144 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 1145 } 1146 } 1147 1148 /* 1149 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 1150 */ 1151 static void zeroblobFunc( 1152 sqlite3_context *context, 1153 int argc, 1154 sqlite3_value **argv 1155 ){ 1156 i64 n; 1157 int rc; 1158 assert( argc==1 ); 1159 UNUSED_PARAMETER(argc); 1160 n = sqlite3_value_int64(argv[0]); 1161 if( n<0 ) n = 0; 1162 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ 1163 if( rc ){ 1164 sqlite3_result_error_code(context, rc); 1165 } 1166 } 1167 1168 /* 1169 ** The replace() function. Three arguments are all strings: call 1170 ** them A, B, and C. The result is also a string which is derived 1171 ** from A by replacing every occurrence of B with C. The match 1172 ** must be exact. Collating sequences are not used. 1173 */ 1174 static void replaceFunc( 1175 sqlite3_context *context, 1176 int argc, 1177 sqlite3_value **argv 1178 ){ 1179 const unsigned char *zStr; /* The input string A */ 1180 const unsigned char *zPattern; /* The pattern string B */ 1181 const unsigned char *zRep; /* The replacement string C */ 1182 unsigned char *zOut; /* The output */ 1183 int nStr; /* Size of zStr */ 1184 int nPattern; /* Size of zPattern */ 1185 int nRep; /* Size of zRep */ 1186 i64 nOut; /* Maximum size of zOut */ 1187 int loopLimit; /* Last zStr[] that might match zPattern[] */ 1188 int i, j; /* Loop counters */ 1189 1190 assert( argc==3 ); 1191 UNUSED_PARAMETER(argc); 1192 zStr = sqlite3_value_text(argv[0]); 1193 if( zStr==0 ) return; 1194 nStr = sqlite3_value_bytes(argv[0]); 1195 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 1196 zPattern = sqlite3_value_text(argv[1]); 1197 if( zPattern==0 ){ 1198 assert( sqlite3_value_type(argv[1])==SQLITE_NULL 1199 || sqlite3_context_db_handle(context)->mallocFailed ); 1200 return; 1201 } 1202 if( zPattern[0]==0 ){ 1203 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); 1204 sqlite3_result_value(context, argv[0]); 1205 return; 1206 } 1207 nPattern = sqlite3_value_bytes(argv[1]); 1208 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 1209 zRep = sqlite3_value_text(argv[2]); 1210 if( zRep==0 ) return; 1211 nRep = sqlite3_value_bytes(argv[2]); 1212 assert( zRep==sqlite3_value_text(argv[2]) ); 1213 nOut = nStr + 1; 1214 assert( nOut<SQLITE_MAX_LENGTH ); 1215 zOut = contextMalloc(context, (i64)nOut); 1216 if( zOut==0 ){ 1217 return; 1218 } 1219 loopLimit = nStr - nPattern; 1220 for(i=j=0; i<=loopLimit; i++){ 1221 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 1222 zOut[j++] = zStr[i]; 1223 }else{ 1224 u8 *zOld; 1225 sqlite3 *db = sqlite3_context_db_handle(context); 1226 nOut += nRep - nPattern; 1227 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1228 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1229 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1230 sqlite3_result_error_toobig(context); 1231 sqlite3_free(zOut); 1232 return; 1233 } 1234 zOld = zOut; 1235 zOut = sqlite3_realloc64(zOut, (int)nOut); 1236 if( zOut==0 ){ 1237 sqlite3_result_error_nomem(context); 1238 sqlite3_free(zOld); 1239 return; 1240 } 1241 memcpy(&zOut[j], zRep, nRep); 1242 j += nRep; 1243 i += nPattern-1; 1244 } 1245 } 1246 assert( j+nStr-i+1==nOut ); 1247 memcpy(&zOut[j], &zStr[i], nStr-i); 1248 j += nStr - i; 1249 assert( j<=nOut ); 1250 zOut[j] = 0; 1251 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 1252 } 1253 1254 /* 1255 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 1256 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 1257 */ 1258 static void trimFunc( 1259 sqlite3_context *context, 1260 int argc, 1261 sqlite3_value **argv 1262 ){ 1263 const unsigned char *zIn; /* Input string */ 1264 const unsigned char *zCharSet; /* Set of characters to trim */ 1265 int nIn; /* Number of bytes in input */ 1266 int flags; /* 1: trimleft 2: trimright 3: trim */ 1267 int i; /* Loop counter */ 1268 unsigned char *aLen = 0; /* Length of each character in zCharSet */ 1269 unsigned char **azChar = 0; /* Individual characters in zCharSet */ 1270 int nChar; /* Number of characters in zCharSet */ 1271 1272 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1273 return; 1274 } 1275 zIn = sqlite3_value_text(argv[0]); 1276 if( zIn==0 ) return; 1277 nIn = sqlite3_value_bytes(argv[0]); 1278 assert( zIn==sqlite3_value_text(argv[0]) ); 1279 if( argc==1 ){ 1280 static const unsigned char lenOne[] = { 1 }; 1281 static unsigned char * const azOne[] = { (u8*)" " }; 1282 nChar = 1; 1283 aLen = (u8*)lenOne; 1284 azChar = (unsigned char **)azOne; 1285 zCharSet = 0; 1286 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 1287 return; 1288 }else{ 1289 const unsigned char *z; 1290 for(z=zCharSet, nChar=0; *z; nChar++){ 1291 SQLITE_SKIP_UTF8(z); 1292 } 1293 if( nChar>0 ){ 1294 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); 1295 if( azChar==0 ){ 1296 return; 1297 } 1298 aLen = (unsigned char*)&azChar[nChar]; 1299 for(z=zCharSet, nChar=0; *z; nChar++){ 1300 azChar[nChar] = (unsigned char *)z; 1301 SQLITE_SKIP_UTF8(z); 1302 aLen[nChar] = (u8)(z - azChar[nChar]); 1303 } 1304 } 1305 } 1306 if( nChar>0 ){ 1307 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); 1308 if( flags & 1 ){ 1309 while( nIn>0 ){ 1310 int len = 0; 1311 for(i=0; i<nChar; i++){ 1312 len = aLen[i]; 1313 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break; 1314 } 1315 if( i>=nChar ) break; 1316 zIn += len; 1317 nIn -= len; 1318 } 1319 } 1320 if( flags & 2 ){ 1321 while( nIn>0 ){ 1322 int len = 0; 1323 for(i=0; i<nChar; i++){ 1324 len = aLen[i]; 1325 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 1326 } 1327 if( i>=nChar ) break; 1328 nIn -= len; 1329 } 1330 } 1331 if( zCharSet ){ 1332 sqlite3_free(azChar); 1333 } 1334 } 1335 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 1336 } 1337 1338 1339 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1340 /* 1341 ** The "unknown" function is automatically substituted in place of 1342 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN 1343 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used. 1344 ** When the "sqlite3" command-line shell is built using this functionality, 1345 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries 1346 ** involving application-defined functions to be examined in a generic 1347 ** sqlite3 shell. 1348 */ 1349 static void unknownFunc( 1350 sqlite3_context *context, 1351 int argc, 1352 sqlite3_value **argv 1353 ){ 1354 /* no-op */ 1355 } 1356 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ 1357 1358 1359 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It 1360 ** is only available if the SQLITE_SOUNDEX compile-time option is used 1361 ** when SQLite is built. 1362 */ 1363 #ifdef SQLITE_SOUNDEX 1364 /* 1365 ** Compute the soundex encoding of a word. 1366 ** 1367 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the 1368 ** soundex encoding of the string X. 1369 */ 1370 static void soundexFunc( 1371 sqlite3_context *context, 1372 int argc, 1373 sqlite3_value **argv 1374 ){ 1375 char zResult[8]; 1376 const u8 *zIn; 1377 int i, j; 1378 static const unsigned char iCode[] = { 1379 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1380 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1381 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1382 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1383 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1384 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1385 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1386 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1387 }; 1388 assert( argc==1 ); 1389 zIn = (u8*)sqlite3_value_text(argv[0]); 1390 if( zIn==0 ) zIn = (u8*)""; 1391 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} 1392 if( zIn[i] ){ 1393 u8 prevcode = iCode[zIn[i]&0x7f]; 1394 zResult[0] = sqlite3Toupper(zIn[i]); 1395 for(j=1; j<4 && zIn[i]; i++){ 1396 int code = iCode[zIn[i]&0x7f]; 1397 if( code>0 ){ 1398 if( code!=prevcode ){ 1399 prevcode = code; 1400 zResult[j++] = code + '0'; 1401 } 1402 }else{ 1403 prevcode = 0; 1404 } 1405 } 1406 while( j<4 ){ 1407 zResult[j++] = '0'; 1408 } 1409 zResult[j] = 0; 1410 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 1411 }else{ 1412 /* IMP: R-64894-50321 The string "?000" is returned if the argument 1413 ** is NULL or contains no ASCII alphabetic characters. */ 1414 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 1415 } 1416 } 1417 #endif /* SQLITE_SOUNDEX */ 1418 1419 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1420 /* 1421 ** A function that loads a shared-library extension then returns NULL. 1422 */ 1423 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 1424 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 1425 const char *zProc; 1426 sqlite3 *db = sqlite3_context_db_handle(context); 1427 char *zErrMsg = 0; 1428 1429 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc 1430 ** flag is set. See the sqlite3_enable_load_extension() API. 1431 */ 1432 if( (db->flags & SQLITE_LoadExtFunc)==0 ){ 1433 sqlite3_result_error(context, "not authorized", -1); 1434 return; 1435 } 1436 1437 if( argc==2 ){ 1438 zProc = (const char *)sqlite3_value_text(argv[1]); 1439 }else{ 1440 zProc = 0; 1441 } 1442 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1443 sqlite3_result_error(context, zErrMsg, -1); 1444 sqlite3_free(zErrMsg); 1445 } 1446 } 1447 #endif 1448 1449 1450 /* 1451 ** An instance of the following structure holds the context of a 1452 ** sum() or avg() aggregate computation. 1453 */ 1454 typedef struct SumCtx SumCtx; 1455 struct SumCtx { 1456 double rSum; /* Floating point sum */ 1457 i64 iSum; /* Integer sum */ 1458 i64 cnt; /* Number of elements summed */ 1459 u8 overflow; /* True if integer overflow seen */ 1460 u8 approx; /* True if non-integer value was input to the sum */ 1461 }; 1462 1463 /* 1464 ** Routines used to compute the sum, average, and total. 1465 ** 1466 ** The SUM() function follows the (broken) SQL standard which means 1467 ** that it returns NULL if it sums over no inputs. TOTAL returns 1468 ** 0.0 in that case. In addition, TOTAL always returns a float where 1469 ** SUM might return an integer if it never encounters a floating point 1470 ** value. TOTAL never fails, but SUM might through an exception if 1471 ** it overflows an integer. 1472 */ 1473 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1474 SumCtx *p; 1475 int type; 1476 assert( argc==1 ); 1477 UNUSED_PARAMETER(argc); 1478 p = sqlite3_aggregate_context(context, sizeof(*p)); 1479 type = sqlite3_value_numeric_type(argv[0]); 1480 if( p && type!=SQLITE_NULL ){ 1481 p->cnt++; 1482 if( type==SQLITE_INTEGER ){ 1483 i64 v = sqlite3_value_int64(argv[0]); 1484 p->rSum += v; 1485 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ 1486 p->overflow = 1; 1487 } 1488 }else{ 1489 p->rSum += sqlite3_value_double(argv[0]); 1490 p->approx = 1; 1491 } 1492 } 1493 } 1494 static void sumFinalize(sqlite3_context *context){ 1495 SumCtx *p; 1496 p = sqlite3_aggregate_context(context, 0); 1497 if( p && p->cnt>0 ){ 1498 if( p->overflow ){ 1499 sqlite3_result_error(context,"integer overflow",-1); 1500 }else if( p->approx ){ 1501 sqlite3_result_double(context, p->rSum); 1502 }else{ 1503 sqlite3_result_int64(context, p->iSum); 1504 } 1505 } 1506 } 1507 static void avgFinalize(sqlite3_context *context){ 1508 SumCtx *p; 1509 p = sqlite3_aggregate_context(context, 0); 1510 if( p && p->cnt>0 ){ 1511 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1512 } 1513 } 1514 static void totalFinalize(sqlite3_context *context){ 1515 SumCtx *p; 1516 p = sqlite3_aggregate_context(context, 0); 1517 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ 1518 sqlite3_result_double(context, p ? p->rSum : (double)0); 1519 } 1520 1521 /* 1522 ** The following structure keeps track of state information for the 1523 ** count() aggregate function. 1524 */ 1525 typedef struct CountCtx CountCtx; 1526 struct CountCtx { 1527 i64 n; 1528 }; 1529 1530 /* 1531 ** Routines to implement the count() aggregate function. 1532 */ 1533 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1534 CountCtx *p; 1535 p = sqlite3_aggregate_context(context, sizeof(*p)); 1536 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1537 p->n++; 1538 } 1539 1540 #ifndef SQLITE_OMIT_DEPRECATED 1541 /* The sqlite3_aggregate_count() function is deprecated. But just to make 1542 ** sure it still operates correctly, verify that its count agrees with our 1543 ** internal count when using count(*) and when the total count can be 1544 ** expressed as a 32-bit integer. */ 1545 assert( argc==1 || p==0 || p->n>0x7fffffff 1546 || p->n==sqlite3_aggregate_count(context) ); 1547 #endif 1548 } 1549 static void countFinalize(sqlite3_context *context){ 1550 CountCtx *p; 1551 p = sqlite3_aggregate_context(context, 0); 1552 sqlite3_result_int64(context, p ? p->n : 0); 1553 } 1554 1555 /* 1556 ** Routines to implement min() and max() aggregate functions. 1557 */ 1558 static void minmaxStep( 1559 sqlite3_context *context, 1560 int NotUsed, 1561 sqlite3_value **argv 1562 ){ 1563 Mem *pArg = (Mem *)argv[0]; 1564 Mem *pBest; 1565 UNUSED_PARAMETER(NotUsed); 1566 1567 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1568 if( !pBest ) return; 1569 1570 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1571 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); 1572 }else if( pBest->flags ){ 1573 int max; 1574 int cmp; 1575 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1576 /* This step function is used for both the min() and max() aggregates, 1577 ** the only difference between the two being that the sense of the 1578 ** comparison is inverted. For the max() aggregate, the 1579 ** sqlite3_user_data() function returns (void *)-1. For min() it 1580 ** returns (void *)db, where db is the sqlite3* database pointer. 1581 ** Therefore the next statement sets variable 'max' to 1 for the max() 1582 ** aggregate, or 0 for min(). 1583 */ 1584 max = sqlite3_user_data(context)!=0; 1585 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1586 if( (max && cmp<0) || (!max && cmp>0) ){ 1587 sqlite3VdbeMemCopy(pBest, pArg); 1588 }else{ 1589 sqlite3SkipAccumulatorLoad(context); 1590 } 1591 }else{ 1592 pBest->db = sqlite3_context_db_handle(context); 1593 sqlite3VdbeMemCopy(pBest, pArg); 1594 } 1595 } 1596 static void minMaxFinalize(sqlite3_context *context){ 1597 sqlite3_value *pRes; 1598 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1599 if( pRes ){ 1600 if( pRes->flags ){ 1601 sqlite3_result_value(context, pRes); 1602 } 1603 sqlite3VdbeMemRelease(pRes); 1604 } 1605 } 1606 1607 /* 1608 ** group_concat(EXPR, ?SEPARATOR?) 1609 */ 1610 static void groupConcatStep( 1611 sqlite3_context *context, 1612 int argc, 1613 sqlite3_value **argv 1614 ){ 1615 const char *zVal; 1616 StrAccum *pAccum; 1617 const char *zSep; 1618 int nVal, nSep; 1619 assert( argc==1 || argc==2 ); 1620 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1621 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); 1622 1623 if( pAccum ){ 1624 sqlite3 *db = sqlite3_context_db_handle(context); 1625 int firstTerm = pAccum->mxAlloc==0; 1626 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; 1627 if( !firstTerm ){ 1628 if( argc==2 ){ 1629 zSep = (char*)sqlite3_value_text(argv[1]); 1630 nSep = sqlite3_value_bytes(argv[1]); 1631 }else{ 1632 zSep = ","; 1633 nSep = 1; 1634 } 1635 if( zSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep); 1636 } 1637 zVal = (char*)sqlite3_value_text(argv[0]); 1638 nVal = sqlite3_value_bytes(argv[0]); 1639 if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal); 1640 } 1641 } 1642 static void groupConcatFinalize(sqlite3_context *context){ 1643 StrAccum *pAccum; 1644 pAccum = sqlite3_aggregate_context(context, 0); 1645 if( pAccum ){ 1646 if( pAccum->accError==STRACCUM_TOOBIG ){ 1647 sqlite3_result_error_toobig(context); 1648 }else if( pAccum->accError==STRACCUM_NOMEM ){ 1649 sqlite3_result_error_nomem(context); 1650 }else{ 1651 sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 1652 sqlite3_free); 1653 } 1654 } 1655 } 1656 1657 /* 1658 ** This routine does per-connection function registration. Most 1659 ** of the built-in functions above are part of the global function set. 1660 ** This routine only deals with those that are not global. 1661 */ 1662 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ 1663 int rc = sqlite3_overload_function(db, "MATCH", 2); 1664 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1665 if( rc==SQLITE_NOMEM ){ 1666 sqlite3OomFault(db); 1667 } 1668 } 1669 1670 /* 1671 ** Set the LIKEOPT flag on the 2-argument function with the given name. 1672 */ 1673 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){ 1674 FuncDef *pDef; 1675 pDef = sqlite3FindFunction(db, zName, 2, SQLITE_UTF8, 0); 1676 if( ALWAYS(pDef) ){ 1677 pDef->funcFlags |= flagVal; 1678 } 1679 } 1680 1681 /* 1682 ** Register the built-in LIKE and GLOB functions. The caseSensitive 1683 ** parameter determines whether or not the LIKE operator is case 1684 ** sensitive. GLOB is always case sensitive. 1685 */ 1686 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1687 struct compareInfo *pInfo; 1688 if( caseSensitive ){ 1689 pInfo = (struct compareInfo*)&likeInfoAlt; 1690 }else{ 1691 pInfo = (struct compareInfo*)&likeInfoNorm; 1692 } 1693 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1694 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1695 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 1696 (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0); 1697 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); 1698 setLikeOptFlag(db, "like", 1699 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); 1700 } 1701 1702 /* 1703 ** pExpr points to an expression which implements a function. If 1704 ** it is appropriate to apply the LIKE optimization to that function 1705 ** then set aWc[0] through aWc[2] to the wildcard characters and 1706 ** return TRUE. If the function is not a LIKE-style function then 1707 ** return FALSE. 1708 ** 1709 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for 1710 ** the function (default for LIKE). If the function makes the distinction 1711 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to 1712 ** false. 1713 */ 1714 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1715 FuncDef *pDef; 1716 if( pExpr->op!=TK_FUNCTION 1717 || !pExpr->x.pList 1718 || pExpr->x.pList->nExpr!=2 1719 ){ 1720 return 0; 1721 } 1722 assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); 1723 pDef = sqlite3FindFunction(db, pExpr->u.zToken, 2, SQLITE_UTF8, 0); 1724 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ 1725 return 0; 1726 } 1727 1728 /* The memcpy() statement assumes that the wildcard characters are 1729 ** the first three statements in the compareInfo structure. The 1730 ** asserts() that follow verify that assumption 1731 */ 1732 memcpy(aWc, pDef->pUserData, 3); 1733 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1734 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1735 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1736 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; 1737 return 1; 1738 } 1739 1740 /* 1741 ** All of the FuncDef structures in the aBuiltinFunc[] array above 1742 ** to the global function hash table. This occurs at start-time (as 1743 ** a consequence of calling sqlite3_initialize()). 1744 ** 1745 ** After this routine runs 1746 */ 1747 void sqlite3RegisterBuiltinFunctions(void){ 1748 /* 1749 ** The following array holds FuncDef structures for all of the functions 1750 ** defined in this file. 1751 ** 1752 ** The array cannot be constant since changes are made to the 1753 ** FuncDef.pHash elements at start-time. The elements of this array 1754 ** are read-only after initialization is complete. 1755 ** 1756 ** For peak efficiency, put the most frequently used function last. 1757 */ 1758 static FuncDef aBuiltinFunc[] = { 1759 #ifdef SQLITE_SOUNDEX 1760 FUNCTION(soundex, 1, 0, 0, soundexFunc ), 1761 #endif 1762 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1763 VFUNCTION(load_extension, 1, 0, 0, loadExt ), 1764 VFUNCTION(load_extension, 2, 0, 0, loadExt ), 1765 #endif 1766 #if SQLITE_USER_AUTHENTICATION 1767 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), 1768 #endif 1769 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 1770 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), 1771 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), 1772 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 1773 FUNCTION2(unlikely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1774 FUNCTION2(likelihood, 2, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1775 FUNCTION2(likely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1776 #ifdef SQLITE_DEBUG 1777 FUNCTION2(affinity, 1, 0, 0, noopFunc, SQLITE_FUNC_AFFINITY), 1778 #endif 1779 FUNCTION(ltrim, 1, 1, 0, trimFunc ), 1780 FUNCTION(ltrim, 2, 1, 0, trimFunc ), 1781 FUNCTION(rtrim, 1, 2, 0, trimFunc ), 1782 FUNCTION(rtrim, 2, 2, 0, trimFunc ), 1783 FUNCTION(trim, 1, 3, 0, trimFunc ), 1784 FUNCTION(trim, 2, 3, 0, trimFunc ), 1785 FUNCTION(min, -1, 0, 1, minmaxFunc ), 1786 FUNCTION(min, 0, 0, 1, 0 ), 1787 AGGREGATE2(min, 1, 0, 1, minmaxStep, minMaxFinalize, 1788 SQLITE_FUNC_MINMAX ), 1789 FUNCTION(max, -1, 1, 1, minmaxFunc ), 1790 FUNCTION(max, 0, 1, 1, 0 ), 1791 AGGREGATE2(max, 1, 1, 1, minmaxStep, minMaxFinalize, 1792 SQLITE_FUNC_MINMAX ), 1793 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), 1794 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), 1795 FUNCTION(instr, 2, 0, 0, instrFunc ), 1796 FUNCTION(printf, -1, 0, 0, printfFunc ), 1797 FUNCTION(unicode, 1, 0, 0, unicodeFunc ), 1798 FUNCTION(char, -1, 0, 0, charFunc ), 1799 FUNCTION(abs, 1, 0, 0, absFunc ), 1800 #ifndef SQLITE_OMIT_FLOATING_POINT 1801 FUNCTION(round, 1, 0, 0, roundFunc ), 1802 FUNCTION(round, 2, 0, 0, roundFunc ), 1803 #endif 1804 FUNCTION(upper, 1, 0, 0, upperFunc ), 1805 FUNCTION(lower, 1, 0, 0, lowerFunc ), 1806 FUNCTION(hex, 1, 0, 0, hexFunc ), 1807 FUNCTION2(ifnull, 2, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1808 VFUNCTION(random, 0, 0, 0, randomFunc ), 1809 VFUNCTION(randomblob, 1, 0, 0, randomBlob ), 1810 FUNCTION(nullif, 2, 0, 1, nullifFunc ), 1811 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), 1812 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), 1813 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), 1814 FUNCTION(quote, 1, 0, 0, quoteFunc ), 1815 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), 1816 VFUNCTION(changes, 0, 0, 0, changes ), 1817 VFUNCTION(total_changes, 0, 0, 0, total_changes ), 1818 FUNCTION(replace, 3, 0, 0, replaceFunc ), 1819 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), 1820 FUNCTION(substr, 2, 0, 0, substrFunc ), 1821 FUNCTION(substr, 3, 0, 0, substrFunc ), 1822 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ), 1823 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ), 1824 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ), 1825 AGGREGATE2(count, 0, 0, 0, countStep, countFinalize, 1826 SQLITE_FUNC_COUNT ), 1827 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ), 1828 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize), 1829 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize), 1830 1831 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1832 #ifdef SQLITE_CASE_SENSITIVE_LIKE 1833 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1834 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1835 #else 1836 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), 1837 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), 1838 #endif 1839 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1840 FUNCTION(unknown, -1, 0, 0, unknownFunc ), 1841 #endif 1842 FUNCTION(coalesce, 1, 0, 0, 0 ), 1843 FUNCTION(coalesce, 0, 0, 0, 0 ), 1844 FUNCTION2(coalesce, -1, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1845 }; 1846 #ifndef SQLITE_OMIT_ALTERTABLE 1847 sqlite3AlterFunctions(); 1848 #endif 1849 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4) 1850 sqlite3AnalyzeFunctions(); 1851 #endif 1852 sqlite3RegisterDateTimeFunctions(); 1853 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); 1854 1855 #if 0 /* Enable to print out how the built-in functions are hashed */ 1856 { 1857 int i; 1858 FuncDef *p; 1859 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){ 1860 printf("FUNC-HASH %02d:", i); 1861 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){ 1862 int n = sqlite3Strlen30(p->zName); 1863 int h = p->zName[0] + n; 1864 printf(" %s(%d)", p->zName, h); 1865 } 1866 printf("\n"); 1867 } 1868 } 1869 #endif 1870 } 1871