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