4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** Utility functions used throughout sqlite.
14 ** This file contains functions for allocating memory, comparing
15 ** strings, and stuff like that.
18 #include "sqliteInt.h"
20 #if HAVE_ISNAN || SQLITE_HAVE_ISNAN
25 ** Routine needed to support the testcase() macro.
27 #ifdef SQLITE_COVERAGE_TEST
28 void sqlite3Coverage(int x
){
29 static unsigned dummy
= 0;
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
39 ** The intent of the integer argument is to let the fault simulator know
40 ** which of multiple sqlite3FaultSim() calls has been hit.
42 ** Return whatever integer value the test callback returns, or return
43 ** SQLITE_OK if no test callback is installed.
45 #ifndef SQLITE_UNTESTABLE
46 int sqlite3FaultSim(int iTest
){
47 int (*xCallback
)(int) = sqlite3GlobalConfig
.xTestCallback
;
48 return xCallback
? xCallback(iTest
) : SQLITE_OK
;
52 #ifndef SQLITE_OMIT_FLOATING_POINT
54 ** Return true if the floating point value is Not a Number (NaN).
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.
59 int sqlite3IsNaN(double x
){
60 int rc
; /* The value return */
61 #if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
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.
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
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.
77 ** Under MSVC, this NaN test may fail if compiled with a floating-
78 ** point precision mode other than /fp:precise. From the MSDN
81 ** The compiler [with /fp:precise] will properly handle comparisons
82 ** involving NaN. For example, x != x evaluates to true if x is NaN
86 # error SQLite will not work correctly with the -ffast-math option of GCC.
88 volatile double y
= x
;
89 volatile double z
= y
;
91 #else /* if HAVE_ISNAN */
93 #endif /* HAVE_ISNAN */
97 #endif /* SQLITE_OMIT_FLOATING_POINT */
100 ** Compute a string length that is limited to what can be stored in
101 ** lower 30 bits of a 32-bit signed integer.
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.
107 int sqlite3Strlen30(const char *z
){
109 return 0x3fffffff & (int)strlen(z
);
113 ** Return the declared type of a column. Or return zDflt if the column
114 ** has no declared type.
116 ** The column type is an extra string stored after the zero-terminator on
117 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
119 char *sqlite3ColumnType(Column
*pCol
, char *zDflt
){
120 if( (pCol
->colFlags
& COLFLAG_HASTYPE
)==0 ) return zDflt
;
121 return pCol
->zName
+ strlen(pCol
->zName
) + 1;
125 ** Helper function for sqlite3Error() - called rarely. Broken out into
126 ** a separate routine to avoid unnecessary register saves on entry to
129 static SQLITE_NOINLINE
void sqlite3ErrorFinish(sqlite3
*db
, int err_code
){
130 if( db
->pErr
) sqlite3ValueSetNull(db
->pErr
);
131 sqlite3SystemError(db
, err_code
);
135 ** Set the current error code to err_code and clear any prior error message.
136 ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
137 ** that would be appropriate.
139 void sqlite3Error(sqlite3
*db
, int err_code
){
141 db
->errCode
= err_code
;
142 if( err_code
|| db
->pErr
) sqlite3ErrorFinish(db
, err_code
);
146 ** Load the sqlite3.iSysErrno field if that is an appropriate thing
147 ** to do based on the SQLite error code in rc.
149 void sqlite3SystemError(sqlite3
*db
, int rc
){
150 if( rc
==SQLITE_IOERR_NOMEM
) return;
152 if( rc
==SQLITE_CANTOPEN
|| rc
==SQLITE_IOERR
){
153 db
->iSysErrno
= sqlite3OsGetLastError(db
->pVfs
);
158 ** Set the most recent error code and error string for the sqlite
159 ** handle "db". The error code is set to "err_code".
161 ** If it is not NULL, string zFormat specifies the format of the
162 ** error string in the style of the printf functions: The following
163 ** format characters are allowed:
165 ** %s Insert a string
166 ** %z A string that should be freed after use
167 ** %d Insert an integer
169 ** %S Insert the first element of a SrcList
171 ** zFormat and any string tokens that follow it are assumed to be
174 ** To clear the most recent error for sqlite handle "db", sqlite3Error
175 ** should be called with err_code set to SQLITE_OK and zFormat set
178 void sqlite3ErrorWithMsg(sqlite3
*db
, int err_code
, const char *zFormat
, ...){
180 db
->errCode
= err_code
;
181 sqlite3SystemError(db
, err_code
);
183 sqlite3Error(db
, err_code
);
184 }else if( db
->pErr
|| (db
->pErr
= sqlite3ValueNew(db
))!=0 ){
187 va_start(ap
, zFormat
);
188 z
= sqlite3VMPrintf(db
, zFormat
, ap
);
190 sqlite3ValueSetStr(db
->pErr
, -1, z
, SQLITE_UTF8
, SQLITE_DYNAMIC
);
195 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
196 ** The following formatting characters are allowed:
198 ** %s Insert a string
199 ** %z A string that should be freed after use
200 ** %d Insert an integer
202 ** %S Insert the first element of a SrcList
204 ** This function should be used to report any error that occurs while
205 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
206 ** last thing the sqlite3_prepare() function does is copy the error
207 ** stored by this function into the database handle using sqlite3Error().
208 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
209 ** during statement execution (sqlite3_step() etc.).
211 void sqlite3ErrorMsg(Parse
*pParse
, const char *zFormat
, ...){
214 sqlite3
*db
= pParse
->db
;
215 va_start(ap
, zFormat
);
216 zMsg
= sqlite3VMPrintf(db
, zFormat
, ap
);
218 if( db
->suppressErr
){
219 sqlite3DbFree(db
, zMsg
);
222 sqlite3DbFree(db
, pParse
->zErrMsg
);
223 pParse
->zErrMsg
= zMsg
;
224 pParse
->rc
= SQLITE_ERROR
;
229 ** Convert an SQL-style quoted string into a normal string by removing
230 ** the quote characters. The conversion is done in-place. If the
231 ** input does not begin with a quote character, then this routine
234 ** The input string must be zero-terminated. A new zero-terminator
235 ** is added to the dequoted string.
237 ** The return value is -1 if no dequoting occurs or the length of the
238 ** dequoted string, exclusive of the zero terminator, if dequoting does
241 ** 2002-Feb-14: This routine is extended to remove MS-Access style
242 ** brackets from around identifiers. For example: "[a-b-c]" becomes
245 void sqlite3Dequote(char *z
){
250 if( !sqlite3Isquote(quote
) ) return;
251 if( quote
=='[' ) quote
= ']';
269 ** Generate a Token object from a string
271 void sqlite3TokenInit(Token
*p
, char *z
){
273 p
->n
= sqlite3Strlen30(z
);
276 /* Convenient short-hand */
277 #define UpperToLower sqlite3UpperToLower
280 ** Some systems have stricmp(). Others have strcasecmp(). Because
281 ** there is no consistency, we will define our own.
283 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
284 ** sqlite3_strnicmp() APIs allow applications and extensions to compare
285 ** the contents of two buffers containing UTF-8 strings in a
286 ** case-independent fashion, using the same definition of "case
287 ** independence" that SQLite uses internally when comparing identifiers.
289 int sqlite3_stricmp(const char *zLeft
, const char *zRight
){
291 return zRight
? -1 : 0;
292 }else if( zRight
==0 ){
295 return sqlite3StrICmp(zLeft
, zRight
);
297 int sqlite3StrICmp(const char *zLeft
, const char *zRight
){
298 unsigned char *a
, *b
;
300 a
= (unsigned char *)zLeft
;
301 b
= (unsigned char *)zRight
;
303 c
= (int)UpperToLower
[*a
] - (int)UpperToLower
[*b
];
304 if( c
|| *a
==0 ) break;
310 int sqlite3_strnicmp(const char *zLeft
, const char *zRight
, int N
){
311 register unsigned char *a
, *b
;
313 return zRight
? -1 : 0;
314 }else if( zRight
==0 ){
317 a
= (unsigned char *)zLeft
;
318 b
= (unsigned char *)zRight
;
319 while( N
-- > 0 && *a
!=0 && UpperToLower
[*a
]==UpperToLower
[*b
]){ a
++; b
++; }
320 return N
<0 ? 0 : UpperToLower
[*a
] - UpperToLower
[*b
];
324 ** The string z[] is an text representation of a real number.
325 ** Convert this string to a double and write it into *pResult.
327 ** The string z[] is length bytes in length (bytes, not characters) and
328 ** uses the encoding enc. The string is not necessarily zero-terminated.
330 ** Return TRUE if the result is a valid real number (or integer) and FALSE
331 ** if the string is empty or contains extraneous text. Valid numbers
332 ** are in one of these formats:
334 ** [+-]digits[E[+-]digits]
335 ** [+-]digits.[digits][E[+-]digits]
336 ** [+-].digits[E[+-]digits]
338 ** Leading and trailing whitespace is ignored for the purpose of determining
341 ** If some prefix of the input string is a valid number, this routine
342 ** returns FALSE but it still converts the prefix and writes the result
345 int sqlite3AtoF(const char *z
, double *pResult
, int length
, u8 enc
){
346 #ifndef SQLITE_OMIT_FLOATING_POINT
348 const char *zEnd
= z
+ length
;
349 /* sign * significand * (10 ^ (esign * exponent)) */
350 int sign
= 1; /* sign of significand */
351 i64 s
= 0; /* significand */
352 int d
= 0; /* adjust exponent for shifting decimal point */
353 int esign
= 1; /* sign of exponent */
354 int e
= 0; /* exponent */
355 int eValid
= 1; /* True exponent is either not used or is well-formed */
358 int nonNum
= 0; /* True if input contains UTF16 with high byte non-zero */
360 assert( enc
==SQLITE_UTF8
|| enc
==SQLITE_UTF16LE
|| enc
==SQLITE_UTF16BE
);
361 *pResult
= 0.0; /* Default return value, in case of an error */
363 if( enc
==SQLITE_UTF8
){
368 assert( SQLITE_UTF16LE
==2 && SQLITE_UTF16BE
==3 );
369 for(i
=3-enc
; i
<length
&& z
[i
]==0; i
+=2){}
375 /* skip leading spaces */
376 while( z
<zEnd
&& sqlite3Isspace(*z
) ) z
+=incr
;
377 if( z
>=zEnd
) return 0;
379 /* get sign of significand */
387 /* copy max significant digits to significand */
388 while( z
<zEnd
&& sqlite3Isdigit(*z
) && s
<((LARGEST_INT64
-9)/10) ){
389 s
= s
*10 + (*z
- '0');
393 /* skip non-significant significand digits
394 ** (increase exponent by d to shift decimal left) */
395 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){ z
+=incr
; nDigits
++; d
++; }
396 if( z
>=zEnd
) goto do_atof_calc
;
398 /* if decimal point is present */
401 /* copy digits from after decimal to significand
402 ** (decrease exponent by d to shift decimal right) */
403 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){
404 if( s
<((LARGEST_INT64
-9)/10) ){
405 s
= s
*10 + (*z
- '0');
411 if( z
>=zEnd
) goto do_atof_calc
;
413 /* if exponent is present */
414 if( *z
=='e' || *z
=='E' ){
418 /* This branch is needed to avoid a (harmless) buffer overread. The
419 ** special comment alerts the mutation tester that the correct answer
420 ** is obtained even if the branch is omitted */
421 if( z
>=zEnd
) goto do_atof_calc
; /*PREVENTS-HARMLESS-OVERREAD*/
423 /* get sign of exponent */
430 /* copy digits to exponent */
431 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){
432 e
= e
<10000 ? (e
*10 + (*z
- '0')) : 10000;
438 /* skip trailing spaces */
439 while( z
<zEnd
&& sqlite3Isspace(*z
) ) z
+=incr
;
442 /* adjust exponent by d, and update sign */
452 /* In the IEEE 754 standard, zero is signed. */
453 result
= sign
<0 ? -(double)0 : (double)0;
455 /* Attempt to reduce exponent.
457 ** Branches that are not required for the correct answer but which only
458 ** help to obtain the correct answer faster are marked with special
459 ** comments, as a hint to the mutation tester.
461 while( e
>0 ){ /*OPTIMIZATION-IF-TRUE*/
463 if( s
>=(LARGEST_INT64
/10) ) break; /*OPTIMIZATION-IF-FALSE*/
466 if( s
%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/
472 /* adjust the sign of significand */
475 if( e
==0 ){ /*OPTIMIZATION-IF-TRUE*/
478 LONGDOUBLE_TYPE scale
= 1.0;
479 /* attempt to handle extremely small/large numbers better */
480 if( e
>307 ){ /*OPTIMIZATION-IF-TRUE*/
481 if( e
<342 ){ /*OPTIMIZATION-IF-TRUE*/
482 while( e
%308 ) { scale
*= 1.0e+1; e
-= 1; }
490 }else{ assert( e
>=342 );
497 result
= 1e308
*1e308
*s
; /* Infinity */
502 /* 1.0e+22 is the largest power of 10 than can be
503 ** represented exactly. */
504 while( e
%22 ) { scale
*= 1.0e+1; e
-= 1; }
505 while( e
>0 ) { scale
*= 1.0e+22; e
-= 22; }
515 /* store the result */
518 /* return true if number and no extra non-whitespace chracters after */
519 return z
==zEnd
&& nDigits
>0 && eValid
&& nonNum
==0;
521 return !sqlite3Atoi64(z
, pResult
, length
, enc
);
522 #endif /* SQLITE_OMIT_FLOATING_POINT */
526 ** Compare the 19-character string zNum against the text representation
527 ** value 2^63: 9223372036854775808. Return negative, zero, or positive
528 ** if zNum is less than, equal to, or greater than the string.
529 ** Note that zNum must contain exactly 19 characters.
531 ** Unlike memcmp() this routine is guaranteed to return the difference
532 ** in the values of the last digit if the only difference is in the
533 ** last digit. So, for example,
535 ** compare2pow63("9223372036854775800", 1)
539 static int compare2pow63(const char *zNum
, int incr
){
542 /* 012345678901234567 */
543 const char *pow63
= "922337203685477580";
544 for(i
=0; c
==0 && i
<18; i
++){
545 c
= (zNum
[i
*incr
]-pow63
[i
])*10;
548 c
= zNum
[18*incr
] - '8';
557 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
558 ** routine does *not* accept hexadecimal notation.
562 ** 0 Successful transformation. Fits in a 64-bit signed integer.
563 ** 1 Excess text after the integer value
564 ** 2 Integer too large for a 64-bit signed integer or is malformed
565 ** 3 Special case of 9223372036854775808
567 ** length is the number of bytes in the string (bytes, not characters).
568 ** The string is not necessarily zero-terminated. The encoding is
571 int sqlite3Atoi64(const char *zNum
, i64
*pNum
, int length
, u8 enc
){
574 int neg
= 0; /* assume positive */
577 int nonNum
= 0; /* True if input contains UTF16 with high byte non-zero */
578 int rc
; /* Baseline return code */
580 const char *zEnd
= zNum
+ length
;
581 assert( enc
==SQLITE_UTF8
|| enc
==SQLITE_UTF16LE
|| enc
==SQLITE_UTF16BE
);
582 if( enc
==SQLITE_UTF8
){
586 assert( SQLITE_UTF16LE
==2 && SQLITE_UTF16BE
==3 );
587 for(i
=3-enc
; i
<length
&& zNum
[i
]==0; i
+=2){}
592 while( zNum
<zEnd
&& sqlite3Isspace(*zNum
) ) zNum
+=incr
;
597 }else if( *zNum
=='+' ){
602 while( zNum
<zEnd
&& zNum
[0]=='0' ){ zNum
+=incr
; } /* Skip leading zeros. */
603 for(i
=0; &zNum
[i
]<zEnd
&& (c
=zNum
[i
])>='0' && c
<='9'; i
+=incr
){
606 if( u
>LARGEST_INT64
){
607 *pNum
= neg
? SMALLEST_INT64
: LARGEST_INT64
;
616 if( &zNum
[i
]<zEnd
/* Extra bytes at the end */
617 || (i
==0 && zStart
==zNum
) /* No digits */
618 || nonNum
/* UTF16 with high-order bytes non-zero */
624 if( i
>19*incr
){ /* Too many digits */
625 /* zNum is empty or contains non-numeric text or is longer
626 ** than 19 digits (thus guaranteeing that it is too large) */
628 }else if( i
<19*incr
){
629 /* Less than 19 digits, so we know that it fits in 64 bits */
630 assert( u
<=LARGEST_INT64
);
633 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
634 c
= compare2pow63(zNum
, incr
);
636 /* zNum is less than 9223372036854775808 so it fits */
637 assert( u
<=LARGEST_INT64
);
640 /* zNum is greater than 9223372036854775808 so it overflows */
643 /* zNum is exactly 9223372036854775808. Fits if negative. The
644 ** special case 2 overflow if positive */
645 assert( u
-1==LARGEST_INT64
);
652 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
653 ** into a 64-bit signed integer. This routine accepts hexadecimal literals,
654 ** whereas sqlite3Atoi64() does not.
658 ** 0 Successful transformation. Fits in a 64-bit signed integer.
659 ** 1 Excess text after the integer value
660 ** 2 Integer too large for a 64-bit signed integer or is malformed
661 ** 3 Special case of 9223372036854775808
663 int sqlite3DecOrHexToI64(const char *z
, i64
*pOut
){
664 #ifndef SQLITE_OMIT_HEX_INTEGER
666 && (z
[1]=='x' || z
[1]=='X')
670 for(i
=2; z
[i
]=='0'; i
++){}
671 for(k
=i
; sqlite3Isxdigit(z
[k
]); k
++){
672 u
= u
*16 + sqlite3HexToInt(z
[k
]);
675 return (z
[k
]==0 && k
-i
<=16) ? 0 : 2;
677 #endif /* SQLITE_OMIT_HEX_INTEGER */
679 return sqlite3Atoi64(z
, pOut
, sqlite3Strlen30(z
), SQLITE_UTF8
);
684 ** If zNum represents an integer that will fit in 32-bits, then set
685 ** *pValue to that integer and return true. Otherwise return false.
687 ** This routine accepts both decimal and hexadecimal notation for integers.
689 ** Any non-numeric characters that following zNum are ignored.
690 ** This is different from sqlite3Atoi64() which requires the
691 ** input number to be zero-terminated.
693 int sqlite3GetInt32(const char *zNum
, int *pValue
){
700 }else if( zNum
[0]=='+' ){
703 #ifndef SQLITE_OMIT_HEX_INTEGER
704 else if( zNum
[0]=='0'
705 && (zNum
[1]=='x' || zNum
[1]=='X')
706 && sqlite3Isxdigit(zNum
[2])
710 while( zNum
[0]=='0' ) zNum
++;
711 for(i
=0; sqlite3Isxdigit(zNum
[i
]) && i
<8; i
++){
712 u
= u
*16 + sqlite3HexToInt(zNum
[i
]);
714 if( (u
&0x80000000)==0 && sqlite3Isxdigit(zNum
[i
])==0 ){
715 memcpy(pValue
, &u
, 4);
722 if( !sqlite3Isdigit(zNum
[0]) ) return 0;
723 while( zNum
[0]=='0' ) zNum
++;
724 for(i
=0; i
<11 && (c
= zNum
[i
] - '0')>=0 && c
<=9; i
++){
728 /* The longest decimal representation of a 32 bit integer is 10 digits:
731 ** 2^31 -> 2147483648
737 testcase( v
-neg
==2147483647 );
738 if( v
-neg
>2147483647 ){
749 ** Return a 32-bit integer value extracted from a string. If the
750 ** string is not an integer, just return 0.
752 int sqlite3Atoi(const char *z
){
754 if( z
) sqlite3GetInt32(z
, &x
);
759 ** The variable-length integer encoding is as follows:
762 ** A = 0xxxxxxx 7 bits of data and one flag bit
763 ** B = 1xxxxxxx 7 bits of data and one flag bit
764 ** C = xxxxxxxx 8 bits of data
773 ** 56 bits - BBBBBBBA
774 ** 64 bits - BBBBBBBBC
778 ** Write a 64-bit variable-length integer to memory starting at p[0].
779 ** The length of data write will be between 1 and 9 bytes. The number
780 ** of bytes written is returned.
782 ** A variable-length integer consists of the lower 7 bits of each byte
783 ** for all bytes that have the 8th bit set and one byte with the 8th
784 ** bit clear. Except, if we get to the 9th byte, it stores the full
785 ** 8 bits and is the last byte.
787 static int SQLITE_NOINLINE
putVarint64(unsigned char *p
, u64 v
){
790 if( v
& (((u64
)0xff000000)<<32) ){
794 p
[i
] = (u8
)((v
& 0x7f) | 0x80);
801 buf
[n
++] = (u8
)((v
& 0x7f) | 0x80);
806 for(i
=0, j
=n
-1; j
>=0; j
--, i
++){
811 int sqlite3PutVarint(unsigned char *p
, u64 v
){
817 p
[0] = ((v
>>7)&0x7f)|0x80;
821 return putVarint64(p
,v
);
825 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
826 ** are defined here rather than simply putting the constant expressions
827 ** inline in order to work around bugs in the RVT compiler.
829 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
831 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
833 #define SLOT_2_0 0x001fc07f
834 #define SLOT_4_2_0 0xf01fc07f
838 ** Read a 64-bit variable-length integer from memory starting at p[0].
839 ** Return the number of bytes read. The value is stored in *v.
841 u8
sqlite3GetVarint(const unsigned char *p
, u64
*v
){
845 /* a: p0 (unmasked) */
854 /* b: p1 (unmasked) */
864 /* Verify that constants are precomputed correctly */
865 assert( SLOT_2_0
== ((0x7f<<14) | (0x7f)) );
866 assert( SLOT_4_2_0
== ((0xfU
<<28) | (0x7f<<14) | (0x7f)) );
871 /* a: p0<<14 | p2 (unmasked) */
882 /* CSE1 from below */
887 /* b: p1<<14 | p3 (unmasked) */
892 /* a &= (0x7f<<14)|(0x7f); */
899 /* a: p0<<14 | p2 (masked) */
900 /* b: p1<<14 | p3 (unmasked) */
901 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
903 /* a &= (0x7f<<14)|(0x7f); */
906 /* s: p0<<14 | p2 (masked) */
911 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
914 /* we can skip these cause they were (effectively) done above
915 ** while calculating s */
916 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
917 /* b &= (0x7f<<14)|(0x7f); */
921 *v
= ((u64
)s
)<<32 | a
;
925 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
928 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
933 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
936 /* we can skip this cause it was (effectively) done above in calc'ing s */
937 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
942 *v
= ((u64
)s
)<<32 | a
;
949 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
957 *v
= ((u64
)s
)<<32 | a
;
961 /* CSE2 from below */
966 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
971 /* a &= (0x7f<<14)|(0x7f); */
975 *v
= ((u64
)s
)<<32 | a
;
982 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
985 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
996 *v
= ((u64
)s
)<<32 | a
;
1002 ** Read a 32-bit variable-length integer from memory starting at p[0].
1003 ** Return the number of bytes read. The value is stored in *v.
1005 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
1006 ** integer, then set *v to 0xffffffff.
1008 ** A MACRO version, getVarint32, is provided which inlines the
1009 ** single-byte case. All code should use the MACRO version as
1010 ** this function assumes the single-byte case has already been handled.
1012 u8
sqlite3GetVarint32(const unsigned char *p
, u32
*v
){
1015 /* The 1-byte case. Overwhelmingly the most common. Handled inline
1016 ** by the getVarin32() macro */
1018 /* a: p0 (unmasked) */
1022 /* Values between 0 and 127 */
1028 /* The 2-byte case */
1031 /* b: p1 (unmasked) */
1034 /* Values between 128 and 16383 */
1041 /* The 3-byte case */
1045 /* a: p0<<14 | p2 (unmasked) */
1048 /* Values between 16384 and 2097151 */
1049 a
&= (0x7f<<14)|(0x7f);
1056 /* A 32-bit varint is used to store size information in btrees.
1057 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
1058 ** A 3-byte varint is sufficient, for example, to record the size
1059 ** of a 1048569-byte BLOB or string.
1061 ** We only unroll the first 1-, 2-, and 3- byte cases. The very
1062 ** rare larger cases can be handled by the slower 64-bit varint
1071 n
= sqlite3GetVarint(p
, &v64
);
1072 assert( n
>3 && n
<=9 );
1073 if( (v64
& SQLITE_MAX_U32
)!=v64
){
1082 /* For following code (kept for historical record only) shows an
1083 ** unrolling for the 3- and 4-byte varint cases. This code is
1084 ** slightly faster, but it is also larger and much harder to test.
1089 /* b: p1<<14 | p3 (unmasked) */
1092 /* Values between 2097152 and 268435455 */
1093 b
&= (0x7f<<14)|(0x7f);
1094 a
&= (0x7f<<14)|(0x7f);
1103 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1106 /* Values between 268435456 and 34359738367 */
1114 /* We can only reach this point when reading a corrupt database
1115 ** file. In that case we are not in any hurry. Use the (relatively
1116 ** slow) general-purpose sqlite3GetVarint() routine to extract the
1123 n
= sqlite3GetVarint(p
, &v64
);
1124 assert( n
>5 && n
<=9 );
1132 ** Return the number of bytes that will be needed to store the given
1135 int sqlite3VarintLen(u64 v
){
1137 for(i
=1; (v
>>= 7)!=0; i
++){ assert( i
<10 ); }
1143 ** Read or write a four-byte big-endian integer value.
1145 u32
sqlite3Get4byte(const u8
*p
){
1146 #if SQLITE_BYTEORDER==4321
1150 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
1153 return __builtin_bswap32(x
);
1154 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
1157 return _byteswap_ulong(x
);
1159 testcase( p
[0]&0x80 );
1160 return ((unsigned)p
[0]<<24) | (p
[1]<<16) | (p
[2]<<8) | p
[3];
1163 void sqlite3Put4byte(unsigned char *p
, u32 v
){
1164 #if SQLITE_BYTEORDER==4321
1166 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
1167 u32 x
= __builtin_bswap32(v
);
1169 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
1170 u32 x
= _byteswap_ulong(v
);
1183 ** Translate a single byte of Hex into an integer.
1184 ** This routine only works if h really is a valid hexadecimal
1185 ** character: 0..9a..fA..F
1187 u8
sqlite3HexToInt(int h
){
1188 assert( (h
>='0' && h
<='9') || (h
>='a' && h
<='f') || (h
>='A' && h
<='F') );
1192 #ifdef SQLITE_EBCDIC
1195 return (u8
)(h
& 0xf);
1198 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
1200 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1201 ** value. Return a pointer to its binary value. Space to hold the
1202 ** binary value has been obtained from malloc and must be freed by
1203 ** the calling routine.
1205 void *sqlite3HexToBlob(sqlite3
*db
, const char *z
, int n
){
1209 zBlob
= (char *)sqlite3DbMallocRawNN(db
, n
/2 + 1);
1212 for(i
=0; i
<n
; i
+=2){
1213 zBlob
[i
/2] = (sqlite3HexToInt(z
[i
])<<4) | sqlite3HexToInt(z
[i
+1]);
1219 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
1222 ** Log an error that is an API call on a connection pointer that should
1223 ** not have been used. The "type" of connection pointer is given as the
1224 ** argument. The zType is a word like "NULL" or "closed" or "invalid".
1226 static void logBadConnection(const char *zType
){
1227 sqlite3_log(SQLITE_MISUSE
,
1228 "API call with %s database connection pointer",
1234 ** Check to make sure we have a valid db pointer. This test is not
1235 ** foolproof but it does provide some measure of protection against
1236 ** misuse of the interface such as passing in db pointers that are
1237 ** NULL or which have been previously closed. If this routine returns
1238 ** 1 it means that the db pointer is valid and 0 if it should not be
1239 ** dereferenced for any reason. The calling function should invoke
1240 ** SQLITE_MISUSE immediately.
1242 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1243 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1244 ** open properly and is not fit for general use but which can be
1245 ** used as an argument to sqlite3_errmsg() or sqlite3_close().
1247 int sqlite3SafetyCheckOk(sqlite3
*db
){
1250 logBadConnection("NULL");
1254 if( magic
!=SQLITE_MAGIC_OPEN
){
1255 if( sqlite3SafetyCheckSickOrOk(db
) ){
1256 testcase( sqlite3GlobalConfig
.xLog
!=0 );
1257 logBadConnection("unopened");
1264 int sqlite3SafetyCheckSickOrOk(sqlite3
*db
){
1267 if( magic
!=SQLITE_MAGIC_SICK
&&
1268 magic
!=SQLITE_MAGIC_OPEN
&&
1269 magic
!=SQLITE_MAGIC_BUSY
){
1270 testcase( sqlite3GlobalConfig
.xLog
!=0 );
1271 logBadConnection("invalid");
1279 ** Attempt to add, substract, or multiply the 64-bit signed value iB against
1280 ** the other 64-bit signed integer at *pA and store the result in *pA.
1281 ** Return 0 on success. Or if the operation would have resulted in an
1282 ** overflow, leave *pA unchanged and return 1.
1284 int sqlite3AddInt64(i64
*pA
, i64 iB
){
1285 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1286 return __builtin_add_overflow(*pA
, iB
, pA
);
1289 testcase( iA
==0 ); testcase( iA
==1 );
1290 testcase( iB
==-1 ); testcase( iB
==0 );
1292 testcase( iA
>0 && LARGEST_INT64
- iA
== iB
);
1293 testcase( iA
>0 && LARGEST_INT64
- iA
== iB
- 1 );
1294 if( iA
>0 && LARGEST_INT64
- iA
< iB
) return 1;
1296 testcase( iA
<0 && -(iA
+ LARGEST_INT64
) == iB
+ 1 );
1297 testcase( iA
<0 && -(iA
+ LARGEST_INT64
) == iB
+ 2 );
1298 if( iA
<0 && -(iA
+ LARGEST_INT64
) > iB
+ 1 ) return 1;
1304 int sqlite3SubInt64(i64
*pA
, i64 iB
){
1305 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1306 return __builtin_sub_overflow(*pA
, iB
, pA
);
1308 testcase( iB
==SMALLEST_INT64
+1 );
1309 if( iB
==SMALLEST_INT64
){
1310 testcase( (*pA
)==(-1) ); testcase( (*pA
)==0 );
1311 if( (*pA
)>=0 ) return 1;
1315 return sqlite3AddInt64(pA
, -iB
);
1319 int sqlite3MulInt64(i64
*pA
, i64 iB
){
1320 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1321 return __builtin_mul_overflow(*pA
, iB
, pA
);
1325 if( iA
>LARGEST_INT64
/iB
) return 1;
1326 if( iA
<SMALLEST_INT64
/iB
) return 1;
1329 if( iB
<SMALLEST_INT64
/iA
) return 1;
1331 if( iB
==SMALLEST_INT64
) return 1;
1332 if( iA
==SMALLEST_INT64
) return 1;
1333 if( -iA
>LARGEST_INT64
/-iB
) return 1;
1342 ** Compute the absolute value of a 32-bit signed integer, of possible. Or
1343 ** if the integer has a value of -2147483648, return +2147483647
1345 int sqlite3AbsInt32(int x
){
1346 if( x
>=0 ) return x
;
1347 if( x
==(int)0x80000000 ) return 0x7fffffff;
1351 #ifdef SQLITE_ENABLE_8_3_NAMES
1353 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
1354 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1355 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1356 ** three characters, then shorten the suffix on z[] to be the last three
1357 ** characters of the original suffix.
1359 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1360 ** do the suffix shortening regardless of URI parameter.
1364 ** test.db-journal => test.nal
1365 ** test.db-wal => test.wal
1366 ** test.db-shm => test.shm
1367 ** test.db-mj7f3319fa => test.9fa
1369 void sqlite3FileSuffix3(const char *zBaseFilename
, char *z
){
1370 #if SQLITE_ENABLE_8_3_NAMES<2
1371 if( sqlite3_uri_boolean(zBaseFilename
, "8_3_names", 0) )
1375 sz
= sqlite3Strlen30(z
);
1376 for(i
=sz
-1; i
>0 && z
[i
]!='/' && z
[i
]!='.'; i
--){}
1377 if( z
[i
]=='.' && ALWAYS(sz
>i
+4) ) memmove(&z
[i
+1], &z
[sz
-3], 4);
1383 ** Find (an approximate) sum of two LogEst values. This computation is
1384 ** not a simple "+" operator because LogEst is stored as a logarithmic
1388 LogEst
sqlite3LogEstAdd(LogEst a
, LogEst b
){
1389 static const unsigned char x
[] = {
1393 7, 7, 7, /* 6,7,8 */
1394 6, 6, 6, /* 9,10,11 */
1395 5, 5, 5, /* 12-14 */
1396 4, 4, 4, 4, /* 15-18 */
1397 3, 3, 3, 3, 3, 3, /* 19-24 */
1398 2, 2, 2, 2, 2, 2, 2, /* 25-31 */
1401 if( a
>b
+49 ) return a
;
1402 if( a
>b
+31 ) return a
+1;
1405 if( b
>a
+49 ) return b
;
1406 if( b
>a
+31 ) return b
+1;
1412 ** Convert an integer into a LogEst. In other words, compute an
1413 ** approximation for 10*log2(x).
1415 LogEst
sqlite3LogEst(u64 x
){
1416 static LogEst a
[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
1420 while( x
<8 ){ y
-= 10; x
<<= 1; }
1422 #if GCC_VERSION>=5004000
1423 int i
= 60 - __builtin_clzll(x
);
1427 while( x
>255 ){ y
+= 40; x
>>= 4; } /*OPTIMIZATION-IF-TRUE*/
1428 while( x
>15 ){ y
+= 10; x
>>= 1; }
1431 return a
[x
&7] + y
- 10;
1434 #ifndef SQLITE_OMIT_VIRTUALTABLE
1436 ** Convert a double into a LogEst
1437 ** In other words, compute an approximation for 10*log2(x).
1439 LogEst
sqlite3LogEstFromDouble(double x
){
1442 assert( sizeof(x
)==8 && sizeof(a
)==8 );
1443 if( x
<=1 ) return 0;
1444 if( x
<=2000000000 ) return sqlite3LogEst((u64
)x
);
1449 #endif /* SQLITE_OMIT_VIRTUALTABLE */
1451 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
1452 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
1453 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
1455 ** Convert a LogEst into an integer.
1457 ** Note that this routine is only used when one or more of various
1458 ** non-standard compile-time options is enabled.
1460 u64
sqlite3LogEstToInt(LogEst x
){
1465 else if( n
>=1 ) n
-= 1;
1466 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
1467 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
1468 if( x
>60 ) return (u64
)LARGEST_INT64
;
1470 /* If only SQLITE_ENABLE_STAT3_OR_STAT4 is on, then the largest input
1471 ** possible to this routine is 310, resulting in a maximum x of 31 */
1474 return x
>=3 ? (n
+8)<<(x
-3) : (n
+8)>>(3-x
);
1476 #endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */
1479 ** Add a new name/number pair to a VList. This might require that the
1480 ** VList object be reallocated, so return the new VList. If an OOM
1481 ** error occurs, the original VList returned and the
1482 ** db->mallocFailed flag is set.
1484 ** A VList is really just an array of integers. To destroy a VList,
1485 ** simply pass it to sqlite3DbFree().
1487 ** The first integer is the number of integers allocated for the whole
1488 ** VList. The second integer is the number of integers actually used.
1489 ** Each name/number pair is encoded by subsequent groups of 3 or more
1492 ** Each name/number pair starts with two integers which are the numeric
1493 ** value for the pair and the size of the name/number pair, respectively.
1494 ** The text name overlays one or more following integers. The text name
1495 ** is always zero-terminated.
1500 ** int nAlloc; // Number of allocated slots
1501 ** int nUsed; // Number of used slots
1502 ** struct VListEntry {
1503 ** int iValue; // Value for this entry
1504 ** int nSlot; // Slots used by this entry
1505 ** // ... variable name goes here
1509 ** During code generation, pointers to the variable names within the
1510 ** VList are taken. When that happens, nAlloc is set to zero as an
1511 ** indication that the VList may never again be enlarged, since the
1512 ** accompanying realloc() would invalidate the pointers.
1514 VList
*sqlite3VListAdd(
1515 sqlite3
*db
, /* The database connection used for malloc() */
1516 VList
*pIn
, /* The input VList. Might be NULL */
1517 const char *zName
, /* Name of symbol to add */
1518 int nName
, /* Bytes of text in zName */
1519 int iVal
/* Value to associate with zName */
1521 int nInt
; /* number of sizeof(int) objects needed for zName */
1522 char *z
; /* Pointer to where zName will be stored */
1523 int i
; /* Index in pIn[] where zName is stored */
1526 assert( pIn
==0 || pIn
[0]>=3 ); /* Verify ok to add new elements */
1527 if( pIn
==0 || pIn
[1]+nInt
> pIn
[0] ){
1528 /* Enlarge the allocation */
1529 int nAlloc
= (pIn
? pIn
[0]*2 : 10) + nInt
;
1530 VList
*pOut
= sqlite3DbRealloc(db
, pIn
, nAlloc
*sizeof(int));
1531 if( pOut
==0 ) return pIn
;
1532 if( pIn
==0 ) pOut
[1] = 2;
1539 z
= (char*)&pIn
[i
+2];
1541 assert( pIn
[1]<=pIn
[0] );
1542 memcpy(z
, zName
, nName
);
1548 ** Return a pointer to the name of a variable in the given VList that
1549 ** has the value iVal. Or return a NULL if there is no such variable in
1552 const char *sqlite3VListNumToName(VList
*pIn
, int iVal
){
1554 if( pIn
==0 ) return 0;
1558 if( pIn
[i
]==iVal
) return (char*)&pIn
[i
+2];
1565 ** Return the number of the variable named zName, if it is in VList.
1566 ** or return 0 if there is no such variable.
1568 int sqlite3VListNameToNum(VList
*pIn
, const char *zName
, int nName
){
1570 if( pIn
==0 ) return 0;
1574 const char *z
= (const char*)&pIn
[i
+2];
1575 if( strncmp(z
,zName
,nName
)==0 && z
[nName
]==0 ) return pIn
[i
];