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 u32 cx; 702 int bMatch; 703 if( noCase ){ 704 cx = sqlite3Toupper(c); 705 c = sqlite3Tolower(c); 706 }else{ 707 cx = c; 708 } 709 while( (c2 = *(zString++))!=0 ){ 710 if( c2!=c && c2!=cx ) continue; 711 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 712 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 713 } 714 }else{ 715 int bMatch; 716 while( (c2 = Utf8Read(zString))!=0 ){ 717 if( c2!=c ) continue; 718 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 719 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 720 } 721 } 722 return SQLITE_NOWILDCARDMATCH; 723 } 724 if( c==matchOther ){ 725 if( pInfo->matchSet==0 ){ 726 c = sqlite3Utf8Read(&zPattern); 727 if( c==0 ) return SQLITE_NOMATCH; 728 zEscaped = zPattern; 729 }else{ 730 u32 prior_c = 0; 731 int seen = 0; 732 int invert = 0; 733 c = sqlite3Utf8Read(&zString); 734 if( c==0 ) return SQLITE_NOMATCH; 735 c2 = sqlite3Utf8Read(&zPattern); 736 if( c2=='^' ){ 737 invert = 1; 738 c2 = sqlite3Utf8Read(&zPattern); 739 } 740 if( c2==']' ){ 741 if( c==']' ) seen = 1; 742 c2 = sqlite3Utf8Read(&zPattern); 743 } 744 while( c2 && c2!=']' ){ 745 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 746 c2 = sqlite3Utf8Read(&zPattern); 747 if( c>=prior_c && c<=c2 ) seen = 1; 748 prior_c = 0; 749 }else{ 750 if( c==c2 ){ 751 seen = 1; 752 } 753 prior_c = c2; 754 } 755 c2 = sqlite3Utf8Read(&zPattern); 756 } 757 if( c2==0 || (seen ^ invert)==0 ){ 758 return SQLITE_NOMATCH; 759 } 760 continue; 761 } 762 } 763 c2 = Utf8Read(zString); 764 if( c==c2 ) continue; 765 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ 766 continue; 767 } 768 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; 769 return SQLITE_NOMATCH; 770 } 771 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; 772 } 773 774 /* 775 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and 776 ** non-zero if there is no match. 777 */ 778 int sqlite3_strglob(const char *zGlobPattern, const char *zString){ 779 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); 780 } 781 782 /* 783 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for 784 ** a miss - like strcmp(). 785 */ 786 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ 787 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); 788 } 789 790 /* 791 ** Count the number of times that the LIKE operator (or GLOB which is 792 ** just a variation of LIKE) gets called. This is used for testing 793 ** only. 794 */ 795 #ifdef SQLITE_TEST 796 int sqlite3_like_count = 0; 797 #endif 798 799 800 /* 801 ** Implementation of the like() SQL function. This function implements 802 ** the build-in LIKE operator. The first argument to the function is the 803 ** pattern and the second argument is the string. So, the SQL statements: 804 ** 805 ** A LIKE B 806 ** 807 ** is implemented as like(B,A). 808 ** 809 ** This same function (with a different compareInfo structure) computes 810 ** the GLOB operator. 811 */ 812 static void likeFunc( 813 sqlite3_context *context, 814 int argc, 815 sqlite3_value **argv 816 ){ 817 const unsigned char *zA, *zB; 818 u32 escape; 819 int nPat; 820 sqlite3 *db = sqlite3_context_db_handle(context); 821 struct compareInfo *pInfo = sqlite3_user_data(context); 822 823 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS 824 if( sqlite3_value_type(argv[0])==SQLITE_BLOB 825 || sqlite3_value_type(argv[1])==SQLITE_BLOB 826 ){ 827 #ifdef SQLITE_TEST 828 sqlite3_like_count++; 829 #endif 830 sqlite3_result_int(context, 0); 831 return; 832 } 833 #endif 834 zB = sqlite3_value_text(argv[0]); 835 zA = sqlite3_value_text(argv[1]); 836 837 /* Limit the length of the LIKE or GLOB pattern to avoid problems 838 ** of deep recursion and N*N behavior in patternCompare(). 839 */ 840 nPat = sqlite3_value_bytes(argv[0]); 841 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); 842 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); 843 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ 844 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 845 return; 846 } 847 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ 848 849 if( argc==3 ){ 850 /* The escape character string must consist of a single UTF-8 character. 851 ** Otherwise, return an error. 852 */ 853 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 854 if( zEsc==0 ) return; 855 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 856 sqlite3_result_error(context, 857 "ESCAPE expression must be a single character", -1); 858 return; 859 } 860 escape = sqlite3Utf8Read(&zEsc); 861 }else{ 862 escape = pInfo->matchSet; 863 } 864 if( zA && zB ){ 865 #ifdef SQLITE_TEST 866 sqlite3_like_count++; 867 #endif 868 sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); 869 } 870 } 871 872 /* 873 ** Implementation of the NULLIF(x,y) function. The result is the first 874 ** argument if the arguments are different. The result is NULL if the 875 ** arguments are equal to each other. 876 */ 877 static void nullifFunc( 878 sqlite3_context *context, 879 int NotUsed, 880 sqlite3_value **argv 881 ){ 882 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 883 UNUSED_PARAMETER(NotUsed); 884 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 885 sqlite3_result_value(context, argv[0]); 886 } 887 } 888 889 /* 890 ** Implementation of the sqlite_version() function. The result is the version 891 ** of the SQLite library that is running. 892 */ 893 static void versionFunc( 894 sqlite3_context *context, 895 int NotUsed, 896 sqlite3_value **NotUsed2 897 ){ 898 UNUSED_PARAMETER2(NotUsed, NotUsed2); 899 /* IMP: R-48699-48617 This function is an SQL wrapper around the 900 ** sqlite3_libversion() C-interface. */ 901 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); 902 } 903 904 /* 905 ** Implementation of the sqlite_source_id() function. The result is a string 906 ** that identifies the particular version of the source code used to build 907 ** SQLite. 908 */ 909 static void sourceidFunc( 910 sqlite3_context *context, 911 int NotUsed, 912 sqlite3_value **NotUsed2 913 ){ 914 UNUSED_PARAMETER2(NotUsed, NotUsed2); 915 /* IMP: R-24470-31136 This function is an SQL wrapper around the 916 ** sqlite3_sourceid() C interface. */ 917 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); 918 } 919 920 /* 921 ** Implementation of the sqlite_log() function. This is a wrapper around 922 ** sqlite3_log(). The return value is NULL. The function exists purely for 923 ** its side-effects. 924 */ 925 static void errlogFunc( 926 sqlite3_context *context, 927 int argc, 928 sqlite3_value **argv 929 ){ 930 UNUSED_PARAMETER(argc); 931 UNUSED_PARAMETER(context); 932 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); 933 } 934 935 /* 936 ** Implementation of the sqlite_compileoption_used() function. 937 ** The result is an integer that identifies if the compiler option 938 ** was used to build SQLite. 939 */ 940 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 941 static void compileoptionusedFunc( 942 sqlite3_context *context, 943 int argc, 944 sqlite3_value **argv 945 ){ 946 const char *zOptName; 947 assert( argc==1 ); 948 UNUSED_PARAMETER(argc); 949 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL 950 ** function is a wrapper around the sqlite3_compileoption_used() C/C++ 951 ** function. 952 */ 953 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 954 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); 955 } 956 } 957 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 958 959 /* 960 ** Implementation of the sqlite_compileoption_get() function. 961 ** The result is a string that identifies the compiler options 962 ** used to build SQLite. 963 */ 964 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 965 static void compileoptiongetFunc( 966 sqlite3_context *context, 967 int argc, 968 sqlite3_value **argv 969 ){ 970 int n; 971 assert( argc==1 ); 972 UNUSED_PARAMETER(argc); 973 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function 974 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. 975 */ 976 n = sqlite3_value_int(argv[0]); 977 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); 978 } 979 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 980 981 /* Array for converting from half-bytes (nybbles) into ASCII hex 982 ** digits. */ 983 static const char hexdigits[] = { 984 '0', '1', '2', '3', '4', '5', '6', '7', 985 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 986 }; 987 988 /* 989 ** Implementation of the QUOTE() function. This function takes a single 990 ** argument. If the argument is numeric, the return value is the same as 991 ** the argument. If the argument is NULL, the return value is the string 992 ** "NULL". Otherwise, the argument is enclosed in single quotes with 993 ** single-quote escapes. 994 */ 995 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 996 assert( argc==1 ); 997 UNUSED_PARAMETER(argc); 998 switch( sqlite3_value_type(argv[0]) ){ 999 case SQLITE_FLOAT: { 1000 double r1, r2; 1001 char zBuf[50]; 1002 r1 = sqlite3_value_double(argv[0]); 1003 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); 1004 sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); 1005 if( r1!=r2 ){ 1006 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); 1007 } 1008 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); 1009 break; 1010 } 1011 case SQLITE_INTEGER: { 1012 sqlite3_result_value(context, argv[0]); 1013 break; 1014 } 1015 case SQLITE_BLOB: { 1016 char *zText = 0; 1017 char const *zBlob = sqlite3_value_blob(argv[0]); 1018 int nBlob = sqlite3_value_bytes(argv[0]); 1019 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1020 zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); 1021 if( zText ){ 1022 int i; 1023 for(i=0; i<nBlob; i++){ 1024 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 1025 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 1026 } 1027 zText[(nBlob*2)+2] = '\''; 1028 zText[(nBlob*2)+3] = '\0'; 1029 zText[0] = 'X'; 1030 zText[1] = '\''; 1031 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 1032 sqlite3_free(zText); 1033 } 1034 break; 1035 } 1036 case SQLITE_TEXT: { 1037 int i,j; 1038 u64 n; 1039 const unsigned char *zArg = sqlite3_value_text(argv[0]); 1040 char *z; 1041 1042 if( zArg==0 ) return; 1043 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } 1044 z = contextMalloc(context, ((i64)i)+((i64)n)+3); 1045 if( z ){ 1046 z[0] = '\''; 1047 for(i=0, j=1; zArg[i]; i++){ 1048 z[j++] = zArg[i]; 1049 if( zArg[i]=='\'' ){ 1050 z[j++] = '\''; 1051 } 1052 } 1053 z[j++] = '\''; 1054 z[j] = 0; 1055 sqlite3_result_text(context, z, j, sqlite3_free); 1056 } 1057 break; 1058 } 1059 default: { 1060 assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); 1061 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); 1062 break; 1063 } 1064 } 1065 } 1066 1067 /* 1068 ** The unicode() function. Return the integer unicode code-point value 1069 ** for the first character of the input string. 1070 */ 1071 static void unicodeFunc( 1072 sqlite3_context *context, 1073 int argc, 1074 sqlite3_value **argv 1075 ){ 1076 const unsigned char *z = sqlite3_value_text(argv[0]); 1077 (void)argc; 1078 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); 1079 } 1080 1081 /* 1082 ** The char() function takes zero or more arguments, each of which is 1083 ** an integer. It constructs a string where each character of the string 1084 ** is the unicode character for the corresponding integer argument. 1085 */ 1086 static void charFunc( 1087 sqlite3_context *context, 1088 int argc, 1089 sqlite3_value **argv 1090 ){ 1091 unsigned char *z, *zOut; 1092 int i; 1093 zOut = z = sqlite3_malloc64( argc*4+1 ); 1094 if( z==0 ){ 1095 sqlite3_result_error_nomem(context); 1096 return; 1097 } 1098 for(i=0; i<argc; i++){ 1099 sqlite3_int64 x; 1100 unsigned c; 1101 x = sqlite3_value_int64(argv[i]); 1102 if( x<0 || x>0x10ffff ) x = 0xfffd; 1103 c = (unsigned)(x & 0x1fffff); 1104 if( c<0x00080 ){ 1105 *zOut++ = (u8)(c&0xFF); 1106 }else if( c<0x00800 ){ 1107 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); 1108 *zOut++ = 0x80 + (u8)(c & 0x3F); 1109 }else if( c<0x10000 ){ 1110 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); 1111 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1112 *zOut++ = 0x80 + (u8)(c & 0x3F); 1113 }else{ 1114 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); 1115 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); 1116 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1117 *zOut++ = 0x80 + (u8)(c & 0x3F); 1118 } \ 1119 } 1120 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); 1121 } 1122 1123 /* 1124 ** The hex() function. Interpret the argument as a blob. Return 1125 ** a hexadecimal rendering as text. 1126 */ 1127 static void hexFunc( 1128 sqlite3_context *context, 1129 int argc, 1130 sqlite3_value **argv 1131 ){ 1132 int i, n; 1133 const unsigned char *pBlob; 1134 char *zHex, *z; 1135 assert( argc==1 ); 1136 UNUSED_PARAMETER(argc); 1137 pBlob = sqlite3_value_blob(argv[0]); 1138 n = sqlite3_value_bytes(argv[0]); 1139 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1140 z = zHex = contextMalloc(context, ((i64)n)*2 + 1); 1141 if( zHex ){ 1142 for(i=0; i<n; i++, pBlob++){ 1143 unsigned char c = *pBlob; 1144 *(z++) = hexdigits[(c>>4)&0xf]; 1145 *(z++) = hexdigits[c&0xf]; 1146 } 1147 *z = 0; 1148 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 1149 } 1150 } 1151 1152 /* 1153 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 1154 */ 1155 static void zeroblobFunc( 1156 sqlite3_context *context, 1157 int argc, 1158 sqlite3_value **argv 1159 ){ 1160 i64 n; 1161 int rc; 1162 assert( argc==1 ); 1163 UNUSED_PARAMETER(argc); 1164 n = sqlite3_value_int64(argv[0]); 1165 if( n<0 ) n = 0; 1166 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ 1167 if( rc ){ 1168 sqlite3_result_error_code(context, rc); 1169 } 1170 } 1171 1172 /* 1173 ** The replace() function. Three arguments are all strings: call 1174 ** them A, B, and C. The result is also a string which is derived 1175 ** from A by replacing every occurrence of B with C. The match 1176 ** must be exact. Collating sequences are not used. 1177 */ 1178 static void replaceFunc( 1179 sqlite3_context *context, 1180 int argc, 1181 sqlite3_value **argv 1182 ){ 1183 const unsigned char *zStr; /* The input string A */ 1184 const unsigned char *zPattern; /* The pattern string B */ 1185 const unsigned char *zRep; /* The replacement string C */ 1186 unsigned char *zOut; /* The output */ 1187 int nStr; /* Size of zStr */ 1188 int nPattern; /* Size of zPattern */ 1189 int nRep; /* Size of zRep */ 1190 i64 nOut; /* Maximum size of zOut */ 1191 int loopLimit; /* Last zStr[] that might match zPattern[] */ 1192 int i, j; /* Loop counters */ 1193 1194 assert( argc==3 ); 1195 UNUSED_PARAMETER(argc); 1196 zStr = sqlite3_value_text(argv[0]); 1197 if( zStr==0 ) return; 1198 nStr = sqlite3_value_bytes(argv[0]); 1199 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 1200 zPattern = sqlite3_value_text(argv[1]); 1201 if( zPattern==0 ){ 1202 assert( sqlite3_value_type(argv[1])==SQLITE_NULL 1203 || sqlite3_context_db_handle(context)->mallocFailed ); 1204 return; 1205 } 1206 if( zPattern[0]==0 ){ 1207 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); 1208 sqlite3_result_value(context, argv[0]); 1209 return; 1210 } 1211 nPattern = sqlite3_value_bytes(argv[1]); 1212 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 1213 zRep = sqlite3_value_text(argv[2]); 1214 if( zRep==0 ) return; 1215 nRep = sqlite3_value_bytes(argv[2]); 1216 assert( zRep==sqlite3_value_text(argv[2]) ); 1217 nOut = nStr + 1; 1218 assert( nOut<SQLITE_MAX_LENGTH ); 1219 zOut = contextMalloc(context, (i64)nOut); 1220 if( zOut==0 ){ 1221 return; 1222 } 1223 loopLimit = nStr - nPattern; 1224 for(i=j=0; i<=loopLimit; i++){ 1225 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 1226 zOut[j++] = zStr[i]; 1227 }else{ 1228 u8 *zOld; 1229 sqlite3 *db = sqlite3_context_db_handle(context); 1230 nOut += nRep - nPattern; 1231 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1232 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1233 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1234 sqlite3_result_error_toobig(context); 1235 sqlite3_free(zOut); 1236 return; 1237 } 1238 zOld = zOut; 1239 zOut = sqlite3_realloc64(zOut, (int)nOut); 1240 if( zOut==0 ){ 1241 sqlite3_result_error_nomem(context); 1242 sqlite3_free(zOld); 1243 return; 1244 } 1245 memcpy(&zOut[j], zRep, nRep); 1246 j += nRep; 1247 i += nPattern-1; 1248 } 1249 } 1250 assert( j+nStr-i+1==nOut ); 1251 memcpy(&zOut[j], &zStr[i], nStr-i); 1252 j += nStr - i; 1253 assert( j<=nOut ); 1254 zOut[j] = 0; 1255 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 1256 } 1257 1258 /* 1259 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 1260 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 1261 */ 1262 static void trimFunc( 1263 sqlite3_context *context, 1264 int argc, 1265 sqlite3_value **argv 1266 ){ 1267 const unsigned char *zIn; /* Input string */ 1268 const unsigned char *zCharSet; /* Set of characters to trim */ 1269 int nIn; /* Number of bytes in input */ 1270 int flags; /* 1: trimleft 2: trimright 3: trim */ 1271 int i; /* Loop counter */ 1272 unsigned char *aLen = 0; /* Length of each character in zCharSet */ 1273 unsigned char **azChar = 0; /* Individual characters in zCharSet */ 1274 int nChar; /* Number of characters in zCharSet */ 1275 1276 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1277 return; 1278 } 1279 zIn = sqlite3_value_text(argv[0]); 1280 if( zIn==0 ) return; 1281 nIn = sqlite3_value_bytes(argv[0]); 1282 assert( zIn==sqlite3_value_text(argv[0]) ); 1283 if( argc==1 ){ 1284 static const unsigned char lenOne[] = { 1 }; 1285 static unsigned char * const azOne[] = { (u8*)" " }; 1286 nChar = 1; 1287 aLen = (u8*)lenOne; 1288 azChar = (unsigned char **)azOne; 1289 zCharSet = 0; 1290 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 1291 return; 1292 }else{ 1293 const unsigned char *z; 1294 for(z=zCharSet, nChar=0; *z; nChar++){ 1295 SQLITE_SKIP_UTF8(z); 1296 } 1297 if( nChar>0 ){ 1298 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); 1299 if( azChar==0 ){ 1300 return; 1301 } 1302 aLen = (unsigned char*)&azChar[nChar]; 1303 for(z=zCharSet, nChar=0; *z; nChar++){ 1304 azChar[nChar] = (unsigned char *)z; 1305 SQLITE_SKIP_UTF8(z); 1306 aLen[nChar] = (u8)(z - azChar[nChar]); 1307 } 1308 } 1309 } 1310 if( nChar>0 ){ 1311 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); 1312 if( flags & 1 ){ 1313 while( nIn>0 ){ 1314 int len = 0; 1315 for(i=0; i<nChar; i++){ 1316 len = aLen[i]; 1317 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break; 1318 } 1319 if( i>=nChar ) break; 1320 zIn += len; 1321 nIn -= len; 1322 } 1323 } 1324 if( flags & 2 ){ 1325 while( nIn>0 ){ 1326 int len = 0; 1327 for(i=0; i<nChar; i++){ 1328 len = aLen[i]; 1329 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 1330 } 1331 if( i>=nChar ) break; 1332 nIn -= len; 1333 } 1334 } 1335 if( zCharSet ){ 1336 sqlite3_free(azChar); 1337 } 1338 } 1339 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 1340 } 1341 1342 1343 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1344 /* 1345 ** The "unknown" function is automatically substituted in place of 1346 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN 1347 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used. 1348 ** When the "sqlite3" command-line shell is built using this functionality, 1349 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries 1350 ** involving application-defined functions to be examined in a generic 1351 ** sqlite3 shell. 1352 */ 1353 static void unknownFunc( 1354 sqlite3_context *context, 1355 int argc, 1356 sqlite3_value **argv 1357 ){ 1358 /* no-op */ 1359 } 1360 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ 1361 1362 1363 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It 1364 ** is only available if the SQLITE_SOUNDEX compile-time option is used 1365 ** when SQLite is built. 1366 */ 1367 #ifdef SQLITE_SOUNDEX 1368 /* 1369 ** Compute the soundex encoding of a word. 1370 ** 1371 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the 1372 ** soundex encoding of the string X. 1373 */ 1374 static void soundexFunc( 1375 sqlite3_context *context, 1376 int argc, 1377 sqlite3_value **argv 1378 ){ 1379 char zResult[8]; 1380 const u8 *zIn; 1381 int i, j; 1382 static const unsigned char iCode[] = { 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1386 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1390 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1391 }; 1392 assert( argc==1 ); 1393 zIn = (u8*)sqlite3_value_text(argv[0]); 1394 if( zIn==0 ) zIn = (u8*)""; 1395 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} 1396 if( zIn[i] ){ 1397 u8 prevcode = iCode[zIn[i]&0x7f]; 1398 zResult[0] = sqlite3Toupper(zIn[i]); 1399 for(j=1; j<4 && zIn[i]; i++){ 1400 int code = iCode[zIn[i]&0x7f]; 1401 if( code>0 ){ 1402 if( code!=prevcode ){ 1403 prevcode = code; 1404 zResult[j++] = code + '0'; 1405 } 1406 }else{ 1407 prevcode = 0; 1408 } 1409 } 1410 while( j<4 ){ 1411 zResult[j++] = '0'; 1412 } 1413 zResult[j] = 0; 1414 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 1415 }else{ 1416 /* IMP: R-64894-50321 The string "?000" is returned if the argument 1417 ** is NULL or contains no ASCII alphabetic characters. */ 1418 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 1419 } 1420 } 1421 #endif /* SQLITE_SOUNDEX */ 1422 1423 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1424 /* 1425 ** A function that loads a shared-library extension then returns NULL. 1426 */ 1427 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 1428 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 1429 const char *zProc; 1430 sqlite3 *db = sqlite3_context_db_handle(context); 1431 char *zErrMsg = 0; 1432 1433 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc 1434 ** flag is set. See the sqlite3_enable_load_extension() API. 1435 */ 1436 if( (db->flags & SQLITE_LoadExtFunc)==0 ){ 1437 sqlite3_result_error(context, "not authorized", -1); 1438 return; 1439 } 1440 1441 if( argc==2 ){ 1442 zProc = (const char *)sqlite3_value_text(argv[1]); 1443 }else{ 1444 zProc = 0; 1445 } 1446 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1447 sqlite3_result_error(context, zErrMsg, -1); 1448 sqlite3_free(zErrMsg); 1449 } 1450 } 1451 #endif 1452 1453 1454 /* 1455 ** An instance of the following structure holds the context of a 1456 ** sum() or avg() aggregate computation. 1457 */ 1458 typedef struct SumCtx SumCtx; 1459 struct SumCtx { 1460 double rSum; /* Floating point sum */ 1461 i64 iSum; /* Integer sum */ 1462 i64 cnt; /* Number of elements summed */ 1463 u8 overflow; /* True if integer overflow seen */ 1464 u8 approx; /* True if non-integer value was input to the sum */ 1465 }; 1466 1467 /* 1468 ** Routines used to compute the sum, average, and total. 1469 ** 1470 ** The SUM() function follows the (broken) SQL standard which means 1471 ** that it returns NULL if it sums over no inputs. TOTAL returns 1472 ** 0.0 in that case. In addition, TOTAL always returns a float where 1473 ** SUM might return an integer if it never encounters a floating point 1474 ** value. TOTAL never fails, but SUM might through an exception if 1475 ** it overflows an integer. 1476 */ 1477 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1478 SumCtx *p; 1479 int type; 1480 assert( argc==1 ); 1481 UNUSED_PARAMETER(argc); 1482 p = sqlite3_aggregate_context(context, sizeof(*p)); 1483 type = sqlite3_value_numeric_type(argv[0]); 1484 if( p && type!=SQLITE_NULL ){ 1485 p->cnt++; 1486 if( type==SQLITE_INTEGER ){ 1487 i64 v = sqlite3_value_int64(argv[0]); 1488 p->rSum += v; 1489 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ 1490 p->overflow = 1; 1491 } 1492 }else{ 1493 p->rSum += sqlite3_value_double(argv[0]); 1494 p->approx = 1; 1495 } 1496 } 1497 } 1498 static void sumFinalize(sqlite3_context *context){ 1499 SumCtx *p; 1500 p = sqlite3_aggregate_context(context, 0); 1501 if( p && p->cnt>0 ){ 1502 if( p->overflow ){ 1503 sqlite3_result_error(context,"integer overflow",-1); 1504 }else if( p->approx ){ 1505 sqlite3_result_double(context, p->rSum); 1506 }else{ 1507 sqlite3_result_int64(context, p->iSum); 1508 } 1509 } 1510 } 1511 static void avgFinalize(sqlite3_context *context){ 1512 SumCtx *p; 1513 p = sqlite3_aggregate_context(context, 0); 1514 if( p && p->cnt>0 ){ 1515 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1516 } 1517 } 1518 static void totalFinalize(sqlite3_context *context){ 1519 SumCtx *p; 1520 p = sqlite3_aggregate_context(context, 0); 1521 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ 1522 sqlite3_result_double(context, p ? p->rSum : (double)0); 1523 } 1524 1525 /* 1526 ** The following structure keeps track of state information for the 1527 ** count() aggregate function. 1528 */ 1529 typedef struct CountCtx CountCtx; 1530 struct CountCtx { 1531 i64 n; 1532 }; 1533 1534 /* 1535 ** Routines to implement the count() aggregate function. 1536 */ 1537 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1538 CountCtx *p; 1539 p = sqlite3_aggregate_context(context, sizeof(*p)); 1540 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1541 p->n++; 1542 } 1543 1544 #ifndef SQLITE_OMIT_DEPRECATED 1545 /* The sqlite3_aggregate_count() function is deprecated. But just to make 1546 ** sure it still operates correctly, verify that its count agrees with our 1547 ** internal count when using count(*) and when the total count can be 1548 ** expressed as a 32-bit integer. */ 1549 assert( argc==1 || p==0 || p->n>0x7fffffff 1550 || p->n==sqlite3_aggregate_count(context) ); 1551 #endif 1552 } 1553 static void countFinalize(sqlite3_context *context){ 1554 CountCtx *p; 1555 p = sqlite3_aggregate_context(context, 0); 1556 sqlite3_result_int64(context, p ? p->n : 0); 1557 } 1558 1559 /* 1560 ** Routines to implement min() and max() aggregate functions. 1561 */ 1562 static void minmaxStep( 1563 sqlite3_context *context, 1564 int NotUsed, 1565 sqlite3_value **argv 1566 ){ 1567 Mem *pArg = (Mem *)argv[0]; 1568 Mem *pBest; 1569 UNUSED_PARAMETER(NotUsed); 1570 1571 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1572 if( !pBest ) return; 1573 1574 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1575 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); 1576 }else if( pBest->flags ){ 1577 int max; 1578 int cmp; 1579 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1580 /* This step function is used for both the min() and max() aggregates, 1581 ** the only difference between the two being that the sense of the 1582 ** comparison is inverted. For the max() aggregate, the 1583 ** sqlite3_user_data() function returns (void *)-1. For min() it 1584 ** returns (void *)db, where db is the sqlite3* database pointer. 1585 ** Therefore the next statement sets variable 'max' to 1 for the max() 1586 ** aggregate, or 0 for min(). 1587 */ 1588 max = sqlite3_user_data(context)!=0; 1589 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1590 if( (max && cmp<0) || (!max && cmp>0) ){ 1591 sqlite3VdbeMemCopy(pBest, pArg); 1592 }else{ 1593 sqlite3SkipAccumulatorLoad(context); 1594 } 1595 }else{ 1596 pBest->db = sqlite3_context_db_handle(context); 1597 sqlite3VdbeMemCopy(pBest, pArg); 1598 } 1599 } 1600 static void minMaxFinalize(sqlite3_context *context){ 1601 sqlite3_value *pRes; 1602 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1603 if( pRes ){ 1604 if( pRes->flags ){ 1605 sqlite3_result_value(context, pRes); 1606 } 1607 sqlite3VdbeMemRelease(pRes); 1608 } 1609 } 1610 1611 /* 1612 ** group_concat(EXPR, ?SEPARATOR?) 1613 */ 1614 static void groupConcatStep( 1615 sqlite3_context *context, 1616 int argc, 1617 sqlite3_value **argv 1618 ){ 1619 const char *zVal; 1620 StrAccum *pAccum; 1621 const char *zSep; 1622 int nVal, nSep; 1623 assert( argc==1 || argc==2 ); 1624 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1625 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); 1626 1627 if( pAccum ){ 1628 sqlite3 *db = sqlite3_context_db_handle(context); 1629 int firstTerm = pAccum->mxAlloc==0; 1630 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; 1631 if( !firstTerm ){ 1632 if( argc==2 ){ 1633 zSep = (char*)sqlite3_value_text(argv[1]); 1634 nSep = sqlite3_value_bytes(argv[1]); 1635 }else{ 1636 zSep = ","; 1637 nSep = 1; 1638 } 1639 if( zSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep); 1640 } 1641 zVal = (char*)sqlite3_value_text(argv[0]); 1642 nVal = sqlite3_value_bytes(argv[0]); 1643 if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal); 1644 } 1645 } 1646 static void groupConcatFinalize(sqlite3_context *context){ 1647 StrAccum *pAccum; 1648 pAccum = sqlite3_aggregate_context(context, 0); 1649 if( pAccum ){ 1650 if( pAccum->accError==STRACCUM_TOOBIG ){ 1651 sqlite3_result_error_toobig(context); 1652 }else if( pAccum->accError==STRACCUM_NOMEM ){ 1653 sqlite3_result_error_nomem(context); 1654 }else{ 1655 sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 1656 sqlite3_free); 1657 } 1658 } 1659 } 1660 1661 /* 1662 ** This routine does per-connection function registration. Most 1663 ** of the built-in functions above are part of the global function set. 1664 ** This routine only deals with those that are not global. 1665 */ 1666 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ 1667 int rc = sqlite3_overload_function(db, "MATCH", 2); 1668 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1669 if( rc==SQLITE_NOMEM ){ 1670 sqlite3OomFault(db); 1671 } 1672 } 1673 1674 /* 1675 ** Set the LIKEOPT flag on the 2-argument function with the given name. 1676 */ 1677 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){ 1678 FuncDef *pDef; 1679 pDef = sqlite3FindFunction(db, zName, 2, SQLITE_UTF8, 0); 1680 if( ALWAYS(pDef) ){ 1681 pDef->funcFlags |= flagVal; 1682 } 1683 } 1684 1685 /* 1686 ** Register the built-in LIKE and GLOB functions. The caseSensitive 1687 ** parameter determines whether or not the LIKE operator is case 1688 ** sensitive. GLOB is always case sensitive. 1689 */ 1690 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1691 struct compareInfo *pInfo; 1692 if( caseSensitive ){ 1693 pInfo = (struct compareInfo*)&likeInfoAlt; 1694 }else{ 1695 pInfo = (struct compareInfo*)&likeInfoNorm; 1696 } 1697 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1698 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); 1699 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 1700 (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0); 1701 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); 1702 setLikeOptFlag(db, "like", 1703 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); 1704 } 1705 1706 /* 1707 ** pExpr points to an expression which implements a function. If 1708 ** it is appropriate to apply the LIKE optimization to that function 1709 ** then set aWc[0] through aWc[2] to the wildcard characters and the 1710 ** escape character and then return TRUE. If the function is not a 1711 ** LIKE-style function then return FALSE. 1712 ** 1713 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE 1714 ** operator if c is a string literal that is exactly one byte in length. 1715 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is 1716 ** no ESCAPE clause. 1717 ** 1718 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for 1719 ** the function (default for LIKE). If the function makes the distinction 1720 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to 1721 ** false. 1722 */ 1723 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1724 FuncDef *pDef; 1725 int nExpr; 1726 if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){ 1727 return 0; 1728 } 1729 assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); 1730 nExpr = pExpr->x.pList->nExpr; 1731 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); 1732 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ 1733 return 0; 1734 } 1735 if( nExpr<3 ){ 1736 aWc[3] = 0; 1737 }else{ 1738 Expr *pEscape = pExpr->x.pList->a[2].pExpr; 1739 char *zEscape; 1740 if( pEscape->op!=TK_STRING ) return 0; 1741 zEscape = pEscape->u.zToken; 1742 if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; 1743 aWc[3] = zEscape[0]; 1744 } 1745 1746 /* The memcpy() statement assumes that the wildcard characters are 1747 ** the first three statements in the compareInfo structure. The 1748 ** asserts() that follow verify that assumption 1749 */ 1750 memcpy(aWc, pDef->pUserData, 3); 1751 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1752 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1753 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1754 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; 1755 return 1; 1756 } 1757 1758 /* 1759 ** All of the FuncDef structures in the aBuiltinFunc[] array above 1760 ** to the global function hash table. This occurs at start-time (as 1761 ** a consequence of calling sqlite3_initialize()). 1762 ** 1763 ** After this routine runs 1764 */ 1765 void sqlite3RegisterBuiltinFunctions(void){ 1766 /* 1767 ** The following array holds FuncDef structures for all of the functions 1768 ** defined in this file. 1769 ** 1770 ** The array cannot be constant since changes are made to the 1771 ** FuncDef.pHash elements at start-time. The elements of this array 1772 ** are read-only after initialization is complete. 1773 ** 1774 ** For peak efficiency, put the most frequently used function last. 1775 */ 1776 static FuncDef aBuiltinFunc[] = { 1777 #ifdef SQLITE_SOUNDEX 1778 FUNCTION(soundex, 1, 0, 0, soundexFunc ), 1779 #endif 1780 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1781 VFUNCTION(load_extension, 1, 0, 0, loadExt ), 1782 VFUNCTION(load_extension, 2, 0, 0, loadExt ), 1783 #endif 1784 #if SQLITE_USER_AUTHENTICATION 1785 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), 1786 #endif 1787 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 1788 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), 1789 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), 1790 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 1791 FUNCTION2(unlikely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1792 FUNCTION2(likelihood, 2, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1793 FUNCTION2(likely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), 1794 #ifdef SQLITE_DEBUG 1795 FUNCTION2(affinity, 1, 0, 0, noopFunc, SQLITE_FUNC_AFFINITY), 1796 #endif 1797 FUNCTION(ltrim, 1, 1, 0, trimFunc ), 1798 FUNCTION(ltrim, 2, 1, 0, trimFunc ), 1799 FUNCTION(rtrim, 1, 2, 0, trimFunc ), 1800 FUNCTION(rtrim, 2, 2, 0, trimFunc ), 1801 FUNCTION(trim, 1, 3, 0, trimFunc ), 1802 FUNCTION(trim, 2, 3, 0, trimFunc ), 1803 FUNCTION(min, -1, 0, 1, minmaxFunc ), 1804 FUNCTION(min, 0, 0, 1, 0 ), 1805 AGGREGATE2(min, 1, 0, 1, minmaxStep, minMaxFinalize, 1806 SQLITE_FUNC_MINMAX ), 1807 FUNCTION(max, -1, 1, 1, minmaxFunc ), 1808 FUNCTION(max, 0, 1, 1, 0 ), 1809 AGGREGATE2(max, 1, 1, 1, minmaxStep, minMaxFinalize, 1810 SQLITE_FUNC_MINMAX ), 1811 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), 1812 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), 1813 FUNCTION(instr, 2, 0, 0, instrFunc ), 1814 FUNCTION(printf, -1, 0, 0, printfFunc ), 1815 FUNCTION(unicode, 1, 0, 0, unicodeFunc ), 1816 FUNCTION(char, -1, 0, 0, charFunc ), 1817 FUNCTION(abs, 1, 0, 0, absFunc ), 1818 #ifndef SQLITE_OMIT_FLOATING_POINT 1819 FUNCTION(round, 1, 0, 0, roundFunc ), 1820 FUNCTION(round, 2, 0, 0, roundFunc ), 1821 #endif 1822 FUNCTION(upper, 1, 0, 0, upperFunc ), 1823 FUNCTION(lower, 1, 0, 0, lowerFunc ), 1824 FUNCTION(hex, 1, 0, 0, hexFunc ), 1825 FUNCTION2(ifnull, 2, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1826 VFUNCTION(random, 0, 0, 0, randomFunc ), 1827 VFUNCTION(randomblob, 1, 0, 0, randomBlob ), 1828 FUNCTION(nullif, 2, 0, 1, nullifFunc ), 1829 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), 1830 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), 1831 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), 1832 FUNCTION(quote, 1, 0, 0, quoteFunc ), 1833 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), 1834 VFUNCTION(changes, 0, 0, 0, changes ), 1835 VFUNCTION(total_changes, 0, 0, 0, total_changes ), 1836 FUNCTION(replace, 3, 0, 0, replaceFunc ), 1837 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), 1838 FUNCTION(substr, 2, 0, 0, substrFunc ), 1839 FUNCTION(substr, 3, 0, 0, substrFunc ), 1840 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ), 1841 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ), 1842 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ), 1843 AGGREGATE2(count, 0, 0, 0, countStep, countFinalize, 1844 SQLITE_FUNC_COUNT ), 1845 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ), 1846 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize), 1847 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize), 1848 1849 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1850 #ifdef SQLITE_CASE_SENSITIVE_LIKE 1851 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1852 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 1853 #else 1854 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), 1855 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), 1856 #endif 1857 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1858 FUNCTION(unknown, -1, 0, 0, unknownFunc ), 1859 #endif 1860 FUNCTION(coalesce, 1, 0, 0, 0 ), 1861 FUNCTION(coalesce, 0, 0, 0, 0 ), 1862 FUNCTION2(coalesce, -1, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), 1863 }; 1864 #ifndef SQLITE_OMIT_ALTERTABLE 1865 sqlite3AlterFunctions(); 1866 #endif 1867 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4) 1868 sqlite3AnalyzeFunctions(); 1869 #endif 1870 sqlite3RegisterDateTimeFunctions(); 1871 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); 1872 1873 #if 0 /* Enable to print out how the built-in functions are hashed */ 1874 { 1875 int i; 1876 FuncDef *p; 1877 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){ 1878 printf("FUNC-HASH %02d:", i); 1879 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){ 1880 int n = sqlite3Strlen30(p->zName); 1881 int h = p->zName[0] + n; 1882 printf(" %s(%d)", p->zName, h); 1883 } 1884 printf("\n"); 1885 } 1886 } 1887 #endif 1888 } 1889