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 #ifndef SQLITE_OMIT_FLOATING_POINT 20 #include <math.h> 21 #endif 22 #include "vdbeInt.h" 23 24 /* 25 ** Return the collating function associated with a function. 26 */ 27 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ 28 VdbeOp *pOp; 29 assert( context->pVdbe!=0 ); 30 pOp = &context->pVdbe->aOp[context->iOp-1]; 31 assert( pOp->opcode==OP_CollSeq ); 32 assert( pOp->p4type==P4_COLLSEQ ); 33 return pOp->p4.pColl; 34 } 35 36 /* 37 ** Indicate that the accumulator load should be skipped on this 38 ** iteration of the aggregate loop. 39 */ 40 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){ 41 assert( context->isError<=0 ); 42 context->isError = -1; 43 context->skipFlag = 1; 44 } 45 46 /* 47 ** Implementation of the non-aggregate min() and max() functions 48 */ 49 static void minmaxFunc( 50 sqlite3_context *context, 51 int argc, 52 sqlite3_value **argv 53 ){ 54 int i; 55 int mask; /* 0 for min() or 0xffffffff for max() */ 56 int iBest; 57 CollSeq *pColl; 58 59 assert( argc>1 ); 60 mask = sqlite3_user_data(context)==0 ? 0 : -1; 61 pColl = sqlite3GetFuncCollSeq(context); 62 assert( pColl ); 63 assert( mask==-1 || mask==0 ); 64 iBest = 0; 65 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 66 for(i=1; i<argc; i++){ 67 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return; 68 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){ 69 testcase( mask==0 ); 70 iBest = i; 71 } 72 } 73 sqlite3_result_value(context, argv[iBest]); 74 } 75 76 /* 77 ** Return the type of the argument. 78 */ 79 static void typeofFunc( 80 sqlite3_context *context, 81 int NotUsed, 82 sqlite3_value **argv 83 ){ 84 static const char *azType[] = { "integer", "real", "text", "blob", "null" }; 85 int i = sqlite3_value_type(argv[0]) - 1; 86 UNUSED_PARAMETER(NotUsed); 87 assert( i>=0 && i<ArraySize(azType) ); 88 assert( SQLITE_INTEGER==1 ); 89 assert( SQLITE_FLOAT==2 ); 90 assert( SQLITE_TEXT==3 ); 91 assert( SQLITE_BLOB==4 ); 92 assert( SQLITE_NULL==5 ); 93 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns 94 ** the datatype code for the initial datatype of the sqlite3_value object 95 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT, 96 ** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */ 97 sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC); 98 } 99 100 101 /* 102 ** Implementation of the length() function 103 */ 104 static void lengthFunc( 105 sqlite3_context *context, 106 int argc, 107 sqlite3_value **argv 108 ){ 109 assert( argc==1 ); 110 UNUSED_PARAMETER(argc); 111 switch( sqlite3_value_type(argv[0]) ){ 112 case SQLITE_BLOB: 113 case SQLITE_INTEGER: 114 case SQLITE_FLOAT: { 115 sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); 116 break; 117 } 118 case SQLITE_TEXT: { 119 const unsigned char *z = sqlite3_value_text(argv[0]); 120 const unsigned char *z0; 121 unsigned char c; 122 if( z==0 ) return; 123 z0 = z; 124 while( (c = *z)!=0 ){ 125 z++; 126 if( c>=0xc0 ){ 127 while( (*z & 0xc0)==0x80 ){ z++; z0++; } 128 } 129 } 130 sqlite3_result_int(context, (int)(z-z0)); 131 break; 132 } 133 default: { 134 sqlite3_result_null(context); 135 break; 136 } 137 } 138 } 139 140 /* 141 ** Implementation of the abs() function. 142 ** 143 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of 144 ** the numeric argument X. 145 */ 146 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 147 assert( argc==1 ); 148 UNUSED_PARAMETER(argc); 149 switch( sqlite3_value_type(argv[0]) ){ 150 case SQLITE_INTEGER: { 151 i64 iVal = sqlite3_value_int64(argv[0]); 152 if( iVal<0 ){ 153 if( iVal==SMALLEST_INT64 ){ 154 /* IMP: R-31676-45509 If X is the integer -9223372036854775808 155 ** then abs(X) throws an integer overflow error since there is no 156 ** equivalent positive 64-bit two complement value. */ 157 sqlite3_result_error(context, "integer overflow", -1); 158 return; 159 } 160 iVal = -iVal; 161 } 162 sqlite3_result_int64(context, iVal); 163 break; 164 } 165 case SQLITE_NULL: { 166 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */ 167 sqlite3_result_null(context); 168 break; 169 } 170 default: { 171 /* Because sqlite3_value_double() returns 0.0 if the argument is not 172 ** something that can be converted into a number, we have: 173 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob 174 ** that cannot be converted to a numeric value. 175 */ 176 double rVal = sqlite3_value_double(argv[0]); 177 if( rVal<0 ) rVal = -rVal; 178 sqlite3_result_double(context, rVal); 179 break; 180 } 181 } 182 } 183 184 /* 185 ** Implementation of the instr() function. 186 ** 187 ** instr(haystack,needle) finds the first occurrence of needle 188 ** in haystack and returns the number of previous characters plus 1, 189 ** or 0 if needle does not occur within haystack. 190 ** 191 ** If both haystack and needle are BLOBs, then the result is one more than 192 ** the number of bytes in haystack prior to the first occurrence of needle, 193 ** or 0 if needle never occurs in haystack. 194 */ 195 static void instrFunc( 196 sqlite3_context *context, 197 int argc, 198 sqlite3_value **argv 199 ){ 200 const unsigned char *zHaystack; 201 const unsigned char *zNeedle; 202 int nHaystack; 203 int nNeedle; 204 int typeHaystack, typeNeedle; 205 int N = 1; 206 int isText; 207 unsigned char firstChar; 208 sqlite3_value *pC1 = 0; 209 sqlite3_value *pC2 = 0; 210 211 UNUSED_PARAMETER(argc); 212 typeHaystack = sqlite3_value_type(argv[0]); 213 typeNeedle = sqlite3_value_type(argv[1]); 214 if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return; 215 nHaystack = sqlite3_value_bytes(argv[0]); 216 nNeedle = sqlite3_value_bytes(argv[1]); 217 if( nNeedle>0 ){ 218 if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){ 219 zHaystack = sqlite3_value_blob(argv[0]); 220 zNeedle = sqlite3_value_blob(argv[1]); 221 isText = 0; 222 }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){ 223 zHaystack = sqlite3_value_text(argv[0]); 224 zNeedle = sqlite3_value_text(argv[1]); 225 isText = 1; 226 }else{ 227 pC1 = sqlite3_value_dup(argv[0]); 228 zHaystack = sqlite3_value_text(pC1); 229 if( zHaystack==0 ) goto endInstrOOM; 230 nHaystack = sqlite3_value_bytes(pC1); 231 pC2 = sqlite3_value_dup(argv[1]); 232 zNeedle = sqlite3_value_text(pC2); 233 if( zNeedle==0 ) goto endInstrOOM; 234 nNeedle = sqlite3_value_bytes(pC2); 235 isText = 1; 236 } 237 if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM; 238 firstChar = zNeedle[0]; 239 while( nNeedle<=nHaystack 240 && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0) 241 ){ 242 N++; 243 do{ 244 nHaystack--; 245 zHaystack++; 246 }while( isText && (zHaystack[0]&0xc0)==0x80 ); 247 } 248 if( nNeedle>nHaystack ) N = 0; 249 } 250 sqlite3_result_int(context, N); 251 endInstr: 252 sqlite3_value_free(pC1); 253 sqlite3_value_free(pC2); 254 return; 255 endInstrOOM: 256 sqlite3_result_error_nomem(context); 257 goto endInstr; 258 } 259 260 /* 261 ** Implementation of the printf() function. 262 */ 263 static void printfFunc( 264 sqlite3_context *context, 265 int argc, 266 sqlite3_value **argv 267 ){ 268 PrintfArguments x; 269 StrAccum str; 270 const char *zFormat; 271 int n; 272 sqlite3 *db = sqlite3_context_db_handle(context); 273 274 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 275 x.nArg = argc-1; 276 x.nUsed = 0; 277 x.apArg = argv+1; 278 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); 279 str.printfFlags = SQLITE_PRINTF_SQLFUNC; 280 sqlite3_str_appendf(&str, zFormat, &x); 281 n = str.nChar; 282 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, 283 SQLITE_DYNAMIC); 284 } 285 } 286 287 /* 288 ** Implementation of the substr() function. 289 ** 290 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. 291 ** p1 is 1-indexed. So substr(x,1,1) returns the first character 292 ** of x. If x is text, then we actually count UTF-8 characters. 293 ** If x is a blob, then we count bytes. 294 ** 295 ** If p1 is negative, then we begin abs(p1) from the end of x[]. 296 ** 297 ** If p2 is negative, return the p2 characters preceding p1. 298 */ 299 static void substrFunc( 300 sqlite3_context *context, 301 int argc, 302 sqlite3_value **argv 303 ){ 304 const unsigned char *z; 305 const unsigned char *z2; 306 int len; 307 int p0type; 308 i64 p1, p2; 309 int negP2 = 0; 310 311 assert( argc==3 || argc==2 ); 312 if( sqlite3_value_type(argv[1])==SQLITE_NULL 313 || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL) 314 ){ 315 return; 316 } 317 p0type = sqlite3_value_type(argv[0]); 318 p1 = sqlite3_value_int(argv[1]); 319 if( p0type==SQLITE_BLOB ){ 320 len = sqlite3_value_bytes(argv[0]); 321 z = sqlite3_value_blob(argv[0]); 322 if( z==0 ) return; 323 assert( len==sqlite3_value_bytes(argv[0]) ); 324 }else{ 325 z = sqlite3_value_text(argv[0]); 326 if( z==0 ) return; 327 len = 0; 328 if( p1<0 ){ 329 for(z2=z; *z2; len++){ 330 SQLITE_SKIP_UTF8(z2); 331 } 332 } 333 } 334 #ifdef SQLITE_SUBSTR_COMPATIBILITY 335 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as 336 ** as substr(X,1,N) - it returns the first N characters of X. This 337 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8] 338 ** from 2009-02-02 for compatibility of applications that exploited the 339 ** old buggy behavior. */ 340 if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */ 341 #endif 342 if( argc==3 ){ 343 p2 = sqlite3_value_int(argv[2]); 344 if( p2<0 ){ 345 p2 = -p2; 346 negP2 = 1; 347 } 348 }else{ 349 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH]; 350 } 351 if( p1<0 ){ 352 p1 += len; 353 if( p1<0 ){ 354 p2 += p1; 355 if( p2<0 ) p2 = 0; 356 p1 = 0; 357 } 358 }else if( p1>0 ){ 359 p1--; 360 }else if( p2>0 ){ 361 p2--; 362 } 363 if( negP2 ){ 364 p1 -= p2; 365 if( p1<0 ){ 366 p2 += p1; 367 p1 = 0; 368 } 369 } 370 assert( p1>=0 && p2>=0 ); 371 if( p0type!=SQLITE_BLOB ){ 372 while( *z && p1 ){ 373 SQLITE_SKIP_UTF8(z); 374 p1--; 375 } 376 for(z2=z; *z2 && p2; p2--){ 377 SQLITE_SKIP_UTF8(z2); 378 } 379 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT, 380 SQLITE_UTF8); 381 }else{ 382 if( p1+p2>len ){ 383 p2 = len-p1; 384 if( p2<0 ) p2 = 0; 385 } 386 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT); 387 } 388 } 389 390 /* 391 ** Implementation of the round() function 392 */ 393 #ifndef SQLITE_OMIT_FLOATING_POINT 394 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 395 int n = 0; 396 double r; 397 char *zBuf; 398 assert( argc==1 || argc==2 ); 399 if( argc==2 ){ 400 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; 401 n = sqlite3_value_int(argv[1]); 402 if( n>30 ) n = 30; 403 if( n<0 ) n = 0; 404 } 405 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 406 r = sqlite3_value_double(argv[0]); 407 /* If Y==0 and X will fit in a 64-bit int, 408 ** handle the rounding directly, 409 ** otherwise use printf. 410 */ 411 if( r<-4503599627370496.0 || r>+4503599627370496.0 ){ 412 /* The value has no fractional part so there is nothing to round */ 413 }else if( n==0 ){ 414 r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5))); 415 }else{ 416 zBuf = sqlite3_mprintf("%.*f",n,r); 417 if( zBuf==0 ){ 418 sqlite3_result_error_nomem(context); 419 return; 420 } 421 sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8); 422 sqlite3_free(zBuf); 423 } 424 sqlite3_result_double(context, r); 425 } 426 #endif 427 428 /* 429 ** Allocate nByte bytes of space using sqlite3Malloc(). If the 430 ** allocation fails, call sqlite3_result_error_nomem() to notify 431 ** the database handle that malloc() has failed and return NULL. 432 ** If nByte is larger than the maximum string or blob length, then 433 ** raise an SQLITE_TOOBIG exception and return NULL. 434 */ 435 static void *contextMalloc(sqlite3_context *context, i64 nByte){ 436 char *z; 437 sqlite3 *db = sqlite3_context_db_handle(context); 438 assert( nByte>0 ); 439 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] ); 440 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); 441 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 442 sqlite3_result_error_toobig(context); 443 z = 0; 444 }else{ 445 z = sqlite3Malloc(nByte); 446 if( !z ){ 447 sqlite3_result_error_nomem(context); 448 } 449 } 450 return z; 451 } 452 453 /* 454 ** Implementation of the upper() and lower() SQL functions. 455 */ 456 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 457 char *z1; 458 const char *z2; 459 int i, n; 460 UNUSED_PARAMETER(argc); 461 z2 = (char*)sqlite3_value_text(argv[0]); 462 n = sqlite3_value_bytes(argv[0]); 463 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 464 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 465 if( z2 ){ 466 z1 = contextMalloc(context, ((i64)n)+1); 467 if( z1 ){ 468 for(i=0; i<n; i++){ 469 z1[i] = (char)sqlite3Toupper(z2[i]); 470 } 471 sqlite3_result_text(context, z1, n, sqlite3_free); 472 } 473 } 474 } 475 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 476 char *z1; 477 const char *z2; 478 int i, n; 479 UNUSED_PARAMETER(argc); 480 z2 = (char*)sqlite3_value_text(argv[0]); 481 n = sqlite3_value_bytes(argv[0]); 482 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 483 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 484 if( z2 ){ 485 z1 = contextMalloc(context, ((i64)n)+1); 486 if( z1 ){ 487 for(i=0; i<n; i++){ 488 z1[i] = sqlite3Tolower(z2[i]); 489 } 490 sqlite3_result_text(context, z1, n, sqlite3_free); 491 } 492 } 493 } 494 495 /* 496 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented 497 ** as VDBE code so that unused argument values do not have to be computed. 498 ** However, we still need some kind of function implementation for this 499 ** routines in the function table. The noopFunc macro provides this. 500 ** noopFunc will never be called so it doesn't matter what the implementation 501 ** is. We might as well use the "version()" function as a substitute. 502 */ 503 #define noopFunc versionFunc /* Substitute function - never called */ 504 505 /* 506 ** Implementation of random(). Return a random integer. 507 */ 508 static void randomFunc( 509 sqlite3_context *context, 510 int NotUsed, 511 sqlite3_value **NotUsed2 512 ){ 513 sqlite_int64 r; 514 UNUSED_PARAMETER2(NotUsed, NotUsed2); 515 sqlite3_randomness(sizeof(r), &r); 516 if( r<0 ){ 517 /* We need to prevent a random number of 0x8000000000000000 518 ** (or -9223372036854775808) since when you do abs() of that 519 ** number of you get the same value back again. To do this 520 ** in a way that is testable, mask the sign bit off of negative 521 ** values, resulting in a positive value. Then take the 522 ** 2s complement of that positive value. The end result can 523 ** therefore be no less than -9223372036854775807. 524 */ 525 r = -(r & LARGEST_INT64); 526 } 527 sqlite3_result_int64(context, r); 528 } 529 530 /* 531 ** Implementation of randomblob(N). Return a random blob 532 ** that is N bytes long. 533 */ 534 static void randomBlob( 535 sqlite3_context *context, 536 int argc, 537 sqlite3_value **argv 538 ){ 539 sqlite3_int64 n; 540 unsigned char *p; 541 assert( argc==1 ); 542 UNUSED_PARAMETER(argc); 543 n = sqlite3_value_int64(argv[0]); 544 if( n<1 ){ 545 n = 1; 546 } 547 p = contextMalloc(context, n); 548 if( p ){ 549 sqlite3_randomness(n, p); 550 sqlite3_result_blob(context, (char*)p, n, sqlite3_free); 551 } 552 } 553 554 /* 555 ** Implementation of the last_insert_rowid() SQL function. The return 556 ** value is the same as the sqlite3_last_insert_rowid() API function. 557 */ 558 static void last_insert_rowid( 559 sqlite3_context *context, 560 int NotUsed, 561 sqlite3_value **NotUsed2 562 ){ 563 sqlite3 *db = sqlite3_context_db_handle(context); 564 UNUSED_PARAMETER2(NotUsed, NotUsed2); 565 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a 566 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface 567 ** function. */ 568 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db)); 569 } 570 571 /* 572 ** Implementation of the changes() SQL function. 573 ** 574 ** IMP: R-32760-32347 The changes() SQL function is a wrapper 575 ** around the sqlite3_changes64() C/C++ function and hence follows the 576 ** same rules for counting changes. 577 */ 578 static void changes( 579 sqlite3_context *context, 580 int NotUsed, 581 sqlite3_value **NotUsed2 582 ){ 583 sqlite3 *db = sqlite3_context_db_handle(context); 584 UNUSED_PARAMETER2(NotUsed, NotUsed2); 585 sqlite3_result_int64(context, sqlite3_changes64(db)); 586 } 587 588 /* 589 ** Implementation of the total_changes() SQL function. The return value is 590 ** the same as the sqlite3_total_changes64() API function. 591 */ 592 static void total_changes( 593 sqlite3_context *context, 594 int NotUsed, 595 sqlite3_value **NotUsed2 596 ){ 597 sqlite3 *db = sqlite3_context_db_handle(context); 598 UNUSED_PARAMETER2(NotUsed, NotUsed2); 599 /* IMP: R-11217-42568 This function is a wrapper around the 600 ** sqlite3_total_changes64() C/C++ interface. */ 601 sqlite3_result_int64(context, sqlite3_total_changes64(db)); 602 } 603 604 /* 605 ** A structure defining how to do GLOB-style comparisons. 606 */ 607 struct compareInfo { 608 u8 matchAll; /* "*" or "%" */ 609 u8 matchOne; /* "?" or "_" */ 610 u8 matchSet; /* "[" or 0 */ 611 u8 noCase; /* true to ignore case differences */ 612 }; 613 614 /* 615 ** For LIKE and GLOB matching on EBCDIC machines, assume that every 616 ** character is exactly one byte in size. Also, provde the Utf8Read() 617 ** macro for fast reading of the next character in the common case where 618 ** the next character is ASCII. 619 */ 620 #if defined(SQLITE_EBCDIC) 621 # define sqlite3Utf8Read(A) (*((*A)++)) 622 # define Utf8Read(A) (*(A++)) 623 #else 624 # define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A)) 625 #endif 626 627 static const struct compareInfo globInfo = { '*', '?', '[', 0 }; 628 /* The correct SQL-92 behavior is for the LIKE operator to ignore 629 ** case. Thus 'a' LIKE 'A' would be true. */ 630 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }; 631 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator 632 ** is case sensitive causing 'a' LIKE 'A' to be false */ 633 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }; 634 635 /* 636 ** Possible error returns from patternMatch() 637 */ 638 #define SQLITE_MATCH 0 639 #define SQLITE_NOMATCH 1 640 #define SQLITE_NOWILDCARDMATCH 2 641 642 /* 643 ** Compare two UTF-8 strings for equality where the first string is 644 ** a GLOB or LIKE expression. Return values: 645 ** 646 ** SQLITE_MATCH: Match 647 ** SQLITE_NOMATCH: No match 648 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards. 649 ** 650 ** Globbing rules: 651 ** 652 ** '*' Matches any sequence of zero or more characters. 653 ** 654 ** '?' Matches exactly one character. 655 ** 656 ** [...] Matches one character from the enclosed list of 657 ** characters. 658 ** 659 ** [^...] Matches one character not in the enclosed list. 660 ** 661 ** With the [...] and [^...] matching, a ']' character can be included 662 ** in the list by making it the first character after '[' or '^'. A 663 ** range of characters can be specified using '-'. Example: 664 ** "[a-z]" matches any single lower-case letter. To match a '-', make 665 ** it the last character in the list. 666 ** 667 ** Like matching rules: 668 ** 669 ** '%' Matches any sequence of zero or more characters 670 ** 671 *** '_' Matches any one character 672 ** 673 ** Ec Where E is the "esc" character and c is any other 674 ** character, including '%', '_', and esc, match exactly c. 675 ** 676 ** The comments within this routine usually assume glob matching. 677 ** 678 ** This routine is usually quick, but can be N**2 in the worst case. 679 */ 680 static int patternCompare( 681 const u8 *zPattern, /* The glob pattern */ 682 const u8 *zString, /* The string to compare against the glob */ 683 const struct compareInfo *pInfo, /* Information about how to do the compare */ 684 u32 matchOther /* The escape char (LIKE) or '[' (GLOB) */ 685 ){ 686 u32 c, c2; /* Next pattern and input string chars */ 687 u32 matchOne = pInfo->matchOne; /* "?" or "_" */ 688 u32 matchAll = pInfo->matchAll; /* "*" or "%" */ 689 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ 690 const u8 *zEscaped = 0; /* One past the last escaped input char */ 691 692 while( (c = Utf8Read(zPattern))!=0 ){ 693 if( c==matchAll ){ /* Match "*" */ 694 /* Skip over multiple "*" characters in the pattern. If there 695 ** are also "?" characters, skip those as well, but consume a 696 ** single character of the input string for each "?" skipped */ 697 while( (c=Utf8Read(zPattern)) == matchAll 698 || (c == matchOne && matchOne!=0) ){ 699 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ 700 return SQLITE_NOWILDCARDMATCH; 701 } 702 } 703 if( c==0 ){ 704 return SQLITE_MATCH; /* "*" at the end of the pattern matches */ 705 }else if( c==matchOther ){ 706 if( pInfo->matchSet==0 ){ 707 c = sqlite3Utf8Read(&zPattern); 708 if( c==0 ) return SQLITE_NOWILDCARDMATCH; 709 }else{ 710 /* "[...]" immediately follows the "*". We have to do a slow 711 ** recursive search in this case, but it is an unusual case. */ 712 assert( matchOther<0x80 ); /* '[' is a single-byte character */ 713 while( *zString ){ 714 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther); 715 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 716 SQLITE_SKIP_UTF8(zString); 717 } 718 return SQLITE_NOWILDCARDMATCH; 719 } 720 } 721 722 /* At this point variable c contains the first character of the 723 ** pattern string past the "*". Search in the input string for the 724 ** first matching character and recursively continue the match from 725 ** that point. 726 ** 727 ** For a case-insensitive search, set variable cx to be the same as 728 ** c but in the other case and search the input string for either 729 ** c or cx. 730 */ 731 if( c<=0x80 ){ 732 char zStop[3]; 733 int bMatch; 734 if( noCase ){ 735 zStop[0] = sqlite3Toupper(c); 736 zStop[1] = sqlite3Tolower(c); 737 zStop[2] = 0; 738 }else{ 739 zStop[0] = c; 740 zStop[1] = 0; 741 } 742 while(1){ 743 zString += strcspn((const char*)zString, zStop); 744 if( zString[0]==0 ) break; 745 zString++; 746 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 747 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 748 } 749 }else{ 750 int bMatch; 751 while( (c2 = Utf8Read(zString))!=0 ){ 752 if( c2!=c ) continue; 753 bMatch = patternCompare(zPattern,zString,pInfo,matchOther); 754 if( bMatch!=SQLITE_NOMATCH ) return bMatch; 755 } 756 } 757 return SQLITE_NOWILDCARDMATCH; 758 } 759 if( c==matchOther ){ 760 if( pInfo->matchSet==0 ){ 761 c = sqlite3Utf8Read(&zPattern); 762 if( c==0 ) return SQLITE_NOMATCH; 763 zEscaped = zPattern; 764 }else{ 765 u32 prior_c = 0; 766 int seen = 0; 767 int invert = 0; 768 c = sqlite3Utf8Read(&zString); 769 if( c==0 ) return SQLITE_NOMATCH; 770 c2 = sqlite3Utf8Read(&zPattern); 771 if( c2=='^' ){ 772 invert = 1; 773 c2 = sqlite3Utf8Read(&zPattern); 774 } 775 if( c2==']' ){ 776 if( c==']' ) seen = 1; 777 c2 = sqlite3Utf8Read(&zPattern); 778 } 779 while( c2 && c2!=']' ){ 780 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 781 c2 = sqlite3Utf8Read(&zPattern); 782 if( c>=prior_c && c<=c2 ) seen = 1; 783 prior_c = 0; 784 }else{ 785 if( c==c2 ){ 786 seen = 1; 787 } 788 prior_c = c2; 789 } 790 c2 = sqlite3Utf8Read(&zPattern); 791 } 792 if( c2==0 || (seen ^ invert)==0 ){ 793 return SQLITE_NOMATCH; 794 } 795 continue; 796 } 797 } 798 c2 = Utf8Read(zString); 799 if( c==c2 ) continue; 800 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ 801 continue; 802 } 803 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; 804 return SQLITE_NOMATCH; 805 } 806 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; 807 } 808 809 /* 810 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and 811 ** non-zero if there is no match. 812 */ 813 int sqlite3_strglob(const char *zGlobPattern, const char *zString){ 814 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); 815 } 816 817 /* 818 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for 819 ** a miss - like strcmp(). 820 */ 821 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ 822 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); 823 } 824 825 /* 826 ** Count the number of times that the LIKE operator (or GLOB which is 827 ** just a variation of LIKE) gets called. This is used for testing 828 ** only. 829 */ 830 #ifdef SQLITE_TEST 831 int sqlite3_like_count = 0; 832 #endif 833 834 835 /* 836 ** Implementation of the like() SQL function. This function implements 837 ** the build-in LIKE operator. The first argument to the function is the 838 ** pattern and the second argument is the string. So, the SQL statements: 839 ** 840 ** A LIKE B 841 ** 842 ** is implemented as like(B,A). 843 ** 844 ** This same function (with a different compareInfo structure) computes 845 ** the GLOB operator. 846 */ 847 static void likeFunc( 848 sqlite3_context *context, 849 int argc, 850 sqlite3_value **argv 851 ){ 852 const unsigned char *zA, *zB; 853 u32 escape; 854 int nPat; 855 sqlite3 *db = sqlite3_context_db_handle(context); 856 struct compareInfo *pInfo = sqlite3_user_data(context); 857 struct compareInfo backupInfo; 858 859 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS 860 if( sqlite3_value_type(argv[0])==SQLITE_BLOB 861 || sqlite3_value_type(argv[1])==SQLITE_BLOB 862 ){ 863 #ifdef SQLITE_TEST 864 sqlite3_like_count++; 865 #endif 866 sqlite3_result_int(context, 0); 867 return; 868 } 869 #endif 870 871 /* Limit the length of the LIKE or GLOB pattern to avoid problems 872 ** of deep recursion and N*N behavior in patternCompare(). 873 */ 874 nPat = sqlite3_value_bytes(argv[0]); 875 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); 876 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); 877 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ 878 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 879 return; 880 } 881 if( argc==3 ){ 882 /* The escape character string must consist of a single UTF-8 character. 883 ** Otherwise, return an error. 884 */ 885 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 886 if( zEsc==0 ) return; 887 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 888 sqlite3_result_error(context, 889 "ESCAPE expression must be a single character", -1); 890 return; 891 } 892 escape = sqlite3Utf8Read(&zEsc); 893 if( escape==pInfo->matchAll || escape==pInfo->matchOne ){ 894 memcpy(&backupInfo, pInfo, sizeof(backupInfo)); 895 pInfo = &backupInfo; 896 if( escape==pInfo->matchAll ) pInfo->matchAll = 0; 897 if( escape==pInfo->matchOne ) pInfo->matchOne = 0; 898 } 899 }else{ 900 escape = pInfo->matchSet; 901 } 902 zB = sqlite3_value_text(argv[0]); 903 zA = sqlite3_value_text(argv[1]); 904 if( zA && zB ){ 905 #ifdef SQLITE_TEST 906 sqlite3_like_count++; 907 #endif 908 sqlite3_result_int(context, 909 patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); 910 } 911 } 912 913 /* 914 ** Implementation of the NULLIF(x,y) function. The result is the first 915 ** argument if the arguments are different. The result is NULL if the 916 ** arguments are equal to each other. 917 */ 918 static void nullifFunc( 919 sqlite3_context *context, 920 int NotUsed, 921 sqlite3_value **argv 922 ){ 923 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 924 UNUSED_PARAMETER(NotUsed); 925 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 926 sqlite3_result_value(context, argv[0]); 927 } 928 } 929 930 /* 931 ** Implementation of the sqlite_version() function. The result is the version 932 ** of the SQLite library that is running. 933 */ 934 static void versionFunc( 935 sqlite3_context *context, 936 int NotUsed, 937 sqlite3_value **NotUsed2 938 ){ 939 UNUSED_PARAMETER2(NotUsed, NotUsed2); 940 /* IMP: R-48699-48617 This function is an SQL wrapper around the 941 ** sqlite3_libversion() C-interface. */ 942 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); 943 } 944 945 /* 946 ** Implementation of the sqlite_source_id() function. The result is a string 947 ** that identifies the particular version of the source code used to build 948 ** SQLite. 949 */ 950 static void sourceidFunc( 951 sqlite3_context *context, 952 int NotUsed, 953 sqlite3_value **NotUsed2 954 ){ 955 UNUSED_PARAMETER2(NotUsed, NotUsed2); 956 /* IMP: R-24470-31136 This function is an SQL wrapper around the 957 ** sqlite3_sourceid() C interface. */ 958 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); 959 } 960 961 /* 962 ** Implementation of the sqlite_log() function. This is a wrapper around 963 ** sqlite3_log(). The return value is NULL. The function exists purely for 964 ** its side-effects. 965 */ 966 static void errlogFunc( 967 sqlite3_context *context, 968 int argc, 969 sqlite3_value **argv 970 ){ 971 UNUSED_PARAMETER(argc); 972 UNUSED_PARAMETER(context); 973 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); 974 } 975 976 /* 977 ** Implementation of the sqlite_compileoption_used() function. 978 ** The result is an integer that identifies if the compiler option 979 ** was used to build SQLite. 980 */ 981 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 982 static void compileoptionusedFunc( 983 sqlite3_context *context, 984 int argc, 985 sqlite3_value **argv 986 ){ 987 const char *zOptName; 988 assert( argc==1 ); 989 UNUSED_PARAMETER(argc); 990 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL 991 ** function is a wrapper around the sqlite3_compileoption_used() C/C++ 992 ** function. 993 */ 994 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ 995 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); 996 } 997 } 998 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 999 1000 /* 1001 ** Implementation of the sqlite_compileoption_get() function. 1002 ** The result is a string that identifies the compiler options 1003 ** used to build SQLite. 1004 */ 1005 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 1006 static void compileoptiongetFunc( 1007 sqlite3_context *context, 1008 int argc, 1009 sqlite3_value **argv 1010 ){ 1011 int n; 1012 assert( argc==1 ); 1013 UNUSED_PARAMETER(argc); 1014 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function 1015 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. 1016 */ 1017 n = sqlite3_value_int(argv[0]); 1018 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); 1019 } 1020 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 1021 1022 /* Array for converting from half-bytes (nybbles) into ASCII hex 1023 ** digits. */ 1024 static const char hexdigits[] = { 1025 '0', '1', '2', '3', '4', '5', '6', '7', 1026 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 1027 }; 1028 1029 /* 1030 ** Append to pStr text that is the SQL literal representation of the 1031 ** value contained in pValue. 1032 */ 1033 void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){ 1034 /* As currently implemented, the string must be initially empty. 1035 ** we might relax this requirement in the future, but that will 1036 ** require enhancements to the implementation. */ 1037 assert( pStr!=0 && pStr->nChar==0 ); 1038 1039 switch( sqlite3_value_type(pValue) ){ 1040 case SQLITE_FLOAT: { 1041 double r1, r2; 1042 const char *zVal; 1043 r1 = sqlite3_value_double(pValue); 1044 sqlite3_str_appendf(pStr, "%!.15g", r1); 1045 zVal = sqlite3_str_value(pStr); 1046 if( zVal ){ 1047 sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8); 1048 if( r1!=r2 ){ 1049 sqlite3_str_reset(pStr); 1050 sqlite3_str_appendf(pStr, "%!.20e", r1); 1051 } 1052 } 1053 break; 1054 } 1055 case SQLITE_INTEGER: { 1056 sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue)); 1057 break; 1058 } 1059 case SQLITE_BLOB: { 1060 char const *zBlob = sqlite3_value_blob(pValue); 1061 int nBlob = sqlite3_value_bytes(pValue); 1062 assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */ 1063 sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4); 1064 if( pStr->accError==0 ){ 1065 char *zText = pStr->zText; 1066 int i; 1067 for(i=0; i<nBlob; i++){ 1068 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 1069 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 1070 } 1071 zText[(nBlob*2)+2] = '\''; 1072 zText[(nBlob*2)+3] = '\0'; 1073 zText[0] = 'X'; 1074 zText[1] = '\''; 1075 pStr->nChar = nBlob*2 + 3; 1076 } 1077 break; 1078 } 1079 case SQLITE_TEXT: { 1080 const unsigned char *zArg = sqlite3_value_text(pValue); 1081 sqlite3_str_appendf(pStr, "%Q", zArg); 1082 break; 1083 } 1084 default: { 1085 assert( sqlite3_value_type(pValue)==SQLITE_NULL ); 1086 sqlite3_str_append(pStr, "NULL", 4); 1087 break; 1088 } 1089 } 1090 } 1091 1092 /* 1093 ** Implementation of the QUOTE() function. 1094 ** 1095 ** The quote(X) function returns the text of an SQL literal which is the 1096 ** value of its argument suitable for inclusion into an SQL statement. 1097 ** Strings are surrounded by single-quotes with escapes on interior quotes 1098 ** as needed. BLOBs are encoded as hexadecimal literals. Strings with 1099 ** embedded NUL characters cannot be represented as string literals in SQL 1100 ** and hence the returned string literal is truncated prior to the first NUL. 1101 */ 1102 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 1103 sqlite3_str str; 1104 sqlite3 *db = sqlite3_context_db_handle(context); 1105 assert( argc==1 ); 1106 UNUSED_PARAMETER(argc); 1107 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); 1108 sqlite3QuoteValue(&str,argv[0]); 1109 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar, 1110 SQLITE_DYNAMIC); 1111 if( str.accError==SQLITE_NOMEM ){ 1112 sqlite3_result_error_nomem(context); 1113 } 1114 } 1115 1116 /* 1117 ** The unicode() function. Return the integer unicode code-point value 1118 ** for the first character of the input string. 1119 */ 1120 static void unicodeFunc( 1121 sqlite3_context *context, 1122 int argc, 1123 sqlite3_value **argv 1124 ){ 1125 const unsigned char *z = sqlite3_value_text(argv[0]); 1126 (void)argc; 1127 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); 1128 } 1129 1130 /* 1131 ** The char() function takes zero or more arguments, each of which is 1132 ** an integer. It constructs a string where each character of the string 1133 ** is the unicode character for the corresponding integer argument. 1134 */ 1135 static void charFunc( 1136 sqlite3_context *context, 1137 int argc, 1138 sqlite3_value **argv 1139 ){ 1140 unsigned char *z, *zOut; 1141 int i; 1142 zOut = z = sqlite3_malloc64( argc*4+1 ); 1143 if( z==0 ){ 1144 sqlite3_result_error_nomem(context); 1145 return; 1146 } 1147 for(i=0; i<argc; i++){ 1148 sqlite3_int64 x; 1149 unsigned c; 1150 x = sqlite3_value_int64(argv[i]); 1151 if( x<0 || x>0x10ffff ) x = 0xfffd; 1152 c = (unsigned)(x & 0x1fffff); 1153 if( c<0x00080 ){ 1154 *zOut++ = (u8)(c&0xFF); 1155 }else if( c<0x00800 ){ 1156 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); 1157 *zOut++ = 0x80 + (u8)(c & 0x3F); 1158 }else if( c<0x10000 ){ 1159 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); 1160 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1161 *zOut++ = 0x80 + (u8)(c & 0x3F); 1162 }else{ 1163 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); 1164 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); 1165 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); 1166 *zOut++ = 0x80 + (u8)(c & 0x3F); 1167 } \ 1168 } 1169 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); 1170 } 1171 1172 /* 1173 ** The hex() function. Interpret the argument as a blob. Return 1174 ** a hexadecimal rendering as text. 1175 */ 1176 static void hexFunc( 1177 sqlite3_context *context, 1178 int argc, 1179 sqlite3_value **argv 1180 ){ 1181 int i, n; 1182 const unsigned char *pBlob; 1183 char *zHex, *z; 1184 assert( argc==1 ); 1185 UNUSED_PARAMETER(argc); 1186 pBlob = sqlite3_value_blob(argv[0]); 1187 n = sqlite3_value_bytes(argv[0]); 1188 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 1189 z = zHex = contextMalloc(context, ((i64)n)*2 + 1); 1190 if( zHex ){ 1191 for(i=0; i<n; i++, pBlob++){ 1192 unsigned char c = *pBlob; 1193 *(z++) = hexdigits[(c>>4)&0xf]; 1194 *(z++) = hexdigits[c&0xf]; 1195 } 1196 *z = 0; 1197 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 1198 } 1199 } 1200 1201 /* 1202 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 1203 */ 1204 static void zeroblobFunc( 1205 sqlite3_context *context, 1206 int argc, 1207 sqlite3_value **argv 1208 ){ 1209 i64 n; 1210 int rc; 1211 assert( argc==1 ); 1212 UNUSED_PARAMETER(argc); 1213 n = sqlite3_value_int64(argv[0]); 1214 if( n<0 ) n = 0; 1215 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ 1216 if( rc ){ 1217 sqlite3_result_error_code(context, rc); 1218 } 1219 } 1220 1221 /* 1222 ** The replace() function. Three arguments are all strings: call 1223 ** them A, B, and C. The result is also a string which is derived 1224 ** from A by replacing every occurrence of B with C. The match 1225 ** must be exact. Collating sequences are not used. 1226 */ 1227 static void replaceFunc( 1228 sqlite3_context *context, 1229 int argc, 1230 sqlite3_value **argv 1231 ){ 1232 const unsigned char *zStr; /* The input string A */ 1233 const unsigned char *zPattern; /* The pattern string B */ 1234 const unsigned char *zRep; /* The replacement string C */ 1235 unsigned char *zOut; /* The output */ 1236 int nStr; /* Size of zStr */ 1237 int nPattern; /* Size of zPattern */ 1238 int nRep; /* Size of zRep */ 1239 i64 nOut; /* Maximum size of zOut */ 1240 int loopLimit; /* Last zStr[] that might match zPattern[] */ 1241 int i, j; /* Loop counters */ 1242 unsigned cntExpand; /* Number zOut expansions */ 1243 sqlite3 *db = sqlite3_context_db_handle(context); 1244 1245 assert( argc==3 ); 1246 UNUSED_PARAMETER(argc); 1247 zStr = sqlite3_value_text(argv[0]); 1248 if( zStr==0 ) return; 1249 nStr = sqlite3_value_bytes(argv[0]); 1250 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 1251 zPattern = sqlite3_value_text(argv[1]); 1252 if( zPattern==0 ){ 1253 assert( sqlite3_value_type(argv[1])==SQLITE_NULL 1254 || sqlite3_context_db_handle(context)->mallocFailed ); 1255 return; 1256 } 1257 if( zPattern[0]==0 ){ 1258 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); 1259 sqlite3_result_value(context, argv[0]); 1260 return; 1261 } 1262 nPattern = sqlite3_value_bytes(argv[1]); 1263 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 1264 zRep = sqlite3_value_text(argv[2]); 1265 if( zRep==0 ) return; 1266 nRep = sqlite3_value_bytes(argv[2]); 1267 assert( zRep==sqlite3_value_text(argv[2]) ); 1268 nOut = nStr + 1; 1269 assert( nOut<SQLITE_MAX_LENGTH ); 1270 zOut = contextMalloc(context, (i64)nOut); 1271 if( zOut==0 ){ 1272 return; 1273 } 1274 loopLimit = nStr - nPattern; 1275 cntExpand = 0; 1276 for(i=j=0; i<=loopLimit; i++){ 1277 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 1278 zOut[j++] = zStr[i]; 1279 }else{ 1280 if( nRep>nPattern ){ 1281 nOut += nRep - nPattern; 1282 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1283 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 1284 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1285 sqlite3_result_error_toobig(context); 1286 sqlite3_free(zOut); 1287 return; 1288 } 1289 cntExpand++; 1290 if( (cntExpand&(cntExpand-1))==0 ){ 1291 /* Grow the size of the output buffer only on substitutions 1292 ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */ 1293 u8 *zOld; 1294 zOld = zOut; 1295 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1)); 1296 if( zOut==0 ){ 1297 sqlite3_result_error_nomem(context); 1298 sqlite3_free(zOld); 1299 return; 1300 } 1301 } 1302 } 1303 memcpy(&zOut[j], zRep, nRep); 1304 j += nRep; 1305 i += nPattern-1; 1306 } 1307 } 1308 assert( j+nStr-i+1<=nOut ); 1309 memcpy(&zOut[j], &zStr[i], nStr-i); 1310 j += nStr - i; 1311 assert( j<=nOut ); 1312 zOut[j] = 0; 1313 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 1314 } 1315 1316 /* 1317 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 1318 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 1319 */ 1320 static void trimFunc( 1321 sqlite3_context *context, 1322 int argc, 1323 sqlite3_value **argv 1324 ){ 1325 const unsigned char *zIn; /* Input string */ 1326 const unsigned char *zCharSet; /* Set of characters to trim */ 1327 unsigned int nIn; /* Number of bytes in input */ 1328 int flags; /* 1: trimleft 2: trimright 3: trim */ 1329 int i; /* Loop counter */ 1330 unsigned int *aLen = 0; /* Length of each character in zCharSet */ 1331 unsigned char **azChar = 0; /* Individual characters in zCharSet */ 1332 int nChar; /* Number of characters in zCharSet */ 1333 1334 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 1335 return; 1336 } 1337 zIn = sqlite3_value_text(argv[0]); 1338 if( zIn==0 ) return; 1339 nIn = (unsigned)sqlite3_value_bytes(argv[0]); 1340 assert( zIn==sqlite3_value_text(argv[0]) ); 1341 if( argc==1 ){ 1342 static const unsigned lenOne[] = { 1 }; 1343 static unsigned char * const azOne[] = { (u8*)" " }; 1344 nChar = 1; 1345 aLen = (unsigned*)lenOne; 1346 azChar = (unsigned char **)azOne; 1347 zCharSet = 0; 1348 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 1349 return; 1350 }else{ 1351 const unsigned char *z; 1352 for(z=zCharSet, nChar=0; *z; nChar++){ 1353 SQLITE_SKIP_UTF8(z); 1354 } 1355 if( nChar>0 ){ 1356 azChar = contextMalloc(context, 1357 ((i64)nChar)*(sizeof(char*)+sizeof(unsigned))); 1358 if( azChar==0 ){ 1359 return; 1360 } 1361 aLen = (unsigned*)&azChar[nChar]; 1362 for(z=zCharSet, nChar=0; *z; nChar++){ 1363 azChar[nChar] = (unsigned char *)z; 1364 SQLITE_SKIP_UTF8(z); 1365 aLen[nChar] = (unsigned)(z - azChar[nChar]); 1366 } 1367 } 1368 } 1369 if( nChar>0 ){ 1370 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); 1371 if( flags & 1 ){ 1372 while( nIn>0 ){ 1373 unsigned int len = 0; 1374 for(i=0; i<nChar; i++){ 1375 len = aLen[i]; 1376 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break; 1377 } 1378 if( i>=nChar ) break; 1379 zIn += len; 1380 nIn -= len; 1381 } 1382 } 1383 if( flags & 2 ){ 1384 while( nIn>0 ){ 1385 unsigned int len = 0; 1386 for(i=0; i<nChar; i++){ 1387 len = aLen[i]; 1388 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 1389 } 1390 if( i>=nChar ) break; 1391 nIn -= len; 1392 } 1393 } 1394 if( zCharSet ){ 1395 sqlite3_free(azChar); 1396 } 1397 } 1398 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 1399 } 1400 1401 1402 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1403 /* 1404 ** The "unknown" function is automatically substituted in place of 1405 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN 1406 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used. 1407 ** When the "sqlite3" command-line shell is built using this functionality, 1408 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries 1409 ** involving application-defined functions to be examined in a generic 1410 ** sqlite3 shell. 1411 */ 1412 static void unknownFunc( 1413 sqlite3_context *context, 1414 int argc, 1415 sqlite3_value **argv 1416 ){ 1417 /* no-op */ 1418 } 1419 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ 1420 1421 1422 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It 1423 ** is only available if the SQLITE_SOUNDEX compile-time option is used 1424 ** when SQLite is built. 1425 */ 1426 #ifdef SQLITE_SOUNDEX 1427 /* 1428 ** Compute the soundex encoding of a word. 1429 ** 1430 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the 1431 ** soundex encoding of the string X. 1432 */ 1433 static void soundexFunc( 1434 sqlite3_context *context, 1435 int argc, 1436 sqlite3_value **argv 1437 ){ 1438 char zResult[8]; 1439 const u8 *zIn; 1440 int i, j; 1441 static const unsigned char iCode[] = { 1442 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1443 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1444 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1445 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1446 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1447 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1448 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 1449 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1450 }; 1451 assert( argc==1 ); 1452 zIn = (u8*)sqlite3_value_text(argv[0]); 1453 if( zIn==0 ) zIn = (u8*)""; 1454 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} 1455 if( zIn[i] ){ 1456 u8 prevcode = iCode[zIn[i]&0x7f]; 1457 zResult[0] = sqlite3Toupper(zIn[i]); 1458 for(j=1; j<4 && zIn[i]; i++){ 1459 int code = iCode[zIn[i]&0x7f]; 1460 if( code>0 ){ 1461 if( code!=prevcode ){ 1462 prevcode = code; 1463 zResult[j++] = code + '0'; 1464 } 1465 }else{ 1466 prevcode = 0; 1467 } 1468 } 1469 while( j<4 ){ 1470 zResult[j++] = '0'; 1471 } 1472 zResult[j] = 0; 1473 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 1474 }else{ 1475 /* IMP: R-64894-50321 The string "?000" is returned if the argument 1476 ** is NULL or contains no ASCII alphabetic characters. */ 1477 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 1478 } 1479 } 1480 #endif /* SQLITE_SOUNDEX */ 1481 1482 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1483 /* 1484 ** A function that loads a shared-library extension then returns NULL. 1485 */ 1486 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 1487 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 1488 const char *zProc; 1489 sqlite3 *db = sqlite3_context_db_handle(context); 1490 char *zErrMsg = 0; 1491 1492 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc 1493 ** flag is set. See the sqlite3_enable_load_extension() API. 1494 */ 1495 if( (db->flags & SQLITE_LoadExtFunc)==0 ){ 1496 sqlite3_result_error(context, "not authorized", -1); 1497 return; 1498 } 1499 1500 if( argc==2 ){ 1501 zProc = (const char *)sqlite3_value_text(argv[1]); 1502 }else{ 1503 zProc = 0; 1504 } 1505 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1506 sqlite3_result_error(context, zErrMsg, -1); 1507 sqlite3_free(zErrMsg); 1508 } 1509 } 1510 #endif 1511 1512 1513 /* 1514 ** An instance of the following structure holds the context of a 1515 ** sum() or avg() aggregate computation. 1516 */ 1517 typedef struct SumCtx SumCtx; 1518 struct SumCtx { 1519 double rSum; /* Floating point sum */ 1520 i64 iSum; /* Integer sum */ 1521 i64 cnt; /* Number of elements summed */ 1522 u8 overflow; /* True if integer overflow seen */ 1523 u8 approx; /* True if non-integer value was input to the sum */ 1524 }; 1525 1526 /* 1527 ** Routines used to compute the sum, average, and total. 1528 ** 1529 ** The SUM() function follows the (broken) SQL standard which means 1530 ** that it returns NULL if it sums over no inputs. TOTAL returns 1531 ** 0.0 in that case. In addition, TOTAL always returns a float where 1532 ** SUM might return an integer if it never encounters a floating point 1533 ** value. TOTAL never fails, but SUM might through an exception if 1534 ** it overflows an integer. 1535 */ 1536 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1537 SumCtx *p; 1538 int type; 1539 assert( argc==1 ); 1540 UNUSED_PARAMETER(argc); 1541 p = sqlite3_aggregate_context(context, sizeof(*p)); 1542 type = sqlite3_value_numeric_type(argv[0]); 1543 if( p && type!=SQLITE_NULL ){ 1544 p->cnt++; 1545 if( type==SQLITE_INTEGER ){ 1546 i64 v = sqlite3_value_int64(argv[0]); 1547 p->rSum += v; 1548 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ 1549 p->approx = p->overflow = 1; 1550 } 1551 }else{ 1552 p->rSum += sqlite3_value_double(argv[0]); 1553 p->approx = 1; 1554 } 1555 } 1556 } 1557 #ifndef SQLITE_OMIT_WINDOWFUNC 1558 static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){ 1559 SumCtx *p; 1560 int type; 1561 assert( argc==1 ); 1562 UNUSED_PARAMETER(argc); 1563 p = sqlite3_aggregate_context(context, sizeof(*p)); 1564 type = sqlite3_value_numeric_type(argv[0]); 1565 /* p is always non-NULL because sumStep() will have been called first 1566 ** to initialize it */ 1567 if( ALWAYS(p) && type!=SQLITE_NULL ){ 1568 assert( p->cnt>0 ); 1569 p->cnt--; 1570 assert( type==SQLITE_INTEGER || p->approx ); 1571 if( type==SQLITE_INTEGER && p->approx==0 ){ 1572 i64 v = sqlite3_value_int64(argv[0]); 1573 p->rSum -= v; 1574 p->iSum -= v; 1575 }else{ 1576 p->rSum -= sqlite3_value_double(argv[0]); 1577 } 1578 } 1579 } 1580 #else 1581 # define sumInverse 0 1582 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1583 static void sumFinalize(sqlite3_context *context){ 1584 SumCtx *p; 1585 p = sqlite3_aggregate_context(context, 0); 1586 if( p && p->cnt>0 ){ 1587 if( p->overflow ){ 1588 sqlite3_result_error(context,"integer overflow",-1); 1589 }else if( p->approx ){ 1590 sqlite3_result_double(context, p->rSum); 1591 }else{ 1592 sqlite3_result_int64(context, p->iSum); 1593 } 1594 } 1595 } 1596 static void avgFinalize(sqlite3_context *context){ 1597 SumCtx *p; 1598 p = sqlite3_aggregate_context(context, 0); 1599 if( p && p->cnt>0 ){ 1600 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1601 } 1602 } 1603 static void totalFinalize(sqlite3_context *context){ 1604 SumCtx *p; 1605 p = sqlite3_aggregate_context(context, 0); 1606 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ 1607 sqlite3_result_double(context, p ? p->rSum : (double)0); 1608 } 1609 1610 /* 1611 ** The following structure keeps track of state information for the 1612 ** count() aggregate function. 1613 */ 1614 typedef struct CountCtx CountCtx; 1615 struct CountCtx { 1616 i64 n; 1617 #ifdef SQLITE_DEBUG 1618 int bInverse; /* True if xInverse() ever called */ 1619 #endif 1620 }; 1621 1622 /* 1623 ** Routines to implement the count() aggregate function. 1624 */ 1625 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1626 CountCtx *p; 1627 p = sqlite3_aggregate_context(context, sizeof(*p)); 1628 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1629 p->n++; 1630 } 1631 1632 #ifndef SQLITE_OMIT_DEPRECATED 1633 /* The sqlite3_aggregate_count() function is deprecated. But just to make 1634 ** sure it still operates correctly, verify that its count agrees with our 1635 ** internal count when using count(*) and when the total count can be 1636 ** expressed as a 32-bit integer. */ 1637 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse 1638 || p->n==sqlite3_aggregate_count(context) ); 1639 #endif 1640 } 1641 static void countFinalize(sqlite3_context *context){ 1642 CountCtx *p; 1643 p = sqlite3_aggregate_context(context, 0); 1644 sqlite3_result_int64(context, p ? p->n : 0); 1645 } 1646 #ifndef SQLITE_OMIT_WINDOWFUNC 1647 static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){ 1648 CountCtx *p; 1649 p = sqlite3_aggregate_context(ctx, sizeof(*p)); 1650 /* p is always non-NULL since countStep() will have been called first */ 1651 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){ 1652 p->n--; 1653 #ifdef SQLITE_DEBUG 1654 p->bInverse = 1; 1655 #endif 1656 } 1657 } 1658 #else 1659 # define countInverse 0 1660 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1661 1662 /* 1663 ** Routines to implement min() and max() aggregate functions. 1664 */ 1665 static void minmaxStep( 1666 sqlite3_context *context, 1667 int NotUsed, 1668 sqlite3_value **argv 1669 ){ 1670 Mem *pArg = (Mem *)argv[0]; 1671 Mem *pBest; 1672 UNUSED_PARAMETER(NotUsed); 1673 1674 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1675 if( !pBest ) return; 1676 1677 if( sqlite3_value_type(pArg)==SQLITE_NULL ){ 1678 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); 1679 }else if( pBest->flags ){ 1680 int max; 1681 int cmp; 1682 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1683 /* This step function is used for both the min() and max() aggregates, 1684 ** the only difference between the two being that the sense of the 1685 ** comparison is inverted. For the max() aggregate, the 1686 ** sqlite3_user_data() function returns (void *)-1. For min() it 1687 ** returns (void *)db, where db is the sqlite3* database pointer. 1688 ** Therefore the next statement sets variable 'max' to 1 for the max() 1689 ** aggregate, or 0 for min(). 1690 */ 1691 max = sqlite3_user_data(context)!=0; 1692 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1693 if( (max && cmp<0) || (!max && cmp>0) ){ 1694 sqlite3VdbeMemCopy(pBest, pArg); 1695 }else{ 1696 sqlite3SkipAccumulatorLoad(context); 1697 } 1698 }else{ 1699 pBest->db = sqlite3_context_db_handle(context); 1700 sqlite3VdbeMemCopy(pBest, pArg); 1701 } 1702 } 1703 static void minMaxValueFinalize(sqlite3_context *context, int bValue){ 1704 sqlite3_value *pRes; 1705 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1706 if( pRes ){ 1707 if( pRes->flags ){ 1708 sqlite3_result_value(context, pRes); 1709 } 1710 if( bValue==0 ) sqlite3VdbeMemRelease(pRes); 1711 } 1712 } 1713 #ifndef SQLITE_OMIT_WINDOWFUNC 1714 static void minMaxValue(sqlite3_context *context){ 1715 minMaxValueFinalize(context, 1); 1716 } 1717 #else 1718 # define minMaxValue 0 1719 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1720 static void minMaxFinalize(sqlite3_context *context){ 1721 minMaxValueFinalize(context, 0); 1722 } 1723 1724 /* 1725 ** group_concat(EXPR, ?SEPARATOR?) 1726 ** 1727 ** The SEPARATOR goes before the EXPR string. This is tragic. The 1728 ** groupConcatInverse() implementation would have been easier if the 1729 ** SEPARATOR were appended after EXPR. And the order is undocumented, 1730 ** so we could change it, in theory. But the old behavior has been 1731 ** around for so long that we dare not, for fear of breaking something. 1732 */ 1733 typedef struct { 1734 StrAccum str; /* The accumulated concatenation */ 1735 #ifndef SQLITE_OMIT_WINDOWFUNC 1736 int nAccum; /* Number of strings presently concatenated */ 1737 int nFirstSepLength; /* Used to detect separator length change */ 1738 /* If pnSepLengths!=0, refs an array of inter-string separator lengths, 1739 ** stored as actually incorporated into presently accumulated result. 1740 ** (Hence, its slots in use number nAccum-1 between method calls.) 1741 ** If pnSepLengths==0, nFirstSepLength is the length used throughout. 1742 */ 1743 int *pnSepLengths; 1744 #endif 1745 } GroupConcatCtx; 1746 1747 static void groupConcatStep( 1748 sqlite3_context *context, 1749 int argc, 1750 sqlite3_value **argv 1751 ){ 1752 const char *zVal; 1753 GroupConcatCtx *pGCC; 1754 const char *zSep; 1755 int nVal, nSep; 1756 assert( argc==1 || argc==2 ); 1757 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1758 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC)); 1759 if( pGCC ){ 1760 sqlite3 *db = sqlite3_context_db_handle(context); 1761 int firstTerm = pGCC->str.mxAlloc==0; 1762 pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; 1763 if( argc==1 ){ 1764 if( !firstTerm ){ 1765 sqlite3_str_appendchar(&pGCC->str, 1, ','); 1766 } 1767 #ifndef SQLITE_OMIT_WINDOWFUNC 1768 else{ 1769 pGCC->nFirstSepLength = 1; 1770 } 1771 #endif 1772 }else if( !firstTerm ){ 1773 zSep = (char*)sqlite3_value_text(argv[1]); 1774 nSep = sqlite3_value_bytes(argv[1]); 1775 if( zSep ){ 1776 sqlite3_str_append(&pGCC->str, zSep, nSep); 1777 } 1778 #ifndef SQLITE_OMIT_WINDOWFUNC 1779 else{ 1780 nSep = 0; 1781 } 1782 if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){ 1783 int *pnsl = pGCC->pnSepLengths; 1784 if( pnsl == 0 ){ 1785 /* First separator length variation seen, start tracking them. */ 1786 pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int)); 1787 if( pnsl!=0 ){ 1788 int i = 0, nA = pGCC->nAccum-1; 1789 while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength; 1790 } 1791 }else{ 1792 pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int)); 1793 } 1794 if( pnsl!=0 ){ 1795 if( ALWAYS(pGCC->nAccum>0) ){ 1796 pnsl[pGCC->nAccum-1] = nSep; 1797 } 1798 pGCC->pnSepLengths = pnsl; 1799 }else{ 1800 sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM); 1801 } 1802 } 1803 #endif 1804 } 1805 #ifndef SQLITE_OMIT_WINDOWFUNC 1806 else{ 1807 pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]); 1808 } 1809 pGCC->nAccum += 1; 1810 #endif 1811 zVal = (char*)sqlite3_value_text(argv[0]); 1812 nVal = sqlite3_value_bytes(argv[0]); 1813 if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal); 1814 } 1815 } 1816 1817 #ifndef SQLITE_OMIT_WINDOWFUNC 1818 static void groupConcatInverse( 1819 sqlite3_context *context, 1820 int argc, 1821 sqlite3_value **argv 1822 ){ 1823 GroupConcatCtx *pGCC; 1824 assert( argc==1 || argc==2 ); 1825 (void)argc; /* Suppress unused parameter warning */ 1826 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1827 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC)); 1828 /* pGCC is always non-NULL since groupConcatStep() will have always 1829 ** run frist to initialize it */ 1830 if( ALWAYS(pGCC) ){ 1831 int nVS; 1832 /* Must call sqlite3_value_text() to convert the argument into text prior 1833 ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */ 1834 (void)sqlite3_value_text(argv[0]); 1835 nVS = sqlite3_value_bytes(argv[0]); 1836 pGCC->nAccum -= 1; 1837 if( pGCC->pnSepLengths!=0 ){ 1838 assert(pGCC->nAccum >= 0); 1839 if( pGCC->nAccum>0 ){ 1840 nVS += *pGCC->pnSepLengths; 1841 memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1, 1842 (pGCC->nAccum-1)*sizeof(int)); 1843 } 1844 }else{ 1845 /* If removing single accumulated string, harmlessly over-do. */ 1846 nVS += pGCC->nFirstSepLength; 1847 } 1848 if( nVS>=(int)pGCC->str.nChar ){ 1849 pGCC->str.nChar = 0; 1850 }else{ 1851 pGCC->str.nChar -= nVS; 1852 memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar); 1853 } 1854 if( pGCC->str.nChar==0 ){ 1855 pGCC->str.mxAlloc = 0; 1856 sqlite3_free(pGCC->pnSepLengths); 1857 pGCC->pnSepLengths = 0; 1858 } 1859 } 1860 } 1861 #else 1862 # define groupConcatInverse 0 1863 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1864 static void groupConcatFinalize(sqlite3_context *context){ 1865 GroupConcatCtx *pGCC 1866 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); 1867 if( pGCC ){ 1868 sqlite3ResultStrAccum(context, &pGCC->str); 1869 #ifndef SQLITE_OMIT_WINDOWFUNC 1870 sqlite3_free(pGCC->pnSepLengths); 1871 #endif 1872 } 1873 } 1874 #ifndef SQLITE_OMIT_WINDOWFUNC 1875 static void groupConcatValue(sqlite3_context *context){ 1876 GroupConcatCtx *pGCC 1877 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); 1878 if( pGCC ){ 1879 StrAccum *pAccum = &pGCC->str; 1880 if( pAccum->accError==SQLITE_TOOBIG ){ 1881 sqlite3_result_error_toobig(context); 1882 }else if( pAccum->accError==SQLITE_NOMEM ){ 1883 sqlite3_result_error_nomem(context); 1884 }else{ 1885 const char *zText = sqlite3_str_value(pAccum); 1886 sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT); 1887 } 1888 } 1889 } 1890 #else 1891 # define groupConcatValue 0 1892 #endif /* SQLITE_OMIT_WINDOWFUNC */ 1893 1894 /* 1895 ** This routine does per-connection function registration. Most 1896 ** of the built-in functions above are part of the global function set. 1897 ** This routine only deals with those that are not global. 1898 */ 1899 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ 1900 int rc = sqlite3_overload_function(db, "MATCH", 2); 1901 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1902 if( rc==SQLITE_NOMEM ){ 1903 sqlite3OomFault(db); 1904 } 1905 } 1906 1907 /* 1908 ** Re-register the built-in LIKE functions. The caseSensitive 1909 ** parameter determines whether or not the LIKE operator is case 1910 ** sensitive. 1911 */ 1912 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1913 struct compareInfo *pInfo; 1914 int flags; 1915 if( caseSensitive ){ 1916 pInfo = (struct compareInfo*)&likeInfoAlt; 1917 flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE; 1918 }else{ 1919 pInfo = (struct compareInfo*)&likeInfoNorm; 1920 flags = SQLITE_FUNC_LIKE; 1921 } 1922 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 1923 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 1924 sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags; 1925 sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags; 1926 } 1927 1928 /* 1929 ** pExpr points to an expression which implements a function. If 1930 ** it is appropriate to apply the LIKE optimization to that function 1931 ** then set aWc[0] through aWc[2] to the wildcard characters and the 1932 ** escape character and then return TRUE. If the function is not a 1933 ** LIKE-style function then return FALSE. 1934 ** 1935 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE 1936 ** operator if c is a string literal that is exactly one byte in length. 1937 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is 1938 ** no ESCAPE clause. 1939 ** 1940 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for 1941 ** the function (default for LIKE). If the function makes the distinction 1942 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to 1943 ** false. 1944 */ 1945 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1946 FuncDef *pDef; 1947 int nExpr; 1948 assert( pExpr!=0 ); 1949 assert( pExpr->op==TK_FUNCTION ); 1950 assert( ExprUseXList(pExpr) ); 1951 if( !pExpr->x.pList ){ 1952 return 0; 1953 } 1954 nExpr = pExpr->x.pList->nExpr; 1955 assert( !ExprHasProperty(pExpr, EP_IntValue) ); 1956 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); 1957 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 1958 if( pDef==0 ) return 0; 1959 #endif 1960 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ 1961 return 0; 1962 } 1963 1964 /* The memcpy() statement assumes that the wildcard characters are 1965 ** the first three statements in the compareInfo structure. The 1966 ** asserts() that follow verify that assumption 1967 */ 1968 memcpy(aWc, pDef->pUserData, 3); 1969 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1970 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1971 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1972 1973 if( nExpr<3 ){ 1974 aWc[3] = 0; 1975 }else{ 1976 Expr *pEscape = pExpr->x.pList->a[2].pExpr; 1977 char *zEscape; 1978 if( pEscape->op!=TK_STRING ) return 0; 1979 assert( !ExprHasProperty(pEscape, EP_IntValue) ); 1980 zEscape = pEscape->u.zToken; 1981 if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; 1982 if( zEscape[0]==aWc[0] ) return 0; 1983 if( zEscape[0]==aWc[1] ) return 0; 1984 aWc[3] = zEscape[0]; 1985 } 1986 1987 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; 1988 return 1; 1989 } 1990 1991 /* Mathematical Constants */ 1992 #ifndef M_PI 1993 # define M_PI 3.141592653589793238462643383279502884 1994 #endif 1995 #ifndef M_LN10 1996 # define M_LN10 2.302585092994045684017991454684364208 1997 #endif 1998 #ifndef M_LN2 1999 # define M_LN2 0.693147180559945309417232121458176568 2000 #endif 2001 2002 2003 /* Extra math functions that require linking with -lm 2004 */ 2005 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS 2006 /* 2007 ** Implementation SQL functions: 2008 ** 2009 ** ceil(X) 2010 ** ceiling(X) 2011 ** floor(X) 2012 ** 2013 ** The sqlite3_user_data() pointer is a pointer to the libm implementation 2014 ** of the underlying C function. 2015 */ 2016 static void ceilingFunc( 2017 sqlite3_context *context, 2018 int argc, 2019 sqlite3_value **argv 2020 ){ 2021 assert( argc==1 ); 2022 switch( sqlite3_value_numeric_type(argv[0]) ){ 2023 case SQLITE_INTEGER: { 2024 sqlite3_result_int64(context, sqlite3_value_int64(argv[0])); 2025 break; 2026 } 2027 case SQLITE_FLOAT: { 2028 double (*x)(double) = (double(*)(double))sqlite3_user_data(context); 2029 sqlite3_result_double(context, x(sqlite3_value_double(argv[0]))); 2030 break; 2031 } 2032 default: { 2033 break; 2034 } 2035 } 2036 } 2037 2038 /* 2039 ** On some systems, ceil() and floor() are intrinsic function. You are 2040 ** unable to take a pointer to these functions. Hence, we here wrap them 2041 ** in our own actual functions. 2042 */ 2043 static double xCeil(double x){ return ceil(x); } 2044 static double xFloor(double x){ return floor(x); } 2045 2046 /* 2047 ** Implementation of SQL functions: 2048 ** 2049 ** ln(X) - natural logarithm 2050 ** log(X) - log X base 10 2051 ** log10(X) - log X base 10 2052 ** log(B,X) - log X base B 2053 */ 2054 static void logFunc( 2055 sqlite3_context *context, 2056 int argc, 2057 sqlite3_value **argv 2058 ){ 2059 double x, b, ans; 2060 assert( argc==1 || argc==2 ); 2061 switch( sqlite3_value_numeric_type(argv[0]) ){ 2062 case SQLITE_INTEGER: 2063 case SQLITE_FLOAT: 2064 x = sqlite3_value_double(argv[0]); 2065 if( x<=0.0 ) return; 2066 break; 2067 default: 2068 return; 2069 } 2070 if( argc==2 ){ 2071 switch( sqlite3_value_numeric_type(argv[0]) ){ 2072 case SQLITE_INTEGER: 2073 case SQLITE_FLOAT: 2074 b = log(x); 2075 if( b<=0.0 ) return; 2076 x = sqlite3_value_double(argv[1]); 2077 if( x<=0.0 ) return; 2078 break; 2079 default: 2080 return; 2081 } 2082 ans = log(x)/b; 2083 }else{ 2084 ans = log(x); 2085 switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){ 2086 case 1: 2087 /* Convert from natural logarithm to log base 10 */ 2088 ans *= 1.0/M_LN10; 2089 break; 2090 case 2: 2091 /* Convert from natural logarithm to log base 2 */ 2092 ans *= 1.0/M_LN2; 2093 break; 2094 default: 2095 break; 2096 } 2097 } 2098 sqlite3_result_double(context, ans); 2099 } 2100 2101 /* 2102 ** Functions to converts degrees to radians and radians to degrees. 2103 */ 2104 static double degToRad(double x){ return x*(M_PI/180.0); } 2105 static double radToDeg(double x){ return x*(180.0/M_PI); } 2106 2107 /* 2108 ** Implementation of 1-argument SQL math functions: 2109 ** 2110 ** exp(X) - Compute e to the X-th power 2111 */ 2112 static void math1Func( 2113 sqlite3_context *context, 2114 int argc, 2115 sqlite3_value **argv 2116 ){ 2117 int type0; 2118 double v0, ans; 2119 double (*x)(double); 2120 assert( argc==1 ); 2121 type0 = sqlite3_value_numeric_type(argv[0]); 2122 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2123 v0 = sqlite3_value_double(argv[0]); 2124 x = (double(*)(double))sqlite3_user_data(context); 2125 ans = x(v0); 2126 sqlite3_result_double(context, ans); 2127 } 2128 2129 /* 2130 ** Implementation of 2-argument SQL math functions: 2131 ** 2132 ** power(X,Y) - Compute X to the Y-th power 2133 */ 2134 static void math2Func( 2135 sqlite3_context *context, 2136 int argc, 2137 sqlite3_value **argv 2138 ){ 2139 int type0, type1; 2140 double v0, v1, ans; 2141 double (*x)(double,double); 2142 assert( argc==2 ); 2143 type0 = sqlite3_value_numeric_type(argv[0]); 2144 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2145 type1 = sqlite3_value_numeric_type(argv[1]); 2146 if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return; 2147 v0 = sqlite3_value_double(argv[0]); 2148 v1 = sqlite3_value_double(argv[1]); 2149 x = (double(*)(double,double))sqlite3_user_data(context); 2150 ans = x(v0, v1); 2151 sqlite3_result_double(context, ans); 2152 } 2153 2154 /* 2155 ** Implementation of 0-argument pi() function. 2156 */ 2157 static void piFunc( 2158 sqlite3_context *context, 2159 int argc, 2160 sqlite3_value **argv 2161 ){ 2162 assert( argc==0 ); 2163 sqlite3_result_double(context, M_PI); 2164 } 2165 2166 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ 2167 2168 /* 2169 ** Implementation of sign(X) function. 2170 */ 2171 static void signFunc( 2172 sqlite3_context *context, 2173 int argc, 2174 sqlite3_value **argv 2175 ){ 2176 int type0; 2177 double x; 2178 UNUSED_PARAMETER(argc); 2179 assert( argc==1 ); 2180 type0 = sqlite3_value_numeric_type(argv[0]); 2181 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; 2182 x = sqlite3_value_double(argv[0]); 2183 sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0); 2184 } 2185 2186 /* 2187 ** All of the FuncDef structures in the aBuiltinFunc[] array above 2188 ** to the global function hash table. This occurs at start-time (as 2189 ** a consequence of calling sqlite3_initialize()). 2190 ** 2191 ** After this routine runs 2192 */ 2193 void sqlite3RegisterBuiltinFunctions(void){ 2194 /* 2195 ** The following array holds FuncDef structures for all of the functions 2196 ** defined in this file. 2197 ** 2198 ** The array cannot be constant since changes are made to the 2199 ** FuncDef.pHash elements at start-time. The elements of this array 2200 ** are read-only after initialization is complete. 2201 ** 2202 ** For peak efficiency, put the most frequently used function last. 2203 */ 2204 static FuncDef aBuiltinFunc[] = { 2205 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/ 2206 #if !defined(SQLITE_UNTESTABLE) 2207 TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0), 2208 TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0), 2209 TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0), 2210 TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), 2211 #endif /* !defined(SQLITE_UNTESTABLE) */ 2212 /***** Regular functions *****/ 2213 #ifdef SQLITE_SOUNDEX 2214 FUNCTION(soundex, 1, 0, 0, soundexFunc ), 2215 #endif 2216 #ifndef SQLITE_OMIT_LOAD_EXTENSION 2217 SFUNCTION(load_extension, 1, 0, 0, loadExt ), 2218 SFUNCTION(load_extension, 2, 0, 0, loadExt ), 2219 #endif 2220 #if SQLITE_USER_AUTHENTICATION 2221 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), 2222 #endif 2223 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 2224 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), 2225 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), 2226 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ 2227 INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2228 INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2229 INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), 2230 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC 2231 FUNCTION2(sqlite_offset, 1, 0, 0, noopFunc, SQLITE_FUNC_OFFSET| 2232 SQLITE_FUNC_TYPEOF), 2233 #endif 2234 FUNCTION(ltrim, 1, 1, 0, trimFunc ), 2235 FUNCTION(ltrim, 2, 1, 0, trimFunc ), 2236 FUNCTION(rtrim, 1, 2, 0, trimFunc ), 2237 FUNCTION(rtrim, 2, 2, 0, trimFunc ), 2238 FUNCTION(trim, 1, 3, 0, trimFunc ), 2239 FUNCTION(trim, 2, 3, 0, trimFunc ), 2240 FUNCTION(min, -1, 0, 1, minmaxFunc ), 2241 FUNCTION(min, 0, 0, 1, 0 ), 2242 WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 2243 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), 2244 FUNCTION(max, -1, 1, 1, minmaxFunc ), 2245 FUNCTION(max, 0, 1, 1, 0 ), 2246 WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 2247 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), 2248 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), 2249 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), 2250 FUNCTION(instr, 2, 0, 0, instrFunc ), 2251 FUNCTION(printf, -1, 0, 0, printfFunc ), 2252 FUNCTION(unicode, 1, 0, 0, unicodeFunc ), 2253 FUNCTION(char, -1, 0, 0, charFunc ), 2254 FUNCTION(abs, 1, 0, 0, absFunc ), 2255 #ifndef SQLITE_OMIT_FLOATING_POINT 2256 FUNCTION(round, 1, 0, 0, roundFunc ), 2257 FUNCTION(round, 2, 0, 0, roundFunc ), 2258 #endif 2259 FUNCTION(upper, 1, 0, 0, upperFunc ), 2260 FUNCTION(lower, 1, 0, 0, lowerFunc ), 2261 FUNCTION(hex, 1, 0, 0, hexFunc ), 2262 INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ), 2263 VFUNCTION(random, 0, 0, 0, randomFunc ), 2264 VFUNCTION(randomblob, 1, 0, 0, randomBlob ), 2265 FUNCTION(nullif, 2, 0, 1, nullifFunc ), 2266 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), 2267 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), 2268 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), 2269 FUNCTION(quote, 1, 0, 0, quoteFunc ), 2270 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), 2271 VFUNCTION(changes, 0, 0, 0, changes ), 2272 VFUNCTION(total_changes, 0, 0, 0, total_changes ), 2273 FUNCTION(replace, 3, 0, 0, replaceFunc ), 2274 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), 2275 FUNCTION(substr, 2, 0, 0, substrFunc ), 2276 FUNCTION(substr, 3, 0, 0, substrFunc ), 2277 FUNCTION(substring, 2, 0, 0, substrFunc ), 2278 FUNCTION(substring, 3, 0, 0, substrFunc ), 2279 WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0), 2280 WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), 2281 WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), 2282 WAGGREGATE(count, 0,0,0, countStep, 2283 countFinalize, countFinalize, countInverse, 2284 SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER ), 2285 WAGGREGATE(count, 1,0,0, countStep, 2286 countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ), 2287 WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep, 2288 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 2289 WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep, 2290 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 2291 2292 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2293 #ifdef SQLITE_CASE_SENSITIVE_LIKE 2294 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2295 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), 2296 #else 2297 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), 2298 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), 2299 #endif 2300 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION 2301 FUNCTION(unknown, -1, 0, 0, unknownFunc ), 2302 #endif 2303 FUNCTION(coalesce, 1, 0, 0, 0 ), 2304 FUNCTION(coalesce, 0, 0, 0, 0 ), 2305 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS 2306 MFUNCTION(ceil, 1, xCeil, ceilingFunc ), 2307 MFUNCTION(ceiling, 1, xCeil, ceilingFunc ), 2308 MFUNCTION(floor, 1, xFloor, ceilingFunc ), 2309 #if SQLITE_HAVE_C99_MATH_FUNCS 2310 MFUNCTION(trunc, 1, trunc, ceilingFunc ), 2311 #endif 2312 FUNCTION(ln, 1, 0, 0, logFunc ), 2313 FUNCTION(log, 1, 1, 0, logFunc ), 2314 FUNCTION(log10, 1, 1, 0, logFunc ), 2315 FUNCTION(log2, 1, 2, 0, logFunc ), 2316 FUNCTION(log, 2, 0, 0, logFunc ), 2317 MFUNCTION(exp, 1, exp, math1Func ), 2318 MFUNCTION(pow, 2, pow, math2Func ), 2319 MFUNCTION(power, 2, pow, math2Func ), 2320 MFUNCTION(mod, 2, fmod, math2Func ), 2321 MFUNCTION(acos, 1, acos, math1Func ), 2322 MFUNCTION(asin, 1, asin, math1Func ), 2323 MFUNCTION(atan, 1, atan, math1Func ), 2324 MFUNCTION(atan2, 2, atan2, math2Func ), 2325 MFUNCTION(cos, 1, cos, math1Func ), 2326 MFUNCTION(sin, 1, sin, math1Func ), 2327 MFUNCTION(tan, 1, tan, math1Func ), 2328 MFUNCTION(cosh, 1, cosh, math1Func ), 2329 MFUNCTION(sinh, 1, sinh, math1Func ), 2330 MFUNCTION(tanh, 1, tanh, math1Func ), 2331 #if SQLITE_HAVE_C99_MATH_FUNCS 2332 MFUNCTION(acosh, 1, acosh, math1Func ), 2333 MFUNCTION(asinh, 1, asinh, math1Func ), 2334 MFUNCTION(atanh, 1, atanh, math1Func ), 2335 #endif 2336 MFUNCTION(sqrt, 1, sqrt, math1Func ), 2337 MFUNCTION(radians, 1, degToRad, math1Func ), 2338 MFUNCTION(degrees, 1, radToDeg, math1Func ), 2339 FUNCTION(pi, 0, 0, 0, piFunc ), 2340 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ 2341 FUNCTION(sign, 1, 0, 0, signFunc ), 2342 INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ), 2343 INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ), 2344 }; 2345 #ifndef SQLITE_OMIT_ALTERTABLE 2346 sqlite3AlterFunctions(); 2347 #endif 2348 sqlite3WindowFunctions(); 2349 sqlite3RegisterDateTimeFunctions(); 2350 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); 2351 2352 #if 0 /* Enable to print out how the built-in functions are hashed */ 2353 { 2354 int i; 2355 FuncDef *p; 2356 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){ 2357 printf("FUNC-HASH %02d:", i); 2358 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){ 2359 int n = sqlite3Strlen30(p->zName); 2360 int h = p->zName[0] + n; 2361 assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); 2362 printf(" %s(%d)", p->zName, h); 2363 } 2364 printf("\n"); 2365 } 2366 } 2367 #endif 2368 } 2369