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