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