1 /* 2 ** 2001 September 15 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 ** Utility functions used throughout sqlite. 13 ** 14 ** This file contains functions for allocating memory, comparing 15 ** strings, and stuff like that. 16 ** 17 */ 18 #include "sqliteInt.h" 19 #include <stdarg.h> 20 #ifdef SQLITE_HAVE_ISNAN 21 # include <math.h> 22 #endif 23 24 /* 25 ** Routine needed to support the testcase() macro. 26 */ 27 #ifdef SQLITE_COVERAGE_TEST 28 void sqlite3Coverage(int x){ 29 static unsigned dummy = 0; 30 dummy += (unsigned)x; 31 } 32 #endif 33 34 /* 35 ** Give a callback to the test harness that can be used to simulate faults 36 ** in places where it is difficult or expensive to do so purely by means 37 ** of inputs. 38 ** 39 ** The intent of the integer argument is to let the fault simulator know 40 ** which of multiple sqlite3FaultSim() calls has been hit. 41 ** 42 ** Return whatever integer value the test callback returns, or return 43 ** SQLITE_OK if no test callback is installed. 44 */ 45 #ifndef SQLITE_OMIT_BUILTIN_TEST 46 int sqlite3FaultSim(int iTest){ 47 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; 48 return xCallback ? xCallback(iTest) : SQLITE_OK; 49 } 50 #endif 51 52 #ifndef SQLITE_OMIT_FLOATING_POINT 53 /* 54 ** Return true if the floating point value is Not a Number (NaN). 55 ** 56 ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN. 57 ** Otherwise, we have our own implementation that works on most systems. 58 */ 59 int sqlite3IsNaN(double x){ 60 int rc; /* The value return */ 61 #if !defined(SQLITE_HAVE_ISNAN) 62 /* 63 ** Systems that support the isnan() library function should probably 64 ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have 65 ** found that many systems do not have a working isnan() function so 66 ** this implementation is provided as an alternative. 67 ** 68 ** This NaN test sometimes fails if compiled on GCC with -ffast-math. 69 ** On the other hand, the use of -ffast-math comes with the following 70 ** warning: 71 ** 72 ** This option [-ffast-math] should never be turned on by any 73 ** -O option since it can result in incorrect output for programs 74 ** which depend on an exact implementation of IEEE or ISO 75 ** rules/specifications for math functions. 76 ** 77 ** Under MSVC, this NaN test may fail if compiled with a floating- 78 ** point precision mode other than /fp:precise. From the MSDN 79 ** documentation: 80 ** 81 ** The compiler [with /fp:precise] will properly handle comparisons 82 ** involving NaN. For example, x != x evaluates to true if x is NaN 83 ** ... 84 */ 85 #ifdef __FAST_MATH__ 86 # error SQLite will not work correctly with the -ffast-math option of GCC. 87 #endif 88 volatile double y = x; 89 volatile double z = y; 90 rc = (y!=z); 91 #else /* if defined(SQLITE_HAVE_ISNAN) */ 92 rc = isnan(x); 93 #endif /* SQLITE_HAVE_ISNAN */ 94 testcase( rc ); 95 return rc; 96 } 97 #endif /* SQLITE_OMIT_FLOATING_POINT */ 98 99 /* 100 ** Compute a string length that is limited to what can be stored in 101 ** lower 30 bits of a 32-bit signed integer. 102 ** 103 ** The value returned will never be negative. Nor will it ever be greater 104 ** than the actual length of the string. For very long strings (greater 105 ** than 1GiB) the value returned might be less than the true string length. 106 */ 107 int sqlite3Strlen30(const char *z){ 108 const char *z2 = z; 109 if( z==0 ) return 0; 110 while( *z2 ){ z2++; } 111 return 0x3fffffff & (int)(z2 - z); 112 } 113 114 /* 115 ** Set the current error code to err_code and clear any prior error message. 116 */ 117 void sqlite3Error(sqlite3 *db, int err_code){ 118 assert( db!=0 ); 119 db->errCode = err_code; 120 if( db->pErr ) sqlite3ValueSetNull(db->pErr); 121 } 122 123 /* 124 ** Set the most recent error code and error string for the sqlite 125 ** handle "db". The error code is set to "err_code". 126 ** 127 ** If it is not NULL, string zFormat specifies the format of the 128 ** error string in the style of the printf functions: The following 129 ** format characters are allowed: 130 ** 131 ** %s Insert a string 132 ** %z A string that should be freed after use 133 ** %d Insert an integer 134 ** %T Insert a token 135 ** %S Insert the first element of a SrcList 136 ** 137 ** zFormat and any string tokens that follow it are assumed to be 138 ** encoded in UTF-8. 139 ** 140 ** To clear the most recent error for sqlite handle "db", sqlite3Error 141 ** should be called with err_code set to SQLITE_OK and zFormat set 142 ** to NULL. 143 */ 144 void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ 145 assert( db!=0 ); 146 db->errCode = err_code; 147 if( zFormat==0 ){ 148 sqlite3Error(db, err_code); 149 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ 150 char *z; 151 va_list ap; 152 va_start(ap, zFormat); 153 z = sqlite3VMPrintf(db, zFormat, ap); 154 va_end(ap); 155 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); 156 } 157 } 158 159 /* 160 ** Add an error message to pParse->zErrMsg and increment pParse->nErr. 161 ** The following formatting characters are allowed: 162 ** 163 ** %s Insert a string 164 ** %z A string that should be freed after use 165 ** %d Insert an integer 166 ** %T Insert a token 167 ** %S Insert the first element of a SrcList 168 ** 169 ** This function should be used to report any error that occurs while 170 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The 171 ** last thing the sqlite3_prepare() function does is copy the error 172 ** stored by this function into the database handle using sqlite3Error(). 173 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used 174 ** during statement execution (sqlite3_step() etc.). 175 */ 176 void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ 177 char *zMsg; 178 va_list ap; 179 sqlite3 *db = pParse->db; 180 va_start(ap, zFormat); 181 zMsg = sqlite3VMPrintf(db, zFormat, ap); 182 va_end(ap); 183 if( db->suppressErr ){ 184 sqlite3DbFree(db, zMsg); 185 }else{ 186 pParse->nErr++; 187 sqlite3DbFree(db, pParse->zErrMsg); 188 pParse->zErrMsg = zMsg; 189 pParse->rc = SQLITE_ERROR; 190 } 191 } 192 193 /* 194 ** Convert an SQL-style quoted string into a normal string by removing 195 ** the quote characters. The conversion is done in-place. If the 196 ** input does not begin with a quote character, then this routine 197 ** is a no-op. 198 ** 199 ** The input string must be zero-terminated. A new zero-terminator 200 ** is added to the dequoted string. 201 ** 202 ** The return value is -1 if no dequoting occurs or the length of the 203 ** dequoted string, exclusive of the zero terminator, if dequoting does 204 ** occur. 205 ** 206 ** 2002-Feb-14: This routine is extended to remove MS-Access style 207 ** brackets from around identifiers. For example: "[a-b-c]" becomes 208 ** "a-b-c". 209 */ 210 int sqlite3Dequote(char *z){ 211 char quote; 212 int i, j; 213 if( z==0 ) return -1; 214 quote = z[0]; 215 switch( quote ){ 216 case '\'': break; 217 case '"': break; 218 case '`': break; /* For MySQL compatibility */ 219 case '[': quote = ']'; break; /* For MS SqlServer compatibility */ 220 default: return -1; 221 } 222 for(i=1, j=0;; i++){ 223 assert( z[i] ); 224 if( z[i]==quote ){ 225 if( z[i+1]==quote ){ 226 z[j++] = quote; 227 i++; 228 }else{ 229 break; 230 } 231 }else{ 232 z[j++] = z[i]; 233 } 234 } 235 z[j] = 0; 236 return j; 237 } 238 239 /* Convenient short-hand */ 240 #define UpperToLower sqlite3UpperToLower 241 242 /* 243 ** Some systems have stricmp(). Others have strcasecmp(). Because 244 ** there is no consistency, we will define our own. 245 ** 246 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and 247 ** sqlite3_strnicmp() APIs allow applications and extensions to compare 248 ** the contents of two buffers containing UTF-8 strings in a 249 ** case-independent fashion, using the same definition of "case 250 ** independence" that SQLite uses internally when comparing identifiers. 251 */ 252 int sqlite3_stricmp(const char *zLeft, const char *zRight){ 253 register unsigned char *a, *b; 254 a = (unsigned char *)zLeft; 255 b = (unsigned char *)zRight; 256 while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 257 return UpperToLower[*a] - UpperToLower[*b]; 258 } 259 int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ 260 register unsigned char *a, *b; 261 a = (unsigned char *)zLeft; 262 b = (unsigned char *)zRight; 263 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } 264 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; 265 } 266 267 /* 268 ** The string z[] is an text representation of a real number. 269 ** Convert this string to a double and write it into *pResult. 270 ** 271 ** The string z[] is length bytes in length (bytes, not characters) and 272 ** uses the encoding enc. The string is not necessarily zero-terminated. 273 ** 274 ** Return TRUE if the result is a valid real number (or integer) and FALSE 275 ** if the string is empty or contains extraneous text. Valid numbers 276 ** are in one of these formats: 277 ** 278 ** [+-]digits[E[+-]digits] 279 ** [+-]digits.[digits][E[+-]digits] 280 ** [+-].digits[E[+-]digits] 281 ** 282 ** Leading and trailing whitespace is ignored for the purpose of determining 283 ** validity. 284 ** 285 ** If some prefix of the input string is a valid number, this routine 286 ** returns FALSE but it still converts the prefix and writes the result 287 ** into *pResult. 288 */ 289 int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ 290 #ifndef SQLITE_OMIT_FLOATING_POINT 291 int incr; 292 const char *zEnd = z + length; 293 /* sign * significand * (10 ^ (esign * exponent)) */ 294 int sign = 1; /* sign of significand */ 295 i64 s = 0; /* significand */ 296 int d = 0; /* adjust exponent for shifting decimal point */ 297 int esign = 1; /* sign of exponent */ 298 int e = 0; /* exponent */ 299 int eValid = 1; /* True exponent is either not used or is well-formed */ 300 double result; 301 int nDigits = 0; 302 int nonNum = 0; 303 304 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 305 *pResult = 0.0; /* Default return value, in case of an error */ 306 307 if( enc==SQLITE_UTF8 ){ 308 incr = 1; 309 }else{ 310 int i; 311 incr = 2; 312 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 313 for(i=3-enc; i<length && z[i]==0; i+=2){} 314 nonNum = i<length; 315 zEnd = z+i+enc-3; 316 z += (enc&1); 317 } 318 319 /* skip leading spaces */ 320 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 321 if( z>=zEnd ) return 0; 322 323 /* get sign of significand */ 324 if( *z=='-' ){ 325 sign = -1; 326 z+=incr; 327 }else if( *z=='+' ){ 328 z+=incr; 329 } 330 331 /* skip leading zeroes */ 332 while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++; 333 334 /* copy max significant digits to significand */ 335 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){ 336 s = s*10 + (*z - '0'); 337 z+=incr, nDigits++; 338 } 339 340 /* skip non-significant significand digits 341 ** (increase exponent by d to shift decimal left) */ 342 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++; 343 if( z>=zEnd ) goto do_atof_calc; 344 345 /* if decimal point is present */ 346 if( *z=='.' ){ 347 z+=incr; 348 /* copy digits from after decimal to significand 349 ** (decrease exponent by d to shift decimal right) */ 350 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){ 351 s = s*10 + (*z - '0'); 352 z+=incr, nDigits++, d--; 353 } 354 /* skip non-significant digits */ 355 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++; 356 } 357 if( z>=zEnd ) goto do_atof_calc; 358 359 /* if exponent is present */ 360 if( *z=='e' || *z=='E' ){ 361 z+=incr; 362 eValid = 0; 363 if( z>=zEnd ) goto do_atof_calc; 364 /* get sign of exponent */ 365 if( *z=='-' ){ 366 esign = -1; 367 z+=incr; 368 }else if( *z=='+' ){ 369 z+=incr; 370 } 371 /* copy digits to exponent */ 372 while( z<zEnd && sqlite3Isdigit(*z) ){ 373 e = e<10000 ? (e*10 + (*z - '0')) : 10000; 374 z+=incr; 375 eValid = 1; 376 } 377 } 378 379 /* skip trailing spaces */ 380 if( nDigits && eValid ){ 381 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr; 382 } 383 384 do_atof_calc: 385 /* adjust exponent by d, and update sign */ 386 e = (e*esign) + d; 387 if( e<0 ) { 388 esign = -1; 389 e *= -1; 390 } else { 391 esign = 1; 392 } 393 394 /* if 0 significand */ 395 if( !s ) { 396 /* In the IEEE 754 standard, zero is signed. 397 ** Add the sign if we've seen at least one digit */ 398 result = (sign<0 && nDigits) ? -(double)0 : (double)0; 399 } else { 400 /* attempt to reduce exponent */ 401 if( esign>0 ){ 402 while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10; 403 }else{ 404 while( !(s%10) && e>0 ) e--,s/=10; 405 } 406 407 /* adjust the sign of significand */ 408 s = sign<0 ? -s : s; 409 410 /* if exponent, scale significand as appropriate 411 ** and store in result. */ 412 if( e ){ 413 LONGDOUBLE_TYPE scale = 1.0; 414 /* attempt to handle extremely small/large numbers better */ 415 if( e>307 && e<342 ){ 416 while( e%308 ) { scale *= 1.0e+1; e -= 1; } 417 if( esign<0 ){ 418 result = s / scale; 419 result /= 1.0e+308; 420 }else{ 421 result = s * scale; 422 result *= 1.0e+308; 423 } 424 }else if( e>=342 ){ 425 if( esign<0 ){ 426 result = 0.0*s; 427 }else{ 428 result = 1e308*1e308*s; /* Infinity */ 429 } 430 }else{ 431 /* 1.0e+22 is the largest power of 10 than can be 432 ** represented exactly. */ 433 while( e%22 ) { scale *= 1.0e+1; e -= 1; } 434 while( e>0 ) { scale *= 1.0e+22; e -= 22; } 435 if( esign<0 ){ 436 result = s / scale; 437 }else{ 438 result = s * scale; 439 } 440 } 441 } else { 442 result = (double)s; 443 } 444 } 445 446 /* store the result */ 447 *pResult = result; 448 449 /* return true if number and no extra non-whitespace chracters after */ 450 return z>=zEnd && nDigits>0 && eValid && nonNum==0; 451 #else 452 return !sqlite3Atoi64(z, pResult, length, enc); 453 #endif /* SQLITE_OMIT_FLOATING_POINT */ 454 } 455 456 /* 457 ** Compare the 19-character string zNum against the text representation 458 ** value 2^63: 9223372036854775808. Return negative, zero, or positive 459 ** if zNum is less than, equal to, or greater than the string. 460 ** Note that zNum must contain exactly 19 characters. 461 ** 462 ** Unlike memcmp() this routine is guaranteed to return the difference 463 ** in the values of the last digit if the only difference is in the 464 ** last digit. So, for example, 465 ** 466 ** compare2pow63("9223372036854775800", 1) 467 ** 468 ** will return -8. 469 */ 470 static int compare2pow63(const char *zNum, int incr){ 471 int c = 0; 472 int i; 473 /* 012345678901234567 */ 474 const char *pow63 = "922337203685477580"; 475 for(i=0; c==0 && i<18; i++){ 476 c = (zNum[i*incr]-pow63[i])*10; 477 } 478 if( c==0 ){ 479 c = zNum[18*incr] - '8'; 480 testcase( c==(-1) ); 481 testcase( c==0 ); 482 testcase( c==(+1) ); 483 } 484 return c; 485 } 486 487 /* 488 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This 489 ** routine does *not* accept hexadecimal notation. 490 ** 491 ** If the zNum value is representable as a 64-bit twos-complement 492 ** integer, then write that value into *pNum and return 0. 493 ** 494 ** If zNum is exactly 9223372036854775808, return 2. This special 495 ** case is broken out because while 9223372036854775808 cannot be a 496 ** signed 64-bit integer, its negative -9223372036854775808 can be. 497 ** 498 ** If zNum is too big for a 64-bit integer and is not 499 ** 9223372036854775808 or if zNum contains any non-numeric text, 500 ** then return 1. 501 ** 502 ** length is the number of bytes in the string (bytes, not characters). 503 ** The string is not necessarily zero-terminated. The encoding is 504 ** given by enc. 505 */ 506 int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ 507 int incr; 508 u64 u = 0; 509 int neg = 0; /* assume positive */ 510 int i; 511 int c = 0; 512 int nonNum = 0; 513 const char *zStart; 514 const char *zEnd = zNum + length; 515 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); 516 if( enc==SQLITE_UTF8 ){ 517 incr = 1; 518 }else{ 519 incr = 2; 520 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); 521 for(i=3-enc; i<length && zNum[i]==0; i+=2){} 522 nonNum = i<length; 523 zEnd = zNum+i+enc-3; 524 zNum += (enc&1); 525 } 526 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr; 527 if( zNum<zEnd ){ 528 if( *zNum=='-' ){ 529 neg = 1; 530 zNum+=incr; 531 }else if( *zNum=='+' ){ 532 zNum+=incr; 533 } 534 } 535 zStart = zNum; 536 while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */ 537 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){ 538 u = u*10 + c - '0'; 539 } 540 if( u>LARGEST_INT64 ){ 541 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; 542 }else if( neg ){ 543 *pNum = -(i64)u; 544 }else{ 545 *pNum = (i64)u; 546 } 547 testcase( i==18 ); 548 testcase( i==19 ); 549 testcase( i==20 ); 550 if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr || nonNum ){ 551 /* zNum is empty or contains non-numeric text or is longer 552 ** than 19 digits (thus guaranteeing that it is too large) */ 553 return 1; 554 }else if( i<19*incr ){ 555 /* Less than 19 digits, so we know that it fits in 64 bits */ 556 assert( u<=LARGEST_INT64 ); 557 return 0; 558 }else{ 559 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ 560 c = compare2pow63(zNum, incr); 561 if( c<0 ){ 562 /* zNum is less than 9223372036854775808 so it fits */ 563 assert( u<=LARGEST_INT64 ); 564 return 0; 565 }else if( c>0 ){ 566 /* zNum is greater than 9223372036854775808 so it overflows */ 567 return 1; 568 }else{ 569 /* zNum is exactly 9223372036854775808. Fits if negative. The 570 ** special case 2 overflow if positive */ 571 assert( u-1==LARGEST_INT64 ); 572 return neg ? 0 : 2; 573 } 574 } 575 } 576 577 /* 578 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal, 579 ** into a 64-bit signed integer. This routine accepts hexadecimal literals, 580 ** whereas sqlite3Atoi64() does not. 581 ** 582 ** Returns: 583 ** 584 ** 0 Successful transformation. Fits in a 64-bit signed integer. 585 ** 1 Integer too large for a 64-bit signed integer or is malformed 586 ** 2 Special case of 9223372036854775808 587 */ 588 int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ 589 #ifndef SQLITE_OMIT_HEX_INTEGER 590 if( z[0]=='0' 591 && (z[1]=='x' || z[1]=='X') 592 && sqlite3Isxdigit(z[2]) 593 ){ 594 u64 u = 0; 595 int i, k; 596 for(i=2; z[i]=='0'; i++){} 597 for(k=i; sqlite3Isxdigit(z[k]); k++){ 598 u = u*16 + sqlite3HexToInt(z[k]); 599 } 600 memcpy(pOut, &u, 8); 601 return (z[k]==0 && k-i<=16) ? 0 : 1; 602 }else 603 #endif /* SQLITE_OMIT_HEX_INTEGER */ 604 { 605 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); 606 } 607 } 608 609 /* 610 ** If zNum represents an integer that will fit in 32-bits, then set 611 ** *pValue to that integer and return true. Otherwise return false. 612 ** 613 ** This routine accepts both decimal and hexadecimal notation for integers. 614 ** 615 ** Any non-numeric characters that following zNum are ignored. 616 ** This is different from sqlite3Atoi64() which requires the 617 ** input number to be zero-terminated. 618 */ 619 int sqlite3GetInt32(const char *zNum, int *pValue){ 620 sqlite_int64 v = 0; 621 int i, c; 622 int neg = 0; 623 if( zNum[0]=='-' ){ 624 neg = 1; 625 zNum++; 626 }else if( zNum[0]=='+' ){ 627 zNum++; 628 } 629 #ifndef SQLITE_OMIT_HEX_INTEGER 630 else if( zNum[0]=='0' 631 && (zNum[1]=='x' || zNum[1]=='X') 632 && sqlite3Isxdigit(zNum[2]) 633 ){ 634 u32 u = 0; 635 zNum += 2; 636 while( zNum[0]=='0' ) zNum++; 637 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ 638 u = u*16 + sqlite3HexToInt(zNum[i]); 639 } 640 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ 641 memcpy(pValue, &u, 4); 642 return 1; 643 }else{ 644 return 0; 645 } 646 } 647 #endif 648 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ 649 v = v*10 + c; 650 } 651 652 /* The longest decimal representation of a 32 bit integer is 10 digits: 653 ** 654 ** 1234567890 655 ** 2^31 -> 2147483648 656 */ 657 testcase( i==10 ); 658 if( i>10 ){ 659 return 0; 660 } 661 testcase( v-neg==2147483647 ); 662 if( v-neg>2147483647 ){ 663 return 0; 664 } 665 if( neg ){ 666 v = -v; 667 } 668 *pValue = (int)v; 669 return 1; 670 } 671 672 /* 673 ** Return a 32-bit integer value extracted from a string. If the 674 ** string is not an integer, just return 0. 675 */ 676 int sqlite3Atoi(const char *z){ 677 int x = 0; 678 if( z ) sqlite3GetInt32(z, &x); 679 return x; 680 } 681 682 /* 683 ** The variable-length integer encoding is as follows: 684 ** 685 ** KEY: 686 ** A = 0xxxxxxx 7 bits of data and one flag bit 687 ** B = 1xxxxxxx 7 bits of data and one flag bit 688 ** C = xxxxxxxx 8 bits of data 689 ** 690 ** 7 bits - A 691 ** 14 bits - BA 692 ** 21 bits - BBA 693 ** 28 bits - BBBA 694 ** 35 bits - BBBBA 695 ** 42 bits - BBBBBA 696 ** 49 bits - BBBBBBA 697 ** 56 bits - BBBBBBBA 698 ** 64 bits - BBBBBBBBC 699 */ 700 701 /* 702 ** Write a 64-bit variable-length integer to memory starting at p[0]. 703 ** The length of data write will be between 1 and 9 bytes. The number 704 ** of bytes written is returned. 705 ** 706 ** A variable-length integer consists of the lower 7 bits of each byte 707 ** for all bytes that have the 8th bit set and one byte with the 8th 708 ** bit clear. Except, if we get to the 9th byte, it stores the full 709 ** 8 bits and is the last byte. 710 */ 711 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ 712 int i, j, n; 713 u8 buf[10]; 714 if( v & (((u64)0xff000000)<<32) ){ 715 p[8] = (u8)v; 716 v >>= 8; 717 for(i=7; i>=0; i--){ 718 p[i] = (u8)((v & 0x7f) | 0x80); 719 v >>= 7; 720 } 721 return 9; 722 } 723 n = 0; 724 do{ 725 buf[n++] = (u8)((v & 0x7f) | 0x80); 726 v >>= 7; 727 }while( v!=0 ); 728 buf[0] &= 0x7f; 729 assert( n<=9 ); 730 for(i=0, j=n-1; j>=0; j--, i++){ 731 p[i] = buf[j]; 732 } 733 return n; 734 } 735 int sqlite3PutVarint(unsigned char *p, u64 v){ 736 if( v<=0x7f ){ 737 p[0] = v&0x7f; 738 return 1; 739 } 740 if( v<=0x3fff ){ 741 p[0] = ((v>>7)&0x7f)|0x80; 742 p[1] = v&0x7f; 743 return 2; 744 } 745 return putVarint64(p,v); 746 } 747 748 /* 749 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants 750 ** are defined here rather than simply putting the constant expressions 751 ** inline in order to work around bugs in the RVT compiler. 752 ** 753 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f 754 ** 755 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 756 */ 757 #define SLOT_2_0 0x001fc07f 758 #define SLOT_4_2_0 0xf01fc07f 759 760 761 /* 762 ** Read a 64-bit variable-length integer from memory starting at p[0]. 763 ** Return the number of bytes read. The value is stored in *v. 764 */ 765 u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ 766 u32 a,b,s; 767 768 a = *p; 769 /* a: p0 (unmasked) */ 770 if (!(a&0x80)) 771 { 772 *v = a; 773 return 1; 774 } 775 776 p++; 777 b = *p; 778 /* b: p1 (unmasked) */ 779 if (!(b&0x80)) 780 { 781 a &= 0x7f; 782 a = a<<7; 783 a |= b; 784 *v = a; 785 return 2; 786 } 787 788 /* Verify that constants are precomputed correctly */ 789 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); 790 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); 791 792 p++; 793 a = a<<14; 794 a |= *p; 795 /* a: p0<<14 | p2 (unmasked) */ 796 if (!(a&0x80)) 797 { 798 a &= SLOT_2_0; 799 b &= 0x7f; 800 b = b<<7; 801 a |= b; 802 *v = a; 803 return 3; 804 } 805 806 /* CSE1 from below */ 807 a &= SLOT_2_0; 808 p++; 809 b = b<<14; 810 b |= *p; 811 /* b: p1<<14 | p3 (unmasked) */ 812 if (!(b&0x80)) 813 { 814 b &= SLOT_2_0; 815 /* moved CSE1 up */ 816 /* a &= (0x7f<<14)|(0x7f); */ 817 a = a<<7; 818 a |= b; 819 *v = a; 820 return 4; 821 } 822 823 /* a: p0<<14 | p2 (masked) */ 824 /* b: p1<<14 | p3 (unmasked) */ 825 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 826 /* moved CSE1 up */ 827 /* a &= (0x7f<<14)|(0x7f); */ 828 b &= SLOT_2_0; 829 s = a; 830 /* s: p0<<14 | p2 (masked) */ 831 832 p++; 833 a = a<<14; 834 a |= *p; 835 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 836 if (!(a&0x80)) 837 { 838 /* we can skip these cause they were (effectively) done above in calc'ing s */ 839 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 840 /* b &= (0x7f<<14)|(0x7f); */ 841 b = b<<7; 842 a |= b; 843 s = s>>18; 844 *v = ((u64)s)<<32 | a; 845 return 5; 846 } 847 848 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 849 s = s<<7; 850 s |= b; 851 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ 852 853 p++; 854 b = b<<14; 855 b |= *p; 856 /* b: p1<<28 | p3<<14 | p5 (unmasked) */ 857 if (!(b&0x80)) 858 { 859 /* we can skip this cause it was (effectively) done above in calc'ing s */ 860 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ 861 a &= SLOT_2_0; 862 a = a<<7; 863 a |= b; 864 s = s>>18; 865 *v = ((u64)s)<<32 | a; 866 return 6; 867 } 868 869 p++; 870 a = a<<14; 871 a |= *p; 872 /* a: p2<<28 | p4<<14 | p6 (unmasked) */ 873 if (!(a&0x80)) 874 { 875 a &= SLOT_4_2_0; 876 b &= SLOT_2_0; 877 b = b<<7; 878 a |= b; 879 s = s>>11; 880 *v = ((u64)s)<<32 | a; 881 return 7; 882 } 883 884 /* CSE2 from below */ 885 a &= SLOT_2_0; 886 p++; 887 b = b<<14; 888 b |= *p; 889 /* b: p3<<28 | p5<<14 | p7 (unmasked) */ 890 if (!(b&0x80)) 891 { 892 b &= SLOT_4_2_0; 893 /* moved CSE2 up */ 894 /* a &= (0x7f<<14)|(0x7f); */ 895 a = a<<7; 896 a |= b; 897 s = s>>4; 898 *v = ((u64)s)<<32 | a; 899 return 8; 900 } 901 902 p++; 903 a = a<<15; 904 a |= *p; 905 /* a: p4<<29 | p6<<15 | p8 (unmasked) */ 906 907 /* moved CSE2 up */ 908 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ 909 b &= SLOT_2_0; 910 b = b<<8; 911 a |= b; 912 913 s = s<<4; 914 b = p[-4]; 915 b &= 0x7f; 916 b = b>>3; 917 s |= b; 918 919 *v = ((u64)s)<<32 | a; 920 921 return 9; 922 } 923 924 /* 925 ** Read a 32-bit variable-length integer from memory starting at p[0]. 926 ** Return the number of bytes read. The value is stored in *v. 927 ** 928 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned 929 ** integer, then set *v to 0xffffffff. 930 ** 931 ** A MACRO version, getVarint32, is provided which inlines the 932 ** single-byte case. All code should use the MACRO version as 933 ** this function assumes the single-byte case has already been handled. 934 */ 935 u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ 936 u32 a,b; 937 938 /* The 1-byte case. Overwhelmingly the most common. Handled inline 939 ** by the getVarin32() macro */ 940 a = *p; 941 /* a: p0 (unmasked) */ 942 #ifndef getVarint32 943 if (!(a&0x80)) 944 { 945 /* Values between 0 and 127 */ 946 *v = a; 947 return 1; 948 } 949 #endif 950 951 /* The 2-byte case */ 952 p++; 953 b = *p; 954 /* b: p1 (unmasked) */ 955 if (!(b&0x80)) 956 { 957 /* Values between 128 and 16383 */ 958 a &= 0x7f; 959 a = a<<7; 960 *v = a | b; 961 return 2; 962 } 963 964 /* The 3-byte case */ 965 p++; 966 a = a<<14; 967 a |= *p; 968 /* a: p0<<14 | p2 (unmasked) */ 969 if (!(a&0x80)) 970 { 971 /* Values between 16384 and 2097151 */ 972 a &= (0x7f<<14)|(0x7f); 973 b &= 0x7f; 974 b = b<<7; 975 *v = a | b; 976 return 3; 977 } 978 979 /* A 32-bit varint is used to store size information in btrees. 980 ** Objects are rarely larger than 2MiB limit of a 3-byte varint. 981 ** A 3-byte varint is sufficient, for example, to record the size 982 ** of a 1048569-byte BLOB or string. 983 ** 984 ** We only unroll the first 1-, 2-, and 3- byte cases. The very 985 ** rare larger cases can be handled by the slower 64-bit varint 986 ** routine. 987 */ 988 #if 1 989 { 990 u64 v64; 991 u8 n; 992 993 p -= 2; 994 n = sqlite3GetVarint(p, &v64); 995 assert( n>3 && n<=9 ); 996 if( (v64 & SQLITE_MAX_U32)!=v64 ){ 997 *v = 0xffffffff; 998 }else{ 999 *v = (u32)v64; 1000 } 1001 return n; 1002 } 1003 1004 #else 1005 /* For following code (kept for historical record only) shows an 1006 ** unrolling for the 3- and 4-byte varint cases. This code is 1007 ** slightly faster, but it is also larger and much harder to test. 1008 */ 1009 p++; 1010 b = b<<14; 1011 b |= *p; 1012 /* b: p1<<14 | p3 (unmasked) */ 1013 if (!(b&0x80)) 1014 { 1015 /* Values between 2097152 and 268435455 */ 1016 b &= (0x7f<<14)|(0x7f); 1017 a &= (0x7f<<14)|(0x7f); 1018 a = a<<7; 1019 *v = a | b; 1020 return 4; 1021 } 1022 1023 p++; 1024 a = a<<14; 1025 a |= *p; 1026 /* a: p0<<28 | p2<<14 | p4 (unmasked) */ 1027 if (!(a&0x80)) 1028 { 1029 /* Values between 268435456 and 34359738367 */ 1030 a &= SLOT_4_2_0; 1031 b &= SLOT_4_2_0; 1032 b = b<<7; 1033 *v = a | b; 1034 return 5; 1035 } 1036 1037 /* We can only reach this point when reading a corrupt database 1038 ** file. In that case we are not in any hurry. Use the (relatively 1039 ** slow) general-purpose sqlite3GetVarint() routine to extract the 1040 ** value. */ 1041 { 1042 u64 v64; 1043 u8 n; 1044 1045 p -= 4; 1046 n = sqlite3GetVarint(p, &v64); 1047 assert( n>5 && n<=9 ); 1048 *v = (u32)v64; 1049 return n; 1050 } 1051 #endif 1052 } 1053 1054 /* 1055 ** Return the number of bytes that will be needed to store the given 1056 ** 64-bit integer. 1057 */ 1058 int sqlite3VarintLen(u64 v){ 1059 int i = 0; 1060 do{ 1061 i++; 1062 v >>= 7; 1063 }while( v!=0 && ALWAYS(i<9) ); 1064 return i; 1065 } 1066 1067 1068 /* 1069 ** Read or write a four-byte big-endian integer value. 1070 */ 1071 u32 sqlite3Get4byte(const u8 *p){ 1072 testcase( p[0]&0x80 ); 1073 return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; 1074 } 1075 void sqlite3Put4byte(unsigned char *p, u32 v){ 1076 p[0] = (u8)(v>>24); 1077 p[1] = (u8)(v>>16); 1078 p[2] = (u8)(v>>8); 1079 p[3] = (u8)v; 1080 } 1081 1082 1083 1084 /* 1085 ** Translate a single byte of Hex into an integer. 1086 ** This routine only works if h really is a valid hexadecimal 1087 ** character: 0..9a..fA..F 1088 */ 1089 u8 sqlite3HexToInt(int h){ 1090 assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); 1091 #ifdef SQLITE_ASCII 1092 h += 9*(1&(h>>6)); 1093 #endif 1094 #ifdef SQLITE_EBCDIC 1095 h += 9*(1&~(h>>4)); 1096 #endif 1097 return (u8)(h & 0xf); 1098 } 1099 1100 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) 1101 /* 1102 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary 1103 ** value. Return a pointer to its binary value. Space to hold the 1104 ** binary value has been obtained from malloc and must be freed by 1105 ** the calling routine. 1106 */ 1107 void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ 1108 char *zBlob; 1109 int i; 1110 1111 zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1); 1112 n--; 1113 if( zBlob ){ 1114 for(i=0; i<n; i+=2){ 1115 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]); 1116 } 1117 zBlob[i/2] = 0; 1118 } 1119 return zBlob; 1120 } 1121 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ 1122 1123 /* 1124 ** Log an error that is an API call on a connection pointer that should 1125 ** not have been used. The "type" of connection pointer is given as the 1126 ** argument. The zType is a word like "NULL" or "closed" or "invalid". 1127 */ 1128 static void logBadConnection(const char *zType){ 1129 sqlite3_log(SQLITE_MISUSE, 1130 "API call with %s database connection pointer", 1131 zType 1132 ); 1133 } 1134 1135 /* 1136 ** Check to make sure we have a valid db pointer. This test is not 1137 ** foolproof but it does provide some measure of protection against 1138 ** misuse of the interface such as passing in db pointers that are 1139 ** NULL or which have been previously closed. If this routine returns 1140 ** 1 it means that the db pointer is valid and 0 if it should not be 1141 ** dereferenced for any reason. The calling function should invoke 1142 ** SQLITE_MISUSE immediately. 1143 ** 1144 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for 1145 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to 1146 ** open properly and is not fit for general use but which can be 1147 ** used as an argument to sqlite3_errmsg() or sqlite3_close(). 1148 */ 1149 int sqlite3SafetyCheckOk(sqlite3 *db){ 1150 u32 magic; 1151 if( db==0 ){ 1152 logBadConnection("NULL"); 1153 return 0; 1154 } 1155 magic = db->magic; 1156 if( magic!=SQLITE_MAGIC_OPEN ){ 1157 if( sqlite3SafetyCheckSickOrOk(db) ){ 1158 testcase( sqlite3GlobalConfig.xLog!=0 ); 1159 logBadConnection("unopened"); 1160 } 1161 return 0; 1162 }else{ 1163 return 1; 1164 } 1165 } 1166 int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ 1167 u32 magic; 1168 magic = db->magic; 1169 if( magic!=SQLITE_MAGIC_SICK && 1170 magic!=SQLITE_MAGIC_OPEN && 1171 magic!=SQLITE_MAGIC_BUSY ){ 1172 testcase( sqlite3GlobalConfig.xLog!=0 ); 1173 logBadConnection("invalid"); 1174 return 0; 1175 }else{ 1176 return 1; 1177 } 1178 } 1179 1180 /* 1181 ** Attempt to add, substract, or multiply the 64-bit signed value iB against 1182 ** the other 64-bit signed integer at *pA and store the result in *pA. 1183 ** Return 0 on success. Or if the operation would have resulted in an 1184 ** overflow, leave *pA unchanged and return 1. 1185 */ 1186 int sqlite3AddInt64(i64 *pA, i64 iB){ 1187 i64 iA = *pA; 1188 testcase( iA==0 ); testcase( iA==1 ); 1189 testcase( iB==-1 ); testcase( iB==0 ); 1190 if( iB>=0 ){ 1191 testcase( iA>0 && LARGEST_INT64 - iA == iB ); 1192 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); 1193 if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; 1194 }else{ 1195 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); 1196 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); 1197 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; 1198 } 1199 *pA += iB; 1200 return 0; 1201 } 1202 int sqlite3SubInt64(i64 *pA, i64 iB){ 1203 testcase( iB==SMALLEST_INT64+1 ); 1204 if( iB==SMALLEST_INT64 ){ 1205 testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); 1206 if( (*pA)>=0 ) return 1; 1207 *pA -= iB; 1208 return 0; 1209 }else{ 1210 return sqlite3AddInt64(pA, -iB); 1211 } 1212 } 1213 #define TWOPOWER32 (((i64)1)<<32) 1214 #define TWOPOWER31 (((i64)1)<<31) 1215 int sqlite3MulInt64(i64 *pA, i64 iB){ 1216 i64 iA = *pA; 1217 i64 iA1, iA0, iB1, iB0, r; 1218 1219 iA1 = iA/TWOPOWER32; 1220 iA0 = iA % TWOPOWER32; 1221 iB1 = iB/TWOPOWER32; 1222 iB0 = iB % TWOPOWER32; 1223 if( iA1==0 ){ 1224 if( iB1==0 ){ 1225 *pA *= iB; 1226 return 0; 1227 } 1228 r = iA0*iB1; 1229 }else if( iB1==0 ){ 1230 r = iA1*iB0; 1231 }else{ 1232 /* If both iA1 and iB1 are non-zero, overflow will result */ 1233 return 1; 1234 } 1235 testcase( r==(-TWOPOWER31)-1 ); 1236 testcase( r==(-TWOPOWER31) ); 1237 testcase( r==TWOPOWER31 ); 1238 testcase( r==TWOPOWER31-1 ); 1239 if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1; 1240 r *= TWOPOWER32; 1241 if( sqlite3AddInt64(&r, iA0*iB0) ) return 1; 1242 *pA = r; 1243 return 0; 1244 } 1245 1246 /* 1247 ** Compute the absolute value of a 32-bit signed integer, of possible. Or 1248 ** if the integer has a value of -2147483648, return +2147483647 1249 */ 1250 int sqlite3AbsInt32(int x){ 1251 if( x>=0 ) return x; 1252 if( x==(int)0x80000000 ) return 0x7fffffff; 1253 return -x; 1254 } 1255 1256 #ifdef SQLITE_ENABLE_8_3_NAMES 1257 /* 1258 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database 1259 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and 1260 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than 1261 ** three characters, then shorten the suffix on z[] to be the last three 1262 ** characters of the original suffix. 1263 ** 1264 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always 1265 ** do the suffix shortening regardless of URI parameter. 1266 ** 1267 ** Examples: 1268 ** 1269 ** test.db-journal => test.nal 1270 ** test.db-wal => test.wal 1271 ** test.db-shm => test.shm 1272 ** test.db-mj7f3319fa => test.9fa 1273 */ 1274 void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ 1275 #if SQLITE_ENABLE_8_3_NAMES<2 1276 if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) 1277 #endif 1278 { 1279 int i, sz; 1280 sz = sqlite3Strlen30(z); 1281 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} 1282 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); 1283 } 1284 } 1285 #endif 1286 1287 /* 1288 ** Find (an approximate) sum of two LogEst values. This computation is 1289 ** not a simple "+" operator because LogEst is stored as a logarithmic 1290 ** value. 1291 ** 1292 */ 1293 LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ 1294 static const unsigned char x[] = { 1295 10, 10, /* 0,1 */ 1296 9, 9, /* 2,3 */ 1297 8, 8, /* 4,5 */ 1298 7, 7, 7, /* 6,7,8 */ 1299 6, 6, 6, /* 9,10,11 */ 1300 5, 5, 5, /* 12-14 */ 1301 4, 4, 4, 4, /* 15-18 */ 1302 3, 3, 3, 3, 3, 3, /* 19-24 */ 1303 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ 1304 }; 1305 if( a>=b ){ 1306 if( a>b+49 ) return a; 1307 if( a>b+31 ) return a+1; 1308 return a+x[a-b]; 1309 }else{ 1310 if( b>a+49 ) return b; 1311 if( b>a+31 ) return b+1; 1312 return b+x[b-a]; 1313 } 1314 } 1315 1316 /* 1317 ** Convert an integer into a LogEst. In other words, compute an 1318 ** approximation for 10*log2(x). 1319 */ 1320 LogEst sqlite3LogEst(u64 x){ 1321 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; 1322 LogEst y = 40; 1323 if( x<8 ){ 1324 if( x<2 ) return 0; 1325 while( x<8 ){ y -= 10; x <<= 1; } 1326 }else{ 1327 while( x>255 ){ y += 40; x >>= 4; } 1328 while( x>15 ){ y += 10; x >>= 1; } 1329 } 1330 return a[x&7] + y - 10; 1331 } 1332 1333 #ifndef SQLITE_OMIT_VIRTUALTABLE 1334 /* 1335 ** Convert a double into a LogEst 1336 ** In other words, compute an approximation for 10*log2(x). 1337 */ 1338 LogEst sqlite3LogEstFromDouble(double x){ 1339 u64 a; 1340 LogEst e; 1341 assert( sizeof(x)==8 && sizeof(a)==8 ); 1342 if( x<=1 ) return 0; 1343 if( x<=2000000000 ) return sqlite3LogEst((u64)x); 1344 memcpy(&a, &x, 8); 1345 e = (a>>52) - 1022; 1346 return e*10; 1347 } 1348 #endif /* SQLITE_OMIT_VIRTUALTABLE */ 1349 1350 /* 1351 ** Convert a LogEst into an integer. 1352 */ 1353 u64 sqlite3LogEstToInt(LogEst x){ 1354 u64 n; 1355 if( x<10 ) return 1; 1356 n = x%10; 1357 x /= 10; 1358 if( n>=5 ) n -= 2; 1359 else if( n>=1 ) n -= 1; 1360 if( x>=3 ){ 1361 return x>60 ? (u64)LARGEST_INT64 : (n+8)<<(x-3); 1362 } 1363 return (n+8)>>(3-x); 1364 } 1365