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