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