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 #ifndef SQLITE_OMIT_FLOATING_POINT
25 ** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
26 ** or to bypass normal error detection during testing in order to let
27 ** execute proceed futher downstream.
29 ** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The
30 ** sqlite3FaultSim() function only returns non-zero during testing.
32 ** During testing, if the test harness has set a fault-sim callback using
33 ** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then
34 ** each call to sqlite3FaultSim() is relayed to that application-supplied
35 ** callback and the integer return value form the application-supplied
36 ** callback is returned by sqlite3FaultSim().
38 ** The integer argument to sqlite3FaultSim() is a code to identify which
39 ** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim()
40 ** should have a unique code. To prevent legacy testing applications from
41 ** breaking, the codes should not be changed or reused.
43 #ifndef SQLITE_UNTESTABLE
44 int sqlite3FaultSim(int iTest
){
45 int (*xCallback
)(int) = sqlite3GlobalConfig
.xTestCallback
;
46 return xCallback
? xCallback(iTest
) : SQLITE_OK
;
50 #ifndef SQLITE_OMIT_FLOATING_POINT
52 ** Return true if the floating point value is Not a Number (NaN).
54 ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
55 ** Otherwise, we have our own implementation that works on most systems.
57 int sqlite3IsNaN(double x
){
58 int rc
; /* The value return */
59 #if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
61 memcpy(&y
,&x
,sizeof(y
));
65 #endif /* HAVE_ISNAN */
69 #endif /* SQLITE_OMIT_FLOATING_POINT */
72 ** Compute a string length that is limited to what can be stored in
73 ** lower 30 bits of a 32-bit signed integer.
75 ** The value returned will never be negative. Nor will it ever be greater
76 ** than the actual length of the string. For very long strings (greater
77 ** than 1GiB) the value returned might be less than the true string length.
79 int sqlite3Strlen30(const char *z
){
81 return 0x3fffffff & (int)strlen(z
);
85 ** Return the declared type of a column. Or return zDflt if the column
86 ** has no declared type.
88 ** The column type is an extra string stored after the zero-terminator on
89 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
91 char *sqlite3ColumnType(Column
*pCol
, char *zDflt
){
92 if( pCol
->colFlags
& COLFLAG_HASTYPE
){
93 return pCol
->zCnName
+ strlen(pCol
->zCnName
) + 1;
94 }else if( pCol
->eCType
){
95 assert( pCol
->eCType
<=SQLITE_N_STDTYPE
);
96 return (char*)sqlite3StdType
[pCol
->eCType
-1];
103 ** Helper function for sqlite3Error() - called rarely. Broken out into
104 ** a separate routine to avoid unnecessary register saves on entry to
107 static SQLITE_NOINLINE
void sqlite3ErrorFinish(sqlite3
*db
, int err_code
){
108 if( db
->pErr
) sqlite3ValueSetNull(db
->pErr
);
109 sqlite3SystemError(db
, err_code
);
113 ** Set the current error code to err_code and clear any prior error message.
114 ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
115 ** that would be appropriate.
117 void sqlite3Error(sqlite3
*db
, int err_code
){
119 db
->errCode
= err_code
;
120 if( err_code
|| db
->pErr
){
121 sqlite3ErrorFinish(db
, err_code
);
123 db
->errByteOffset
= -1;
128 ** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state
129 ** and error message.
131 void sqlite3ErrorClear(sqlite3
*db
){
133 db
->errCode
= SQLITE_OK
;
134 db
->errByteOffset
= -1;
135 if( db
->pErr
) sqlite3ValueSetNull(db
->pErr
);
139 ** Load the sqlite3.iSysErrno field if that is an appropriate thing
140 ** to do based on the SQLite error code in rc.
142 void sqlite3SystemError(sqlite3
*db
, int rc
){
143 if( rc
==SQLITE_IOERR_NOMEM
) return;
145 if( rc
==SQLITE_CANTOPEN
|| rc
==SQLITE_IOERR
){
146 db
->iSysErrno
= sqlite3OsGetLastError(db
->pVfs
);
151 ** Set the most recent error code and error string for the sqlite
152 ** handle "db". The error code is set to "err_code".
154 ** If it is not NULL, string zFormat specifies the format of the
155 ** error string. zFormat and any string tokens that follow it are
156 ** assumed to be encoded in UTF-8.
158 ** To clear the most recent error for sqlite handle "db", sqlite3Error
159 ** should be called with err_code set to SQLITE_OK and zFormat set
162 void sqlite3ErrorWithMsg(sqlite3
*db
, int err_code
, const char *zFormat
, ...){
164 db
->errCode
= err_code
;
165 sqlite3SystemError(db
, err_code
);
167 sqlite3Error(db
, err_code
);
168 }else if( db
->pErr
|| (db
->pErr
= sqlite3ValueNew(db
))!=0 ){
171 va_start(ap
, zFormat
);
172 z
= sqlite3VMPrintf(db
, zFormat
, ap
);
174 sqlite3ValueSetStr(db
->pErr
, -1, z
, SQLITE_UTF8
, SQLITE_DYNAMIC
);
179 ** Check for interrupts and invoke progress callback.
181 void sqlite3ProgressCheck(Parse
*p
){
183 if( AtomicLoad(&db
->u1
.isInterrupted
) ){
185 p
->rc
= SQLITE_INTERRUPT
;
187 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
188 if( db
->xProgress
&& (++p
->nProgressSteps
)>=db
->nProgressOps
){
189 if( db
->xProgress(db
->pProgressArg
) ){
191 p
->rc
= SQLITE_INTERRUPT
;
193 p
->nProgressSteps
= 0;
199 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
201 ** This function should be used to report any error that occurs while
202 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
203 ** last thing the sqlite3_prepare() function does is copy the error
204 ** stored by this function into the database handle using sqlite3Error().
205 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
206 ** during statement execution (sqlite3_step() etc.).
208 void sqlite3ErrorMsg(Parse
*pParse
, const char *zFormat
, ...){
211 sqlite3
*db
= pParse
->db
;
213 assert( db
->pParse
==pParse
|| db
->pParse
->pToplevel
==pParse
);
214 db
->errByteOffset
= -2;
215 va_start(ap
, zFormat
);
216 zMsg
= sqlite3VMPrintf(db
, zFormat
, ap
);
218 if( db
->errByteOffset
<-1 ) db
->errByteOffset
= -1;
219 if( db
->suppressErr
){
220 sqlite3DbFree(db
, zMsg
);
221 if( db
->mallocFailed
){
223 pParse
->rc
= SQLITE_NOMEM
;
227 sqlite3DbFree(db
, pParse
->zErrMsg
);
228 pParse
->zErrMsg
= zMsg
;
229 pParse
->rc
= SQLITE_ERROR
;
235 ** If database connection db is currently parsing SQL, then transfer
236 ** error code errCode to that parser if the parser has not already
237 ** encountered some other kind of error.
239 int sqlite3ErrorToParser(sqlite3
*db
, int errCode
){
241 if( db
==0 || (pParse
= db
->pParse
)==0 ) return errCode
;
242 pParse
->rc
= errCode
;
248 ** Convert an SQL-style quoted string into a normal string by removing
249 ** the quote characters. The conversion is done in-place. If the
250 ** input does not begin with a quote character, then this routine
253 ** The input string must be zero-terminated. A new zero-terminator
254 ** is added to the dequoted string.
256 ** The return value is -1 if no dequoting occurs or the length of the
257 ** dequoted string, exclusive of the zero terminator, if dequoting does
260 ** 2002-02-14: This routine is extended to remove MS-Access style
261 ** brackets from around identifiers. For example: "[a-b-c]" becomes
264 void sqlite3Dequote(char *z
){
269 if( !sqlite3Isquote(quote
) ) return;
270 if( quote
=='[' ) quote
= ']';
286 void sqlite3DequoteExpr(Expr
*p
){
287 assert( !ExprHasProperty(p
, EP_IntValue
) );
288 assert( sqlite3Isquote(p
->u
.zToken
[0]) );
289 p
->flags
|= p
->u
.zToken
[0]=='"' ? EP_Quoted
|EP_DblQuoted
: EP_Quoted
;
290 sqlite3Dequote(p
->u
.zToken
);
294 ** If the input token p is quoted, try to adjust the token to remove
295 ** the quotes. This is not always possible:
298 ** "ab""cd" -> (not possible because of the interior "")
300 ** Remove the quotes if possible. This is a optimization. The overall
301 ** system should still return the correct answer even if this routine
302 ** is always a no-op.
304 void sqlite3DequoteToken(Token
*p
){
307 if( !sqlite3Isquote(p
->z
[0]) ) return;
308 for(i
=1; i
<p
->n
-1; i
++){
309 if( sqlite3Isquote(p
->z
[i
]) ) return;
316 ** Generate a Token object from a string
318 void sqlite3TokenInit(Token
*p
, char *z
){
320 p
->n
= sqlite3Strlen30(z
);
323 /* Convenient short-hand */
324 #define UpperToLower sqlite3UpperToLower
327 ** Some systems have stricmp(). Others have strcasecmp(). Because
328 ** there is no consistency, we will define our own.
330 ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
331 ** sqlite3_strnicmp() APIs allow applications and extensions to compare
332 ** the contents of two buffers containing UTF-8 strings in a
333 ** case-independent fashion, using the same definition of "case
334 ** independence" that SQLite uses internally when comparing identifiers.
336 int sqlite3_stricmp(const char *zLeft
, const char *zRight
){
338 return zRight
? -1 : 0;
339 }else if( zRight
==0 ){
342 return sqlite3StrICmp(zLeft
, zRight
);
344 int sqlite3StrICmp(const char *zLeft
, const char *zRight
){
345 unsigned char *a
, *b
;
347 a
= (unsigned char *)zLeft
;
348 b
= (unsigned char *)zRight
;
355 c
= (int)UpperToLower
[c
] - (int)UpperToLower
[x
];
363 int sqlite3_strnicmp(const char *zLeft
, const char *zRight
, int N
){
364 register unsigned char *a
, *b
;
366 return zRight
? -1 : 0;
367 }else if( zRight
==0 ){
370 a
= (unsigned char *)zLeft
;
371 b
= (unsigned char *)zRight
;
372 while( N
-- > 0 && *a
!=0 && UpperToLower
[*a
]==UpperToLower
[*b
]){ a
++; b
++; }
373 return N
<0 ? 0 : UpperToLower
[*a
] - UpperToLower
[*b
];
377 ** Compute an 8-bit hash on a string that is insensitive to case differences
379 u8
sqlite3StrIHash(const char *z
){
383 h
+= UpperToLower
[(unsigned char)z
[0]];
390 ** Compute 10 to the E-th power. Examples: E==1 results in 10.
391 ** E==2 results in 100. E==50 results in 1.0e50.
393 ** This routine only works for values of E between 1 and 341.
395 static LONGDOUBLE_TYPE
sqlite3Pow10(int E
){
396 #if defined(_MSC_VER)
397 static const LONGDOUBLE_TYPE x
[] = {
408 LONGDOUBLE_TYPE r
= 1.0;
410 assert( E
>=0 && E
<=307 );
411 for(i
=0; E
!=0; i
++, E
>>=1){
412 if( E
& 1 ) r
*= x
[i
];
416 LONGDOUBLE_TYPE x
= 10.0;
417 LONGDOUBLE_TYPE r
= 1.0;
429 ** The string z[] is an text representation of a real number.
430 ** Convert this string to a double and write it into *pResult.
432 ** The string z[] is length bytes in length (bytes, not characters) and
433 ** uses the encoding enc. The string is not necessarily zero-terminated.
435 ** Return TRUE if the result is a valid real number (or integer) and FALSE
436 ** if the string is empty or contains extraneous text. More specifically
438 ** 1 => The input string is a pure integer
439 ** 2 or more => The input has a decimal point or eNNN clause
440 ** 0 or less => The input string is not a valid number
441 ** -1 => Not a valid number, but has a valid prefix which
442 ** includes a decimal point and/or an eNNN clause
444 ** Valid numbers are in one of these formats:
446 ** [+-]digits[E[+-]digits]
447 ** [+-]digits.[digits][E[+-]digits]
448 ** [+-].digits[E[+-]digits]
450 ** Leading and trailing whitespace is ignored for the purpose of determining
453 ** If some prefix of the input string is a valid number, this routine
454 ** returns FALSE but it still converts the prefix and writes the result
457 #if defined(_MSC_VER)
458 #pragma warning(disable : 4756)
460 int sqlite3AtoF(const char *z
, double *pResult
, int length
, u8 enc
){
461 #ifndef SQLITE_OMIT_FLOATING_POINT
464 /* sign * significand * (10 ^ (esign * exponent)) */
465 int sign
= 1; /* sign of significand */
466 i64 s
= 0; /* significand */
467 int d
= 0; /* adjust exponent for shifting decimal point */
468 int esign
= 1; /* sign of exponent */
469 int e
= 0; /* exponent */
470 int eValid
= 1; /* True exponent is either not used or is well-formed */
472 int nDigit
= 0; /* Number of digits processed */
473 int eType
= 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */
475 assert( enc
==SQLITE_UTF8
|| enc
==SQLITE_UTF16LE
|| enc
==SQLITE_UTF16BE
);
476 *pResult
= 0.0; /* Default return value, in case of an error */
477 if( length
==0 ) return 0;
479 if( enc
==SQLITE_UTF8
){
486 assert( SQLITE_UTF16LE
==2 && SQLITE_UTF16BE
==3 );
487 testcase( enc
==SQLITE_UTF16LE
);
488 testcase( enc
==SQLITE_UTF16BE
);
489 for(i
=3-enc
; i
<length
&& z
[i
]==0; i
+=2){}
490 if( i
<length
) eType
= -100;
495 /* skip leading spaces */
496 while( z
<zEnd
&& sqlite3Isspace(*z
) ) z
+=incr
;
497 if( z
>=zEnd
) return 0;
499 /* get sign of significand */
507 /* copy max significant digits to significand */
508 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){
509 s
= s
*10 + (*z
- '0');
511 if( s
>=((LARGEST_INT64
-9)/10) ){
512 /* skip non-significant significand digits
513 ** (increase exponent by d to shift decimal left) */
514 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){ z
+=incr
; d
++; }
517 if( z
>=zEnd
) goto do_atof_calc
;
519 /* if decimal point is present */
523 /* copy digits from after decimal to significand
524 ** (decrease exponent by d to shift decimal right) */
525 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){
526 if( s
<((LARGEST_INT64
-9)/10) ){
527 s
= s
*10 + (*z
- '0');
534 if( z
>=zEnd
) goto do_atof_calc
;
536 /* if exponent is present */
537 if( *z
=='e' || *z
=='E' ){
542 /* This branch is needed to avoid a (harmless) buffer overread. The
543 ** special comment alerts the mutation tester that the correct answer
544 ** is obtained even if the branch is omitted */
545 if( z
>=zEnd
) goto do_atof_calc
; /*PREVENTS-HARMLESS-OVERREAD*/
547 /* get sign of exponent */
554 /* copy digits to exponent */
555 while( z
<zEnd
&& sqlite3Isdigit(*z
) ){
556 e
= e
<10000 ? (e
*10 + (*z
- '0')) : 10000;
562 /* skip trailing spaces */
563 while( z
<zEnd
&& sqlite3Isspace(*z
) ) z
+=incr
;
566 /* adjust exponent by d, and update sign */
576 /* In the IEEE 754 standard, zero is signed. */
577 result
= sign
<0 ? -(double)0 : (double)0;
579 /* Attempt to reduce exponent.
581 ** Branches that are not required for the correct answer but which only
582 ** help to obtain the correct answer faster are marked with special
583 ** comments, as a hint to the mutation tester.
585 while( e
>0 ){ /*OPTIMIZATION-IF-TRUE*/
587 if( s
>=(LARGEST_INT64
/10) ) break; /*OPTIMIZATION-IF-FALSE*/
590 if( s
%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/
596 /* adjust the sign of significand */
599 if( e
==0 ){ /*OPTIMIZATION-IF-TRUE*/
602 /* attempt to handle extremely small/large numbers better */
603 if( e
>307 ){ /*OPTIMIZATION-IF-TRUE*/
604 if( e
<342 ){ /*OPTIMIZATION-IF-TRUE*/
605 LONGDOUBLE_TYPE scale
= sqlite3Pow10(e
-308);
613 }else{ assert( e
>=342 );
620 result
= 1e308
*1e308
*s
; /* Infinity */
625 LONGDOUBLE_TYPE scale
= sqlite3Pow10(e
);
635 /* store the result */
638 /* return true if number and no extra non-whitespace chracters after */
639 if( z
==zEnd
&& nDigit
>0 && eValid
&& eType
>0 ){
641 }else if( eType
>=2 && (eType
==3 || eValid
) && nDigit
>0 ){
647 return !sqlite3Atoi64(z
, pResult
, length
, enc
);
648 #endif /* SQLITE_OMIT_FLOATING_POINT */
650 #if defined(_MSC_VER)
651 #pragma warning(default : 4756)
655 ** Render an signed 64-bit integer as text. Store the result in zOut[] and
656 ** return the length of the string that was stored, in bytes. The value
657 ** returned does not include the zero terminator at the end of the output
660 ** The caller must ensure that zOut[] is at least 21 bytes in size.
662 int sqlite3Int64ToText(i64 v
, char *zOut
){
667 x
= (v
==SMALLEST_INT64
) ? ((u64
)1)<<63 : (u64
)-v
;
672 zTemp
[sizeof(zTemp
)-1] = 0;
673 while( 1 /*exit-by-break*/ ){
674 zTemp
[i
] = (x
%10) + '0';
679 if( v
<0 ) zTemp
[--i
] = '-';
680 memcpy(zOut
, &zTemp
[i
], sizeof(zTemp
)-i
);
681 return sizeof(zTemp
)-1-i
;
685 ** Compare the 19-character string zNum against the text representation
686 ** value 2^63: 9223372036854775808. Return negative, zero, or positive
687 ** if zNum is less than, equal to, or greater than the string.
688 ** Note that zNum must contain exactly 19 characters.
690 ** Unlike memcmp() this routine is guaranteed to return the difference
691 ** in the values of the last digit if the only difference is in the
692 ** last digit. So, for example,
694 ** compare2pow63("9223372036854775800", 1)
698 static int compare2pow63(const char *zNum
, int incr
){
701 /* 012345678901234567 */
702 const char *pow63
= "922337203685477580";
703 for(i
=0; c
==0 && i
<18; i
++){
704 c
= (zNum
[i
*incr
]-pow63
[i
])*10;
707 c
= zNum
[18*incr
] - '8';
716 ** Convert zNum to a 64-bit signed integer. zNum must be decimal. This
717 ** routine does *not* accept hexadecimal notation.
721 ** -1 Not even a prefix of the input text looks like an integer
722 ** 0 Successful transformation. Fits in a 64-bit signed integer.
723 ** 1 Excess non-space text after the integer value
724 ** 2 Integer too large for a 64-bit signed integer or is malformed
725 ** 3 Special case of 9223372036854775808
727 ** length is the number of bytes in the string (bytes, not characters).
728 ** The string is not necessarily zero-terminated. The encoding is
731 int sqlite3Atoi64(const char *zNum
, i64
*pNum
, int length
, u8 enc
){
734 int neg
= 0; /* assume positive */
737 int nonNum
= 0; /* True if input contains UTF16 with high byte non-zero */
738 int rc
; /* Baseline return code */
740 const char *zEnd
= zNum
+ length
;
741 assert( enc
==SQLITE_UTF8
|| enc
==SQLITE_UTF16LE
|| enc
==SQLITE_UTF16BE
);
742 if( enc
==SQLITE_UTF8
){
747 assert( SQLITE_UTF16LE
==2 && SQLITE_UTF16BE
==3 );
748 for(i
=3-enc
; i
<length
&& zNum
[i
]==0; i
+=2){}
753 while( zNum
<zEnd
&& sqlite3Isspace(*zNum
) ) zNum
+=incr
;
758 }else if( *zNum
=='+' ){
763 while( zNum
<zEnd
&& zNum
[0]=='0' ){ zNum
+=incr
; } /* Skip leading zeros. */
764 for(i
=0; &zNum
[i
]<zEnd
&& (c
=zNum
[i
])>='0' && c
<='9'; i
+=incr
){
767 testcase( i
==18*incr
);
768 testcase( i
==19*incr
);
769 testcase( i
==20*incr
);
770 if( u
>LARGEST_INT64
){
771 /* This test and assignment is needed only to suppress UB warnings
772 ** from clang and -fsanitize=undefined. This test and assignment make
773 ** the code a little larger and slower, and no harm comes from omitting
774 ** them, but we must appaise the undefined-behavior pharisees. */
775 *pNum
= neg
? SMALLEST_INT64
: LARGEST_INT64
;
782 if( i
==0 && zStart
==zNum
){ /* No digits */
784 }else if( nonNum
){ /* UTF16 with high-order bytes non-zero */
786 }else if( &zNum
[i
]<zEnd
){ /* Extra bytes at the end */
789 if( !sqlite3Isspace(zNum
[jj
]) ){
790 rc
= 1; /* Extra non-space text after the integer */
794 }while( &zNum
[jj
]<zEnd
);
797 /* Less than 19 digits, so we know that it fits in 64 bits */
798 assert( u
<=LARGEST_INT64
);
801 /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
802 c
= i
>19*incr
? 1 : compare2pow63(zNum
, incr
);
804 /* zNum is less than 9223372036854775808 so it fits */
805 assert( u
<=LARGEST_INT64
);
808 *pNum
= neg
? SMALLEST_INT64
: LARGEST_INT64
;
810 /* zNum is greater than 9223372036854775808 so it overflows */
813 /* zNum is exactly 9223372036854775808. Fits if negative. The
814 ** special case 2 overflow if positive */
815 assert( u
-1==LARGEST_INT64
);
823 ** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
824 ** into a 64-bit signed integer. This routine accepts hexadecimal literals,
825 ** whereas sqlite3Atoi64() does not.
829 ** 0 Successful transformation. Fits in a 64-bit signed integer.
830 ** 1 Excess text after the integer value
831 ** 2 Integer too large for a 64-bit signed integer or is malformed
832 ** 3 Special case of 9223372036854775808
834 int sqlite3DecOrHexToI64(const char *z
, i64
*pOut
){
835 #ifndef SQLITE_OMIT_HEX_INTEGER
837 && (z
[1]=='x' || z
[1]=='X')
841 for(i
=2; z
[i
]=='0'; i
++){}
842 for(k
=i
; sqlite3Isxdigit(z
[k
]); k
++){
843 u
= u
*16 + sqlite3HexToInt(z
[k
]);
846 if( k
-i
>16 ) return 2;
847 if( z
[k
]!=0 ) return 1;
850 #endif /* SQLITE_OMIT_HEX_INTEGER */
852 return sqlite3Atoi64(z
, pOut
, sqlite3Strlen30(z
), SQLITE_UTF8
);
857 ** If zNum represents an integer that will fit in 32-bits, then set
858 ** *pValue to that integer and return true. Otherwise return false.
860 ** This routine accepts both decimal and hexadecimal notation for integers.
862 ** Any non-numeric characters that following zNum are ignored.
863 ** This is different from sqlite3Atoi64() which requires the
864 ** input number to be zero-terminated.
866 int sqlite3GetInt32(const char *zNum
, int *pValue
){
873 }else if( zNum
[0]=='+' ){
876 #ifndef SQLITE_OMIT_HEX_INTEGER
877 else if( zNum
[0]=='0'
878 && (zNum
[1]=='x' || zNum
[1]=='X')
879 && sqlite3Isxdigit(zNum
[2])
883 while( zNum
[0]=='0' ) zNum
++;
884 for(i
=0; i
<8 && sqlite3Isxdigit(zNum
[i
]); i
++){
885 u
= u
*16 + sqlite3HexToInt(zNum
[i
]);
887 if( (u
&0x80000000)==0 && sqlite3Isxdigit(zNum
[i
])==0 ){
888 memcpy(pValue
, &u
, 4);
895 if( !sqlite3Isdigit(zNum
[0]) ) return 0;
896 while( zNum
[0]=='0' ) zNum
++;
897 for(i
=0; i
<11 && (c
= zNum
[i
] - '0')>=0 && c
<=9; i
++){
901 /* The longest decimal representation of a 32 bit integer is 10 digits:
904 ** 2^31 -> 2147483648
910 testcase( v
-neg
==2147483647 );
911 if( v
-neg
>2147483647 ){
922 ** Return a 32-bit integer value extracted from a string. If the
923 ** string is not an integer, just return 0.
925 int sqlite3Atoi(const char *z
){
927 sqlite3GetInt32(z
, &x
);
932 ** Try to convert z into an unsigned 32-bit integer. Return true on
933 ** success and false if there is an error.
935 ** Only decimal notation is accepted.
937 int sqlite3GetUInt32(const char *z
, u32
*pI
){
940 for(i
=0; sqlite3Isdigit(z
[i
]); i
++){
941 v
= v
*10 + z
[i
] - '0';
942 if( v
>4294967296LL ){ *pI
= 0; return 0; }
944 if( i
==0 || z
[i
]!=0 ){ *pI
= 0; return 0; }
950 ** The variable-length integer encoding is as follows:
953 ** A = 0xxxxxxx 7 bits of data and one flag bit
954 ** B = 1xxxxxxx 7 bits of data and one flag bit
955 ** C = xxxxxxxx 8 bits of data
964 ** 56 bits - BBBBBBBA
965 ** 64 bits - BBBBBBBBC
969 ** Write a 64-bit variable-length integer to memory starting at p[0].
970 ** The length of data write will be between 1 and 9 bytes. The number
971 ** of bytes written is returned.
973 ** A variable-length integer consists of the lower 7 bits of each byte
974 ** for all bytes that have the 8th bit set and one byte with the 8th
975 ** bit clear. Except, if we get to the 9th byte, it stores the full
976 ** 8 bits and is the last byte.
978 static int SQLITE_NOINLINE
putVarint64(unsigned char *p
, u64 v
){
981 if( v
& (((u64
)0xff000000)<<32) ){
985 p
[i
] = (u8
)((v
& 0x7f) | 0x80);
992 buf
[n
++] = (u8
)((v
& 0x7f) | 0x80);
997 for(i
=0, j
=n
-1; j
>=0; j
--, i
++){
1002 int sqlite3PutVarint(unsigned char *p
, u64 v
){
1008 p
[0] = ((v
>>7)&0x7f)|0x80;
1012 return putVarint64(p
,v
);
1016 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
1017 ** are defined here rather than simply putting the constant expressions
1018 ** inline in order to work around bugs in the RVT compiler.
1020 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
1022 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
1024 #define SLOT_2_0 0x001fc07f
1025 #define SLOT_4_2_0 0xf01fc07f
1029 ** Read a 64-bit variable-length integer from memory starting at p[0].
1030 ** Return the number of bytes read. The value is stored in *v.
1032 u8
sqlite3GetVarint(const unsigned char *p
, u64
*v
){
1035 if( ((signed char*)p
)[0]>=0 ){
1039 if( ((signed char*)p
)[1]>=0 ){
1040 *v
= ((u32
)(p
[0]&0x7f)<<7) | p
[1];
1044 /* Verify that constants are precomputed correctly */
1045 assert( SLOT_2_0
== ((0x7f<<14) | (0x7f)) );
1046 assert( SLOT_4_2_0
== ((0xfU
<<28) | (0x7f<<14) | (0x7f)) );
1048 a
= ((u32
)p
[0])<<14;
1052 /* a: p0<<14 | p2 (unmasked) */
1063 /* CSE1 from below */
1068 /* b: p1<<14 | p3 (unmasked) */
1073 /* a &= (0x7f<<14)|(0x7f); */
1080 /* a: p0<<14 | p2 (masked) */
1081 /* b: p1<<14 | p3 (unmasked) */
1082 /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1084 /* a &= (0x7f<<14)|(0x7f); */
1087 /* s: p0<<14 | p2 (masked) */
1092 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1095 /* we can skip these cause they were (effectively) done above
1096 ** while calculating s */
1097 /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
1098 /* b &= (0x7f<<14)|(0x7f); */
1102 *v
= ((u64
)s
)<<32 | a
;
1106 /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1109 /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
1114 /* b: p1<<28 | p3<<14 | p5 (unmasked) */
1117 /* we can skip this cause it was (effectively) done above in calc'ing s */
1118 /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
1123 *v
= ((u64
)s
)<<32 | a
;
1130 /* a: p2<<28 | p4<<14 | p6 (unmasked) */
1138 *v
= ((u64
)s
)<<32 | a
;
1142 /* CSE2 from below */
1147 /* b: p3<<28 | p5<<14 | p7 (unmasked) */
1152 /* a &= (0x7f<<14)|(0x7f); */
1156 *v
= ((u64
)s
)<<32 | a
;
1163 /* a: p4<<29 | p6<<15 | p8 (unmasked) */
1166 /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
1177 *v
= ((u64
)s
)<<32 | a
;
1183 ** Read a 32-bit variable-length integer from memory starting at p[0].
1184 ** Return the number of bytes read. The value is stored in *v.
1186 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
1187 ** integer, then set *v to 0xffffffff.
1189 ** A MACRO version, getVarint32, is provided which inlines the
1190 ** single-byte case. All code should use the MACRO version as
1191 ** this function assumes the single-byte case has already been handled.
1193 u8
sqlite3GetVarint32(const unsigned char *p
, u32
*v
){
1196 /* The 1-byte case. Overwhelmingly the most common. Handled inline
1197 ** by the getVarin32() macro */
1199 /* a: p0 (unmasked) */
1203 /* Values between 0 and 127 */
1209 /* The 2-byte case */
1212 /* b: p1 (unmasked) */
1215 /* Values between 128 and 16383 */
1222 /* The 3-byte case */
1226 /* a: p0<<14 | p2 (unmasked) */
1229 /* Values between 16384 and 2097151 */
1230 a
&= (0x7f<<14)|(0x7f);
1237 /* A 32-bit varint is used to store size information in btrees.
1238 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
1239 ** A 3-byte varint is sufficient, for example, to record the size
1240 ** of a 1048569-byte BLOB or string.
1242 ** We only unroll the first 1-, 2-, and 3- byte cases. The very
1243 ** rare larger cases can be handled by the slower 64-bit varint
1251 n
= sqlite3GetVarint(p
-2, &v64
);
1252 assert( n
>3 && n
<=9 );
1253 if( (v64
& SQLITE_MAX_U32
)!=v64
){
1262 /* For following code (kept for historical record only) shows an
1263 ** unrolling for the 3- and 4-byte varint cases. This code is
1264 ** slightly faster, but it is also larger and much harder to test.
1269 /* b: p1<<14 | p3 (unmasked) */
1272 /* Values between 2097152 and 268435455 */
1273 b
&= (0x7f<<14)|(0x7f);
1274 a
&= (0x7f<<14)|(0x7f);
1283 /* a: p0<<28 | p2<<14 | p4 (unmasked) */
1286 /* Values between 268435456 and 34359738367 */
1294 /* We can only reach this point when reading a corrupt database
1295 ** file. In that case we are not in any hurry. Use the (relatively
1296 ** slow) general-purpose sqlite3GetVarint() routine to extract the
1303 n
= sqlite3GetVarint(p
, &v64
);
1304 assert( n
>5 && n
<=9 );
1312 ** Return the number of bytes that will be needed to store the given
1315 int sqlite3VarintLen(u64 v
){
1317 for(i
=1; (v
>>= 7)!=0; i
++){ assert( i
<10 ); }
1323 ** Read or write a four-byte big-endian integer value.
1325 u32
sqlite3Get4byte(const u8
*p
){
1326 #if SQLITE_BYTEORDER==4321
1330 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
1333 return __builtin_bswap32(x
);
1334 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
1337 return _byteswap_ulong(x
);
1339 testcase( p
[0]&0x80 );
1340 return ((unsigned)p
[0]<<24) | (p
[1]<<16) | (p
[2]<<8) | p
[3];
1343 void sqlite3Put4byte(unsigned char *p
, u32 v
){
1344 #if SQLITE_BYTEORDER==4321
1346 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
1347 u32 x
= __builtin_bswap32(v
);
1349 #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
1350 u32 x
= _byteswap_ulong(v
);
1363 ** Translate a single byte of Hex into an integer.
1364 ** This routine only works if h really is a valid hexadecimal
1365 ** character: 0..9a..fA..F
1367 u8
sqlite3HexToInt(int h
){
1368 assert( (h
>='0' && h
<='9') || (h
>='a' && h
<='f') || (h
>='A' && h
<='F') );
1372 #ifdef SQLITE_EBCDIC
1375 return (u8
)(h
& 0xf);
1378 /* BEGIN SQLCIPHER */
1379 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
1381 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1382 ** value. Return a pointer to its binary value. Space to hold the
1383 ** binary value has been obtained from malloc and must be freed by
1384 ** the calling routine.
1386 void *sqlite3HexToBlob(sqlite3
*db
, const char *z
, int n
){
1390 zBlob
= (char *)sqlite3DbMallocRawNN(db
, n
/2 + 1);
1393 for(i
=0; i
<n
; i
+=2){
1394 zBlob
[i
/2] = (sqlite3HexToInt(z
[i
])<<4) | sqlite3HexToInt(z
[i
+1]);
1400 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
1404 ** Log an error that is an API call on a connection pointer that should
1405 ** not have been used. The "type" of connection pointer is given as the
1406 ** argument. The zType is a word like "NULL" or "closed" or "invalid".
1408 static void logBadConnection(const char *zType
){
1409 sqlite3_log(SQLITE_MISUSE
,
1410 "API call with %s database connection pointer",
1416 ** Check to make sure we have a valid db pointer. This test is not
1417 ** foolproof but it does provide some measure of protection against
1418 ** misuse of the interface such as passing in db pointers that are
1419 ** NULL or which have been previously closed. If this routine returns
1420 ** 1 it means that the db pointer is valid and 0 if it should not be
1421 ** dereferenced for any reason. The calling function should invoke
1422 ** SQLITE_MISUSE immediately.
1424 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1425 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1426 ** open properly and is not fit for general use but which can be
1427 ** used as an argument to sqlite3_errmsg() or sqlite3_close().
1429 int sqlite3SafetyCheckOk(sqlite3
*db
){
1432 logBadConnection("NULL");
1435 eOpenState
= db
->eOpenState
;
1436 if( eOpenState
!=SQLITE_STATE_OPEN
){
1437 if( sqlite3SafetyCheckSickOrOk(db
) ){
1438 testcase( sqlite3GlobalConfig
.xLog
!=0 );
1439 logBadConnection("unopened");
1446 int sqlite3SafetyCheckSickOrOk(sqlite3
*db
){
1448 eOpenState
= db
->eOpenState
;
1449 if( eOpenState
!=SQLITE_STATE_SICK
&&
1450 eOpenState
!=SQLITE_STATE_OPEN
&&
1451 eOpenState
!=SQLITE_STATE_BUSY
){
1452 testcase( sqlite3GlobalConfig
.xLog
!=0 );
1453 logBadConnection("invalid");
1461 ** Attempt to add, substract, or multiply the 64-bit signed value iB against
1462 ** the other 64-bit signed integer at *pA and store the result in *pA.
1463 ** Return 0 on success. Or if the operation would have resulted in an
1464 ** overflow, leave *pA unchanged and return 1.
1466 int sqlite3AddInt64(i64
*pA
, i64 iB
){
1467 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1468 return __builtin_add_overflow(*pA
, iB
, pA
);
1471 testcase( iA
==0 ); testcase( iA
==1 );
1472 testcase( iB
==-1 ); testcase( iB
==0 );
1474 testcase( iA
>0 && LARGEST_INT64
- iA
== iB
);
1475 testcase( iA
>0 && LARGEST_INT64
- iA
== iB
- 1 );
1476 if( iA
>0 && LARGEST_INT64
- iA
< iB
) return 1;
1478 testcase( iA
<0 && -(iA
+ LARGEST_INT64
) == iB
+ 1 );
1479 testcase( iA
<0 && -(iA
+ LARGEST_INT64
) == iB
+ 2 );
1480 if( iA
<0 && -(iA
+ LARGEST_INT64
) > iB
+ 1 ) return 1;
1486 int sqlite3SubInt64(i64
*pA
, i64 iB
){
1487 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1488 return __builtin_sub_overflow(*pA
, iB
, pA
);
1490 testcase( iB
==SMALLEST_INT64
+1 );
1491 if( iB
==SMALLEST_INT64
){
1492 testcase( (*pA
)==(-1) ); testcase( (*pA
)==0 );
1493 if( (*pA
)>=0 ) return 1;
1497 return sqlite3AddInt64(pA
, -iB
);
1501 int sqlite3MulInt64(i64
*pA
, i64 iB
){
1502 #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
1503 return __builtin_mul_overflow(*pA
, iB
, pA
);
1507 if( iA
>LARGEST_INT64
/iB
) return 1;
1508 if( iA
<SMALLEST_INT64
/iB
) return 1;
1511 if( iB
<SMALLEST_INT64
/iA
) return 1;
1513 if( iB
==SMALLEST_INT64
) return 1;
1514 if( iA
==SMALLEST_INT64
) return 1;
1515 if( -iA
>LARGEST_INT64
/-iB
) return 1;
1524 ** Compute the absolute value of a 32-bit signed integer, of possible. Or
1525 ** if the integer has a value of -2147483648, return +2147483647
1527 int sqlite3AbsInt32(int x
){
1528 if( x
>=0 ) return x
;
1529 if( x
==(int)0x80000000 ) return 0x7fffffff;
1533 #ifdef SQLITE_ENABLE_8_3_NAMES
1535 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
1536 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1537 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1538 ** three characters, then shorten the suffix on z[] to be the last three
1539 ** characters of the original suffix.
1541 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1542 ** do the suffix shortening regardless of URI parameter.
1546 ** test.db-journal => test.nal
1547 ** test.db-wal => test.wal
1548 ** test.db-shm => test.shm
1549 ** test.db-mj7f3319fa => test.9fa
1551 void sqlite3FileSuffix3(const char *zBaseFilename
, char *z
){
1552 #if SQLITE_ENABLE_8_3_NAMES<2
1553 if( sqlite3_uri_boolean(zBaseFilename
, "8_3_names", 0) )
1557 sz
= sqlite3Strlen30(z
);
1558 for(i
=sz
-1; i
>0 && z
[i
]!='/' && z
[i
]!='.'; i
--){}
1559 if( z
[i
]=='.' && ALWAYS(sz
>i
+4) ) memmove(&z
[i
+1], &z
[sz
-3], 4);
1565 ** Find (an approximate) sum of two LogEst values. This computation is
1566 ** not a simple "+" operator because LogEst is stored as a logarithmic
1570 LogEst
sqlite3LogEstAdd(LogEst a
, LogEst b
){
1571 static const unsigned char x
[] = {
1575 7, 7, 7, /* 6,7,8 */
1576 6, 6, 6, /* 9,10,11 */
1577 5, 5, 5, /* 12-14 */
1578 4, 4, 4, 4, /* 15-18 */
1579 3, 3, 3, 3, 3, 3, /* 19-24 */
1580 2, 2, 2, 2, 2, 2, 2, /* 25-31 */
1583 if( a
>b
+49 ) return a
;
1584 if( a
>b
+31 ) return a
+1;
1587 if( b
>a
+49 ) return b
;
1588 if( b
>a
+31 ) return b
+1;
1594 ** Convert an integer into a LogEst. In other words, compute an
1595 ** approximation for 10*log2(x).
1597 LogEst
sqlite3LogEst(u64 x
){
1598 static LogEst a
[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
1602 while( x
<8 ){ y
-= 10; x
<<= 1; }
1604 #if GCC_VERSION>=5004000
1605 int i
= 60 - __builtin_clzll(x
);
1609 while( x
>255 ){ y
+= 40; x
>>= 4; } /*OPTIMIZATION-IF-TRUE*/
1610 while( x
>15 ){ y
+= 10; x
>>= 1; }
1613 return a
[x
&7] + y
- 10;
1617 ** Convert a double into a LogEst
1618 ** In other words, compute an approximation for 10*log2(x).
1620 LogEst
sqlite3LogEstFromDouble(double x
){
1623 assert( sizeof(x
)==8 && sizeof(a
)==8 );
1624 if( x
<=1 ) return 0;
1625 if( x
<=2000000000 ) return sqlite3LogEst((u64
)x
);
1632 ** Convert a LogEst into an integer.
1634 u64
sqlite3LogEstToInt(LogEst x
){
1639 else if( n
>=1 ) n
-= 1;
1640 if( x
>60 ) return (u64
)LARGEST_INT64
;
1641 return x
>=3 ? (n
+8)<<(x
-3) : (n
+8)>>(3-x
);
1645 ** Add a new name/number pair to a VList. This might require that the
1646 ** VList object be reallocated, so return the new VList. If an OOM
1647 ** error occurs, the original VList returned and the
1648 ** db->mallocFailed flag is set.
1650 ** A VList is really just an array of integers. To destroy a VList,
1651 ** simply pass it to sqlite3DbFree().
1653 ** The first integer is the number of integers allocated for the whole
1654 ** VList. The second integer is the number of integers actually used.
1655 ** Each name/number pair is encoded by subsequent groups of 3 or more
1658 ** Each name/number pair starts with two integers which are the numeric
1659 ** value for the pair and the size of the name/number pair, respectively.
1660 ** The text name overlays one or more following integers. The text name
1661 ** is always zero-terminated.
1666 ** int nAlloc; // Number of allocated slots
1667 ** int nUsed; // Number of used slots
1668 ** struct VListEntry {
1669 ** int iValue; // Value for this entry
1670 ** int nSlot; // Slots used by this entry
1671 ** // ... variable name goes here
1675 ** During code generation, pointers to the variable names within the
1676 ** VList are taken. When that happens, nAlloc is set to zero as an
1677 ** indication that the VList may never again be enlarged, since the
1678 ** accompanying realloc() would invalidate the pointers.
1680 VList
*sqlite3VListAdd(
1681 sqlite3
*db
, /* The database connection used for malloc() */
1682 VList
*pIn
, /* The input VList. Might be NULL */
1683 const char *zName
, /* Name of symbol to add */
1684 int nName
, /* Bytes of text in zName */
1685 int iVal
/* Value to associate with zName */
1687 int nInt
; /* number of sizeof(int) objects needed for zName */
1688 char *z
; /* Pointer to where zName will be stored */
1689 int i
; /* Index in pIn[] where zName is stored */
1692 assert( pIn
==0 || pIn
[0]>=3 ); /* Verify ok to add new elements */
1693 if( pIn
==0 || pIn
[1]+nInt
> pIn
[0] ){
1694 /* Enlarge the allocation */
1695 sqlite3_int64 nAlloc
= (pIn
? 2*(sqlite3_int64
)pIn
[0] : 10) + nInt
;
1696 VList
*pOut
= sqlite3DbRealloc(db
, pIn
, nAlloc
*sizeof(int));
1697 if( pOut
==0 ) return pIn
;
1698 if( pIn
==0 ) pOut
[1] = 2;
1705 z
= (char*)&pIn
[i
+2];
1707 assert( pIn
[1]<=pIn
[0] );
1708 memcpy(z
, zName
, nName
);
1714 ** Return a pointer to the name of a variable in the given VList that
1715 ** has the value iVal. Or return a NULL if there is no such variable in
1718 const char *sqlite3VListNumToName(VList
*pIn
, int iVal
){
1720 if( pIn
==0 ) return 0;
1724 if( pIn
[i
]==iVal
) return (char*)&pIn
[i
+2];
1731 ** Return the number of the variable named zName, if it is in VList.
1732 ** or return 0 if there is no such variable.
1734 int sqlite3VListNameToNum(VList
*pIn
, const char *zName
, int nName
){
1736 if( pIn
==0 ) return 0;
1740 const char *z
= (const char*)&pIn
[i
+2];
1741 if( strncmp(z
,zName
,nName
)==0 && z
[nName
]==0 ) return pIn
[i
];
1748 ** High-resolution hardware timer used for debugging and testing only.
1750 #if defined(VDBE_PROFILE) \
1751 || defined(SQLITE_PERFORMANCE_TRACE) \
1752 || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
1753 # include "hwtime.h"