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