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 ** Internal interface definitions for SQLite.
20 ** Some comments have special meaning to the tools that measure test
23 ** NO_TEST - The branches on this line are not
24 ** measured by branch coverage. This is
25 ** used on lines of code that actually
26 ** implement parts of coverage testing.
28 ** OPTIMIZATION-IF-TRUE - This branch is allowed to alway be false
29 ** and the correct answer is still obtained,
30 ** though perhaps more slowly.
32 ** OPTIMIZATION-IF-FALSE - This branch is allowed to alway be true
33 ** and the correct answer is still obtained,
34 ** though perhaps more slowly.
36 ** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread
37 ** that would be harmless and undetectable
40 ** In all cases, the special comment must be enclosed in the usual
41 ** slash-asterisk...asterisk-slash comment marks, with no spaces between the
42 ** asterisks and the comment text.
46 ** Make sure the Tcl calling convention macro is defined. This macro is
47 ** only used by test code and Tcl integration code.
50 # define SQLITE_TCLAPI
54 ** Include the header file used to customize the compiler options for MSVC.
55 ** This should be done first so that it can successfully prevent spurious
56 ** compiler warnings due to subsequent content in this file and other files
57 ** that are included by this file.
62 ** Special setup for VxWorks
67 ** These #defines should enable >2GB file support on POSIX if the
68 ** underlying operating system supports it. If the OS lacks
69 ** large file support, or if the OS is windows, these should be no-ops.
71 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
72 ** system #includes. Hence, this block of code must be the very first
73 ** code in all source files.
75 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
76 ** on the compiler command line. This is necessary if you are compiling
77 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
78 ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
79 ** without this option, LFS is enable. But LFS does not exist in the kernel
80 ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
81 ** portability you should omit LFS.
83 ** The previous paragraph was written in 2005. (This paragraph is written
84 ** on 2008-11-28.) These days, all Linux kernels support large files, so
85 ** you should probably leave LFS enabled. But some embedded platforms might
86 ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
88 ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
90 #ifndef SQLITE_DISABLE_LFS
91 # define _LARGE_FILE 1
92 # ifndef _FILE_OFFSET_BITS
93 # define _FILE_OFFSET_BITS 64
95 # define _LARGEFILE_SOURCE 1
98 /* The GCC_VERSION and MSVC_VERSION macros are used to
99 ** conditionally include optimizations for each of these compilers. A
100 ** value of 0 means that compiler is not being used. The
101 ** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
102 ** optimizations, and hence set all compiler macros to 0
104 ** There was once also a CLANG_VERSION macro. However, we learn that the
105 ** version numbers in clang are for "marketing" only and are inconsistent
106 ** and unreliable. Fortunately, all versions of clang also recognize the
107 ** gcc version numbers and have reasonable settings for gcc version numbers,
108 ** so the GCC_VERSION macro will be set to a correct non-zero value even
109 ** when compiling with clang.
111 #if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)
112 # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
114 # define GCC_VERSION 0
116 #if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
117 # define MSVC_VERSION _MSC_VER
119 # define MSVC_VERSION 0
122 /* Needed for various definitions... */
123 #if defined(__GNUC__) && !defined(_GNU_SOURCE)
127 #if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
132 ** For MinGW, check to see if we can include the header file containing its
133 ** version information, among other things. Normally, this internal MinGW
134 ** header file would [only] be included automatically by other MinGW header
135 ** files; however, the contained version information is now required by this
136 ** header file to work around binary compatibility issues (see below) and
137 ** this is the only known way to reliably obtain it. This entire #if block
138 ** would be completely unnecessary if there was any other way of detecting
139 ** MinGW via their preprocessor (e.g. if they customized their GCC to define
140 ** some MinGW-specific macros). When compiling for MinGW, either the
141 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
142 ** defined; otherwise, detection of conditions specific to MinGW will be
145 #if defined(_HAVE_MINGW_H)
147 #elif defined(_HAVE__MINGW_H)
152 ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
153 ** define is required to maintain binary compatibility with the MSVC runtime
154 ** library in use (e.g. for Windows XP).
156 #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
157 defined(_WIN32) && !defined(_WIN64) && \
158 defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
160 # define _USE_32BIT_TIME_T
163 /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
164 ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
170 ** Include the configuration header output by 'configure' if we're using the
171 ** autoconf-based build
173 #if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
175 #define SQLITECONFIG_H 1
178 #include "sqliteLimit.h"
180 /* Disable nuisance warnings on Borland compilers */
181 #if defined(__BORLANDC__)
182 #pragma warn -rch /* unreachable code */
183 #pragma warn -ccc /* Condition is always true or false */
184 #pragma warn -aus /* Assigned value is never used */
185 #pragma warn -csu /* Comparing signed and unsigned */
186 #pragma warn -spa /* Suspicious pointer arithmetic */
190 ** Include standard header files as necessary
195 #ifdef HAVE_INTTYPES_H
196 #include <inttypes.h>
200 ** The following macros are used to cast pointers to integers and
201 ** integers to pointers. The way you do this varies from one compiler
202 ** to the next, so we have developed the following set of #if statements
203 ** to generate appropriate macros for a wide range of compilers.
205 ** The correct "ANSI" way to do this is to use the intptr_t type.
206 ** Unfortunately, that typedef is not available on all compilers, or
207 ** if it is available, it requires an #include of specific headers
208 ** that vary from one machine to the next.
210 ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
211 ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
212 ** So we have to define the macros in different ways depending on the
215 #if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
216 # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
217 # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
218 #elif !defined(__GNUC__) /* Works for compilers other than LLVM */
219 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
220 # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
221 #elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
222 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
223 # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
224 #else /* Generates a warning - but it always works */
225 # define SQLITE_INT_TO_PTR(X) ((void*)(X))
226 # define SQLITE_PTR_TO_INT(X) ((int)(X))
230 ** A macro to hint to the compiler that a function should not be
233 #if defined(__GNUC__)
234 # define SQLITE_NOINLINE __attribute__((noinline))
235 #elif defined(_MSC_VER) && _MSC_VER>=1310
236 # define SQLITE_NOINLINE __declspec(noinline)
238 # define SQLITE_NOINLINE
242 ** Make sure that the compiler intrinsics we desire are enabled when
243 ** compiling with an appropriate version of MSVC unless prevented by
244 ** the SQLITE_DISABLE_INTRINSIC define.
246 #if !defined(SQLITE_DISABLE_INTRINSIC)
247 # if defined(_MSC_VER) && _MSC_VER>=1400
248 # if !defined(_WIN32_WCE)
250 # pragma intrinsic(_byteswap_ushort)
251 # pragma intrinsic(_byteswap_ulong)
252 # pragma intrinsic(_byteswap_uint64)
253 # pragma intrinsic(_ReadWriteBarrier)
255 # include <cmnintrin.h>
261 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
262 ** 0 means mutexes are permanently disable and the library is never
263 ** threadsafe. 1 means the library is serialized which is the highest
264 ** level of threadsafety. 2 means the library is multithreaded - multiple
265 ** threads can use SQLite as long as no two threads try to use the same
266 ** database connection at the same time.
268 ** Older versions of SQLite used an optional THREADSAFE macro.
269 ** We support that for legacy.
271 ** To ensure that the correct value of "THREADSAFE" is reported when querying
272 ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
273 ** logic is partially replicated in ctime.c. If it is updated here, it should
274 ** also be updated there.
276 #if !defined(SQLITE_THREADSAFE)
277 # if defined(THREADSAFE)
278 # define SQLITE_THREADSAFE THREADSAFE
280 # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
285 ** Powersafe overwrite is on by default. But can be turned off using
286 ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
288 #ifndef SQLITE_POWERSAFE_OVERWRITE
289 # define SQLITE_POWERSAFE_OVERWRITE 1
293 ** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
294 ** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in
295 ** which case memory allocation statistics are disabled by default.
297 #if !defined(SQLITE_DEFAULT_MEMSTATUS)
298 # define SQLITE_DEFAULT_MEMSTATUS 1
302 ** Exactly one of the following macros must be defined in order to
303 ** specify which memory allocation subsystem to use.
305 ** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
306 ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
307 ** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails
308 ** SQLITE_MEMDEBUG // Debugging version of system malloc()
310 ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
311 ** assert() macro is enabled, each call into the Win32 native heap subsystem
312 ** will cause HeapValidate to be called. If heap validation should fail, an
313 ** assertion will be triggered.
315 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
318 #if defined(SQLITE_SYSTEM_MALLOC) \
319 + defined(SQLITE_WIN32_MALLOC) \
320 + defined(SQLITE_ZERO_MALLOC) \
321 + defined(SQLITE_MEMDEBUG)>1
322 # error "Two or more of the following compile-time configuration options\
323 are defined but at most one is allowed:\
324 SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\
327 #if defined(SQLITE_SYSTEM_MALLOC) \
328 + defined(SQLITE_WIN32_MALLOC) \
329 + defined(SQLITE_ZERO_MALLOC) \
330 + defined(SQLITE_MEMDEBUG)==0
331 # define SQLITE_SYSTEM_MALLOC 1
335 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
336 ** sizes of memory allocations below this value where possible.
338 #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
339 # define SQLITE_MALLOC_SOFT_LIMIT 1024
343 ** We need to define _XOPEN_SOURCE as follows in order to enable
344 ** recursive mutexes on most Unix systems and fchmod() on OpenBSD.
345 ** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
348 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
349 # define _XOPEN_SOURCE 600
353 ** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that
354 ** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,
355 ** make it true by defining or undefining NDEBUG.
357 ** Setting NDEBUG makes the code smaller and faster by disabling the
358 ** assert() statements in the code. So we want the default action
359 ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
360 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
363 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
366 #if defined(NDEBUG) && defined(SQLITE_DEBUG)
371 ** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
373 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
374 # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
378 ** The testcase() macro is used to aid in coverage testing. When
379 ** doing coverage testing, the condition inside the argument to
380 ** testcase() must be evaluated both true and false in order to
381 ** get full branch coverage. The testcase() macro is inserted
382 ** to help ensure adequate test coverage in places where simple
383 ** condition/decision coverage is inadequate. For example, testcase()
384 ** can be used to make sure boundary values are tested. For
385 ** bitmask tests, testcase() can be used to make sure each bit
386 ** is significant and used at least once. On switch statements
387 ** where multiple cases go to the same block of code, testcase()
388 ** can insure that all cases are evaluated.
391 #ifdef SQLITE_COVERAGE_TEST
392 void sqlite3Coverage(int);
393 # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
399 ** The TESTONLY macro is used to enclose variable declarations or
400 ** other bits of code that are needed to support the arguments
401 ** within testcase() and assert() macros.
403 #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
404 # define TESTONLY(X) X
410 ** Sometimes we need a small amount of code such as a variable initialization
411 ** to setup for a later assert() statement. We do not want this code to
412 ** appear when assert() is disabled. The following macro is therefore
413 ** used to contain that setup code. The "VVA" acronym stands for
414 ** "Verification, Validation, and Accreditation". In other words, the
415 ** code within VVA_ONLY() will only run during verification processes.
418 # define VVA_ONLY(X) X
424 ** The ALWAYS and NEVER macros surround boolean expressions which
425 ** are intended to always be true or false, respectively. Such
426 ** expressions could be omitted from the code completely. But they
427 ** are included in a few cases in order to enhance the resilience
428 ** of SQLite to unexpected behavior - to make the code "self-healing"
429 ** or "ductile" rather than being "brittle" and crashing at the first
430 ** hint of unplanned behavior.
432 ** In other words, ALWAYS and NEVER are added for defensive code.
434 ** When doing coverage testing ALWAYS and NEVER are hard-coded to
435 ** be true and false so that the unreachable code they specify will
436 ** not be counted as untested code.
438 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
439 # define ALWAYS(X) (1)
440 # define NEVER(X) (0)
441 #elif !defined(NDEBUG)
442 # define ALWAYS(X) ((X)?1:(assert(0),0))
443 # define NEVER(X) ((X)?(assert(0),1):0)
445 # define ALWAYS(X) (X)
446 # define NEVER(X) (X)
450 ** Some conditionals are optimizations only. In other words, if the
451 ** conditionals are replaced with a constant 1 (true) or 0 (false) then
452 ** the correct answer is still obtained, though perhaps not as quickly.
454 ** The following macros mark these optimizations conditionals.
456 #if defined(SQLITE_MUTATION_TEST)
457 # define OK_IF_ALWAYS_TRUE(X) (1)
458 # define OK_IF_ALWAYS_FALSE(X) (0)
460 # define OK_IF_ALWAYS_TRUE(X) (X)
461 # define OK_IF_ALWAYS_FALSE(X) (X)
465 ** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
466 ** defined. We need to defend against those failures when testing with
467 ** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
468 ** during a normal build. The following macro can be used to disable tests
469 ** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
471 #if defined(SQLITE_TEST_REALLOC_STRESS)
472 # define ONLY_IF_REALLOC_STRESS(X) (X)
473 #elif !defined(NDEBUG)
474 # define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)
476 # define ONLY_IF_REALLOC_STRESS(X) (0)
480 ** Declarations used for tracing the operating system interfaces.
482 #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \
483 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
484 extern int sqlite3OSTrace
;
485 # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
486 # define SQLITE_HAVE_OS_TRACE
489 # undef SQLITE_HAVE_OS_TRACE
493 ** Is the sqlite3ErrName() function needed in the build? Currently,
494 ** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when
495 ** OSTRACE is enabled), and by several "test*.c" files (which are
496 ** compiled using SQLITE_TEST).
498 #if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \
499 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
500 # define SQLITE_NEED_ERR_NAME
502 # undef SQLITE_NEED_ERR_NAME
506 ** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN
508 #ifdef SQLITE_OMIT_EXPLAIN
509 # undef SQLITE_ENABLE_EXPLAIN_COMMENTS
513 ** Return true (non-zero) if the input is an integer that is too large
514 ** to fit in 32-bits. This macro is used inside of various testcase()
515 ** macros to verify that we have tested SQLite for large-file support.
517 #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
520 ** The macro unlikely() is a hint that surrounds a boolean
521 ** expression that is usually false. Macro likely() surrounds
522 ** a boolean expression that is usually true. These hints could,
523 ** in theory, be used by the compiler to generate better code, but
524 ** currently they are just comments for human readers.
526 #define likely(X) (X)
527 #define unlikely(X) (X)
538 ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
539 ** This allows better measurements of where memcpy() is used when running
540 ** cachegrind. But this macro version of memcpy() is very slow so it
541 ** should not be used in production. This is a performance measurement
544 #ifdef SQLITE_INLINE_MEMCPY
545 # define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
546 int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
550 ** If compiling for a processor that lacks floating point support,
551 ** substitute integer for floating-point
553 #ifdef SQLITE_OMIT_FLOATING_POINT
554 # define double sqlite_int64
555 # define float sqlite_int64
556 # define LONGDOUBLE_TYPE sqlite_int64
557 # ifndef SQLITE_BIG_DBL
558 # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
560 # define SQLITE_OMIT_DATETIME_FUNCS 1
561 # define SQLITE_OMIT_TRACE 1
562 # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
563 # undef SQLITE_HAVE_ISNAN
565 #ifndef SQLITE_BIG_DBL
566 # define SQLITE_BIG_DBL (1e99)
570 ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
571 ** afterward. Having this macro allows us to cause the C compiler
572 ** to omit code used by TEMP tables without messy #ifndef statements.
574 #ifdef SQLITE_OMIT_TEMPDB
575 #define OMIT_TEMPDB 1
577 #define OMIT_TEMPDB 0
581 ** The "file format" number is an integer that is incremented whenever
582 ** the VDBE-level file format changes. The following macros define the
583 ** the default file format for new databases and the maximum file format
584 ** that the library can read.
586 #define SQLITE_MAX_FILE_FORMAT 4
587 #ifndef SQLITE_DEFAULT_FILE_FORMAT
588 # define SQLITE_DEFAULT_FILE_FORMAT 4
592 ** Determine whether triggers are recursive by default. This can be
593 ** changed at run-time using a pragma.
595 #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
596 # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
600 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
601 ** on the command-line
603 #ifndef SQLITE_TEMP_STORE
604 # define SQLITE_TEMP_STORE 1
608 ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
609 ** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
612 #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
613 # undef SQLITE_MAX_WORKER_THREADS
614 # define SQLITE_MAX_WORKER_THREADS 0
616 #ifndef SQLITE_MAX_WORKER_THREADS
617 # define SQLITE_MAX_WORKER_THREADS 8
619 #ifndef SQLITE_DEFAULT_WORKER_THREADS
620 # define SQLITE_DEFAULT_WORKER_THREADS 0
622 #if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS
623 # undef SQLITE_MAX_WORKER_THREADS
624 # define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS
628 ** The default initial allocation for the pagecache when using separate
629 ** pagecaches for each database connection. A positive number is the
630 ** number of pages. A negative number N translations means that a buffer
631 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
633 ** The default value of "20" was choosen to minimize the run-time of the
634 ** speedtest1 test program with options: --shrink-memory --reprepare
636 #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
637 # define SQLITE_DEFAULT_PCACHE_INITSZ 20
641 ** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.
643 #ifndef SQLITE_DEFAULT_SORTERREF_SIZE
644 # define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff
648 ** The compile-time options SQLITE_MMAP_READWRITE and
649 ** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.
650 ** You must choose one or the other (or neither) but not both.
652 #if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
653 #error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE
657 ** GCC does not define the offsetof() macro so we'll have to do it
661 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
665 ** Macros to compute minimum and maximum of two numbers.
668 # define MIN(A,B) ((A)<(B)?(A):(B))
671 # define MAX(A,B) ((A)>(B)?(A):(B))
675 ** Swap two objects of type TYPE.
677 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
680 ** Check to see if this machine uses EBCDIC. (Yes, believe it or
681 ** not, there are still machines out there that use EBCDIC.)
684 # define SQLITE_EBCDIC 1
686 # define SQLITE_ASCII 1
690 ** Integers of known sizes. These typedefs might change for architectures
691 ** where the sizes very. Preprocessor macros are available so that the
692 ** types can be conveniently redefined at compile-type. Like this:
694 ** cc '-DUINTPTR_TYPE=long long int' ...
697 # ifdef HAVE_UINT32_T
698 # define UINT32_TYPE uint32_t
700 # define UINT32_TYPE unsigned int
704 # ifdef HAVE_UINT16_T
705 # define UINT16_TYPE uint16_t
707 # define UINT16_TYPE unsigned short int
712 # define INT16_TYPE int16_t
714 # define INT16_TYPE short int
719 # define UINT8_TYPE uint8_t
721 # define UINT8_TYPE unsigned char
726 # define INT8_TYPE int8_t
728 # define INT8_TYPE signed char
731 #ifndef LONGDOUBLE_TYPE
732 # define LONGDOUBLE_TYPE long double
734 typedef sqlite_int64 i64
; /* 8-byte signed integer */
735 typedef sqlite_uint64 u64
; /* 8-byte unsigned integer */
736 typedef UINT32_TYPE u32
; /* 4-byte unsigned integer */
737 typedef UINT16_TYPE u16
; /* 2-byte unsigned integer */
738 typedef INT16_TYPE i16
; /* 2-byte signed integer */
739 typedef UINT8_TYPE u8
; /* 1-byte unsigned integer */
740 typedef INT8_TYPE i8
; /* 1-byte signed integer */
743 ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
744 ** that can be stored in a u32 without loss of data. The value
745 ** is 0x00000000ffffffff. But because of quirks of some compilers, we
746 ** have to specify the value in the less intuitive manner shown:
748 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
751 ** The datatype used to store estimates of the number of rows in a
752 ** table or index. This is an unsigned integer type. For 99.9% of
753 ** the world, a 32-bit integer is sufficient. But a 64-bit integer
754 ** can be used at compile-time if desired.
756 #ifdef SQLITE_64BIT_STATS
757 typedef u64 tRowcnt
; /* 64-bit only if requested at compile-time */
759 typedef u32 tRowcnt
; /* 32-bit is the default */
763 ** Estimated quantities used for query planning are stored as 16-bit
764 ** logarithms. For quantity X, the value stored is 10*log2(X). This
765 ** gives a possible range of values of approximately 1.0e986 to 1e-986.
766 ** But the allowed values are "grainy". Not every value is representable.
767 ** For example, quantities 16 and 17 are both represented by a LogEst
768 ** of 40. However, since LogEst quantities are suppose to be estimates,
769 ** not exact values, this imprecision is not a problem.
771 ** "LogEst" is short for "Logarithmic Estimate".
774 ** 1 -> 0 20 -> 43 10000 -> 132
775 ** 2 -> 10 25 -> 46 25000 -> 146
776 ** 3 -> 16 100 -> 66 1000000 -> 199
777 ** 4 -> 20 1000 -> 99 1048576 -> 200
778 ** 10 -> 33 1024 -> 100 4294967296 -> 320
780 ** The LogEst can be negative to indicate fractional values.
783 ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
785 typedef INT16_TYPE LogEst
;
788 ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
790 #ifndef SQLITE_PTRSIZE
791 # if defined(__SIZEOF_POINTER__)
792 # define SQLITE_PTRSIZE __SIZEOF_POINTER__
793 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
794 defined(_M_ARM) || defined(__arm__) || defined(__x86)
795 # define SQLITE_PTRSIZE 4
797 # define SQLITE_PTRSIZE 8
801 /* The uptr type is an unsigned integer large enough to hold a pointer
803 #if defined(HAVE_STDINT_H)
804 typedef uintptr_t uptr
;
805 #elif SQLITE_PTRSIZE==4
812 ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
813 ** something between S (inclusive) and E (exclusive).
815 ** In other words, S is a buffer and E is a pointer to the first byte after
816 ** the end of buffer S. This macro returns true if P points to something
817 ** contained within the buffer S.
819 #define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
823 ** Macros to determine whether the machine is big or little endian,
824 ** and whether or not that determination is run-time or compile-time.
826 ** For best performance, an attempt is made to guess at the byte-order
827 ** using C-preprocessor macros. If that is unsuccessful, or if
828 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
831 #ifndef SQLITE_BYTEORDER
832 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
833 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
834 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
836 # define SQLITE_BYTEORDER 1234
837 # elif defined(sparc) || defined(__ppc__)
838 # define SQLITE_BYTEORDER 4321
840 # define SQLITE_BYTEORDER 0
843 #if SQLITE_BYTEORDER==4321
844 # define SQLITE_BIGENDIAN 1
845 # define SQLITE_LITTLEENDIAN 0
846 # define SQLITE_UTF16NATIVE SQLITE_UTF16BE
847 #elif SQLITE_BYTEORDER==1234
848 # define SQLITE_BIGENDIAN 0
849 # define SQLITE_LITTLEENDIAN 1
850 # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
852 # ifdef SQLITE_AMALGAMATION
853 const int sqlite3one
= 1;
855 extern const int sqlite3one
;
857 # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
858 # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
859 # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
863 ** Constants for the largest and smallest possible 64-bit signed integers.
864 ** These macros are designed to work correctly on both 32-bit and 64-bit
867 #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
868 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
871 ** Round up a number to the next larger multiple of 8. This is used
872 ** to force 8-byte alignment on 64-bit architectures.
874 #define ROUND8(x) (((x)+7)&~7)
877 ** Round down to the nearest multiple of 8
879 #define ROUNDDOWN8(x) ((x)&~7)
882 ** Assert that the pointer X is aligned to an 8-byte boundary. This
883 ** macro is used only within assert() to verify that the code gets
884 ** all alignment restrictions correct.
886 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
887 ** underlying malloc() implementation might return us 4-byte aligned
888 ** pointers. In that case, only verify 4-byte alignment.
890 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
891 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
893 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
897 ** Disable MMAP on platforms where it is known to not work
899 #if defined(__OpenBSD__) || defined(__QNXNTO__)
900 # undef SQLITE_MAX_MMAP_SIZE
901 # define SQLITE_MAX_MMAP_SIZE 0
905 ** Default maximum size of memory used by memory-mapped I/O in the VFS
908 # include <TargetConditionals.h>
910 #ifndef SQLITE_MAX_MMAP_SIZE
911 # if defined(__linux__) \
913 || (defined(__APPLE__) && defined(__MACH__)) \
915 || defined(__FreeBSD__) \
916 || defined(__DragonFly__)
917 # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */
919 # define SQLITE_MAX_MMAP_SIZE 0
924 ** The default MMAP_SIZE is zero on all platforms. Or, even if a larger
925 ** default MMAP_SIZE is specified at compile-time, make sure that it does
926 ** not exceed the maximum mmap size.
928 #ifndef SQLITE_DEFAULT_MMAP_SIZE
929 # define SQLITE_DEFAULT_MMAP_SIZE 0
931 #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
932 # undef SQLITE_DEFAULT_MMAP_SIZE
933 # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
937 ** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.
938 ** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also
939 ** define SQLITE_ENABLE_STAT3_OR_STAT4
941 #ifdef SQLITE_ENABLE_STAT4
942 # undef SQLITE_ENABLE_STAT3
943 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
944 #elif SQLITE_ENABLE_STAT3
945 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
946 #elif SQLITE_ENABLE_STAT3_OR_STAT4
947 # undef SQLITE_ENABLE_STAT3_OR_STAT4
951 ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
952 ** the Select query generator tracing logic is turned on.
954 #if defined(SQLITE_ENABLE_SELECTTRACE)
955 # define SELECTTRACE_ENABLED 1
957 # define SELECTTRACE_ENABLED 0
961 ** An instance of the following structure is used to store the busy-handler
962 ** callback for a given sqlite handle.
964 ** The sqlite.busyHandler member of the sqlite struct contains the busy
965 ** callback for the database handle. Each pager opened via the sqlite
966 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
967 ** callback is currently invoked only from within pager.c.
969 typedef struct BusyHandler BusyHandler
;
971 int (*xBusyHandler
)(void *,int); /* The busy callback */
972 void *pBusyArg
; /* First arg to busy callback */
973 int nBusy
; /* Incremented with each busy call */
974 u8 bExtraFileArg
; /* Include sqlite3_file as callback arg */
978 ** Name of the master database table. The master database table
979 ** is a special table that holds the names and attributes of all
980 ** user tables and indices.
982 #define MASTER_NAME "sqlite_master"
983 #define TEMP_MASTER_NAME "sqlite_temp_master"
986 ** The root-page of the master database table.
988 #define MASTER_ROOT 1
991 ** The name of the schema table.
993 #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
996 ** A convenience macro that returns the number of elements in
999 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
1002 ** Determine if the argument is a power of two
1004 #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
1007 ** The following value as a destructor means to use sqlite3DbFree().
1008 ** The sqlite3DbFree() routine requires two parameters instead of the
1009 ** one parameter that destructors normally want. So we have to introduce
1010 ** this magic value that the code knows to handle differently. Any
1011 ** pointer will work here as long as it is distinct from SQLITE_STATIC
1012 ** and SQLITE_TRANSIENT.
1014 #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)
1017 ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
1018 ** not support Writable Static Data (WSD) such as global and static variables.
1019 ** All variables must either be on the stack or dynamically allocated from
1020 ** the heap. When WSD is unsupported, the variable declarations scattered
1021 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
1022 ** macro is used for this purpose. And instead of referencing the variable
1023 ** directly, we use its constant as a key to lookup the run-time allocated
1024 ** buffer that holds real variable. The constant is also the initializer
1025 ** for the run-time allocated buffer.
1027 ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
1028 ** macros become no-ops and have zero performance impact.
1030 #ifdef SQLITE_OMIT_WSD
1031 #define SQLITE_WSD const
1032 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
1033 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
1034 int sqlite3_wsd_init(int N
, int J
);
1035 void *sqlite3_wsd_find(void *K
, int L
);
1038 #define GLOBAL(t,v) v
1039 #define sqlite3GlobalConfig sqlite3Config
1043 ** The following macros are used to suppress compiler warnings and to
1044 ** make it clear to human readers when a function parameter is deliberately
1045 ** left unused within the body of a function. This usually happens when
1046 ** a function is called via a function pointer. For example the
1047 ** implementation of an SQL aggregate step callback may not use the
1048 ** parameter indicating the number of arguments passed to the aggregate,
1049 ** if it knows that this is enforced elsewhere.
1051 ** When a function parameter is not used at all within the body of a function,
1052 ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
1053 ** However, these macros may also be used to suppress warnings related to
1054 ** parameters that may or may not be used depending on compilation options.
1055 ** For example those parameters only used in assert() statements. In these
1056 ** cases the parameters are named as per the usual conventions.
1058 #define UNUSED_PARAMETER(x) (void)(x)
1059 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
1062 ** Forward references to structures
1064 typedef struct AggInfo AggInfo
;
1065 typedef struct AuthContext AuthContext
;
1066 typedef struct AutoincInfo AutoincInfo
;
1067 typedef struct Bitvec Bitvec
;
1068 typedef struct CollSeq CollSeq
;
1069 typedef struct Column Column
;
1070 typedef struct Db Db
;
1071 typedef struct Schema Schema
;
1072 typedef struct Expr Expr
;
1073 typedef struct ExprList ExprList
;
1074 typedef struct FKey FKey
;
1075 typedef struct FuncDestructor FuncDestructor
;
1076 typedef struct FuncDef FuncDef
;
1077 typedef struct FuncDefHash FuncDefHash
;
1078 typedef struct IdList IdList
;
1079 typedef struct Index Index
;
1080 typedef struct IndexSample IndexSample
;
1081 typedef struct KeyClass KeyClass
;
1082 typedef struct KeyInfo KeyInfo
;
1083 typedef struct Lookaside Lookaside
;
1084 typedef struct LookasideSlot LookasideSlot
;
1085 typedef struct Module Module
;
1086 typedef struct NameContext NameContext
;
1087 typedef struct Parse Parse
;
1088 typedef struct PreUpdate PreUpdate
;
1089 typedef struct PrintfArguments PrintfArguments
;
1090 typedef struct RowSet RowSet
;
1091 typedef struct Savepoint Savepoint
;
1092 typedef struct Select Select
;
1093 typedef struct SQLiteThread SQLiteThread
;
1094 typedef struct SelectDest SelectDest
;
1095 typedef struct SrcList SrcList
;
1096 typedef struct StrAccum StrAccum
;
1097 typedef struct Table Table
;
1098 typedef struct TableLock TableLock
;
1099 typedef struct Token Token
;
1100 typedef struct TreeView TreeView
;
1101 typedef struct Trigger Trigger
;
1102 typedef struct TriggerPrg TriggerPrg
;
1103 typedef struct TriggerStep TriggerStep
;
1104 typedef struct UnpackedRecord UnpackedRecord
;
1105 typedef struct Upsert Upsert
;
1106 typedef struct VTable VTable
;
1107 typedef struct VtabCtx VtabCtx
;
1108 typedef struct Walker Walker
;
1109 typedef struct WhereInfo WhereInfo
;
1110 typedef struct With With
;
1112 /* A VList object records a mapping between parameters/variables/wildcards
1113 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
1114 ** variable number associated with that parameter. See the format description
1115 ** on the sqlite3VListAdd() routine for more information. A VList is really
1116 ** just an array of integers.
1121 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
1122 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
1123 ** pointer types (i.e. FuncDef) defined above.
1132 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
1133 ** synchronous setting to EXTRA. It is no longer supported.
1135 #ifdef SQLITE_EXTRA_DURABLE
1136 # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
1137 # define SQLITE_DEFAULT_SYNCHRONOUS 3
1141 ** Default synchronous levels.
1143 ** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ
1144 ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
1146 ** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS
1152 ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
1153 ** In other words, the zero-based numbers are used for all external interfaces
1154 ** and the one-based values are used internally.
1156 #ifndef SQLITE_DEFAULT_SYNCHRONOUS
1157 # define SQLITE_DEFAULT_SYNCHRONOUS 2
1159 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
1160 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
1164 ** Each database file to be accessed by the system is an instance
1165 ** of the following structure. There are normally two of these structures
1166 ** in the sqlite.aDb[] array. aDb[0] is the main database file and
1167 ** aDb[1] is the database file used to hold temporary tables. Additional
1168 ** databases may be attached.
1171 char *zDbSName
; /* Name of this database. (schema name, not filename) */
1172 Btree
*pBt
; /* The B*Tree structure for this database file */
1173 u8 safety_level
; /* How aggressive at syncing data to disk */
1174 u8 bSyncSet
; /* True if "PRAGMA synchronous=N" has been run */
1175 Schema
*pSchema
; /* Pointer to database schema (possibly shared) */
1179 ** An instance of the following structure stores a database schema.
1181 ** Most Schema objects are associated with a Btree. The exception is
1182 ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
1183 ** In shared cache mode, a single Schema object can be shared by multiple
1184 ** Btrees that refer to the same underlying BtShared object.
1186 ** Schema objects are automatically deallocated when the last Btree that
1187 ** references them is destroyed. The TEMP Schema is manually freed by
1190 ** A thread must be holding a mutex on the corresponding Btree in order
1191 ** to access Schema content. This implies that the thread must also be
1192 ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
1193 ** For a TEMP Schema, only the connection mutex is required.
1196 int schema_cookie
; /* Database schema version number for this file */
1197 int iGeneration
; /* Generation counter. Incremented with each change */
1198 Hash tblHash
; /* All tables indexed by name */
1199 Hash idxHash
; /* All (named) indices indexed by name */
1200 Hash trigHash
; /* All triggers indexed by name */
1201 Hash fkeyHash
; /* All foreign keys by referenced table name */
1202 Table
*pSeqTab
; /* The sqlite_sequence table used by AUTOINCREMENT */
1203 u8 file_format
; /* Schema format version for this file */
1204 u8 enc
; /* Text encoding used by this database */
1205 u16 schemaFlags
; /* Flags associated with this schema */
1206 int cache_size
; /* Number of pages to use in the cache */
1210 ** These macros can be used to test, set, or clear bits in the
1211 ** Db.pSchema->flags field.
1213 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
1214 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
1215 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
1216 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
1219 ** Allowed values for the DB.pSchema->flags field.
1221 ** The DB_SchemaLoaded flag is set after the database schema has been
1222 ** read into internal hash tables.
1224 ** DB_UnresetViews means that one or more views have column names that
1225 ** have been filled out. If the schema changes, these column names might
1226 ** changes and so the view will need to be reset.
1228 #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
1229 #define DB_UnresetViews 0x0002 /* Some views have defined column names */
1230 #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
1231 #define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */
1234 ** The number of different kinds of things that can be limited
1235 ** using the sqlite3_limit() interface.
1237 #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
1240 ** Lookaside malloc is a set of fixed-size buffers that can be used
1241 ** to satisfy small transient memory allocation requests for objects
1242 ** associated with a particular database connection. The use of
1243 ** lookaside malloc provides a significant performance enhancement
1244 ** (approx 10%) by avoiding numerous malloc/free requests while parsing
1247 ** The Lookaside structure holds configuration information about the
1248 ** lookaside malloc subsystem. Each available memory allocation in
1249 ** the lookaside subsystem is stored on a linked list of LookasideSlot
1252 ** Lookaside allocations are only allowed for objects that are associated
1253 ** with a particular database connection. Hence, schema information cannot
1254 ** be stored in lookaside because in shared cache mode the schema information
1255 ** is shared by multiple database connections. Therefore, while parsing
1256 ** schema information, the Lookaside.bEnabled flag is cleared so that
1257 ** lookaside allocations are not used to construct the schema objects.
1260 u32 bDisable
; /* Only operate the lookaside when zero */
1261 u16 sz
; /* Size of each buffer in bytes */
1262 u8 bMalloced
; /* True if pStart obtained from sqlite3_malloc() */
1263 u32 nSlot
; /* Number of lookaside slots allocated */
1264 u32 anStat
[3]; /* 0: hits. 1: size misses. 2: full misses */
1265 LookasideSlot
*pInit
; /* List of buffers not previously used */
1266 LookasideSlot
*pFree
; /* List of available buffers */
1267 void *pStart
; /* First byte of available memory space */
1268 void *pEnd
; /* First byte past end of available space */
1270 struct LookasideSlot
{
1271 LookasideSlot
*pNext
; /* Next buffer in the list of free buffers */
1275 ** A hash table for built-in function definitions. (Application-defined
1276 ** functions use a regular table table from hash.h.)
1278 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
1279 ** Collisions are on the FuncDef.u.pHash chain.
1281 #define SQLITE_FUNC_HASH_SZ 23
1282 struct FuncDefHash
{
1283 FuncDef
*a
[SQLITE_FUNC_HASH_SZ
]; /* Hash table for functions */
1286 #ifdef SQLITE_USER_AUTHENTICATION
1288 ** Information held in the "sqlite3" database connection object and used
1289 ** to manage user authentication.
1291 typedef struct sqlite3_userauth sqlite3_userauth
;
1292 struct sqlite3_userauth
{
1293 u8 authLevel
; /* Current authentication level */
1294 int nAuthPW
; /* Size of the zAuthPW in bytes */
1295 char *zAuthPW
; /* Password used to authenticate */
1296 char *zAuthUser
; /* User name used to authenticate */
1299 /* Allowed values for sqlite3_userauth.authLevel */
1300 #define UAUTH_Unknown 0 /* Authentication not yet checked */
1301 #define UAUTH_Fail 1 /* User authentication failed */
1302 #define UAUTH_User 2 /* Authenticated as a normal user */
1303 #define UAUTH_Admin 3 /* Authenticated as an administrator */
1305 /* Functions used only by user authorization logic */
1306 int sqlite3UserAuthTable(const char*);
1307 int sqlite3UserAuthCheckLogin(sqlite3
*,const char*,u8
*);
1308 void sqlite3UserAuthInit(sqlite3
*);
1309 void sqlite3CryptFunc(sqlite3_context
*,int,sqlite3_value
**);
1311 #endif /* SQLITE_USER_AUTHENTICATION */
1314 ** typedef for the authorization callback function.
1316 #ifdef SQLITE_USER_AUTHENTICATION
1317 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1318 const char*, const char*);
1320 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1324 #ifndef SQLITE_OMIT_DEPRECATED
1325 /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
1326 ** in the style of sqlite3_trace()
1328 #define SQLITE_TRACE_LEGACY 0x80
1330 #define SQLITE_TRACE_LEGACY 0
1331 #endif /* SQLITE_OMIT_DEPRECATED */
1335 ** Each database connection is an instance of the following structure.
1338 sqlite3_vfs
*pVfs
; /* OS Interface */
1339 struct Vdbe
*pVdbe
; /* List of active virtual machines */
1340 CollSeq
*pDfltColl
; /* The default collating sequence (BINARY) */
1341 sqlite3_mutex
*mutex
; /* Connection mutex */
1342 Db
*aDb
; /* All backends */
1343 int nDb
; /* Number of backends currently in use */
1344 u32 mDbFlags
; /* flags recording internal state */
1345 u32 flags
; /* flags settable by pragmas. See below */
1346 i64 lastRowid
; /* ROWID of most recent insert (see above) */
1347 i64 szMmap
; /* Default mmap_size setting */
1348 u32 nSchemaLock
; /* Do not reset the schema when non-zero */
1349 unsigned int openFlags
; /* Flags passed to sqlite3_vfs.xOpen() */
1350 int errCode
; /* Most recent error code (SQLITE_*) */
1351 int errMask
; /* & result codes with this before returning */
1352 int iSysErrno
; /* Errno value from last system error */
1353 u16 dbOptFlags
; /* Flags to enable/disable optimizations */
1354 u8 enc
; /* Text encoding */
1355 u8 autoCommit
; /* The auto-commit flag. */
1356 u8 temp_store
; /* 1: file 2: memory 0: default */
1357 u8 mallocFailed
; /* True if we have seen a malloc failure */
1358 u8 bBenignMalloc
; /* Do not require OOMs if true */
1359 u8 dfltLockMode
; /* Default locking-mode for attached dbs */
1360 signed char nextAutovac
; /* Autovac setting after VACUUM if >=0 */
1361 u8 suppressErr
; /* Do not issue error messages if true */
1362 u8 vtabOnConflict
; /* Value to return for s3_vtab_on_conflict() */
1363 u8 isTransactionSavepoint
; /* True if the outermost savepoint is a TS */
1364 u8 mTrace
; /* zero or more SQLITE_TRACE flags */
1365 u8 skipBtreeMutex
; /* True if no shared-cache backends */
1366 u8 nSqlExec
; /* Number of pending OP_SqlExec opcodes */
1367 int nextPagesize
; /* Pagesize after VACUUM if >0 */
1368 u32 magic
; /* Magic number for detect library misuse */
1369 int nChange
; /* Value returned by sqlite3_changes() */
1370 int nTotalChange
; /* Value returned by sqlite3_total_changes() */
1371 int aLimit
[SQLITE_N_LIMIT
]; /* Limits */
1372 int nMaxSorterMmap
; /* Maximum size of regions mapped by sorter */
1373 struct sqlite3InitInfo
{ /* Information used during initialization */
1374 int newTnum
; /* Rootpage of table being initialized */
1375 u8 iDb
; /* Which db file is being initialized */
1376 u8 busy
; /* TRUE if currently initializing */
1377 unsigned orphanTrigger
: 1; /* Last statement is orphaned TEMP trigger */
1378 unsigned imposterTable
: 1; /* Building an imposter table */
1379 unsigned reopenMemdb
: 1; /* ATTACH is really a reopen using MemDB */
1381 int nVdbeActive
; /* Number of VDBEs currently running */
1382 int nVdbeRead
; /* Number of active VDBEs that read or write */
1383 int nVdbeWrite
; /* Number of active VDBEs that read and write */
1384 int nVdbeExec
; /* Number of nested calls to VdbeExec() */
1385 int nVDestroy
; /* Number of active OP_VDestroy operations */
1386 int nExtension
; /* Number of loaded extensions */
1387 void **aExtension
; /* Array of shared library handles */
1388 int (*xTrace
)(u32
,void*,void*,void*); /* Trace function */
1389 void *pTraceArg
; /* Argument to the trace function */
1390 void (*xProfile
)(void*,const char*,u64
); /* Profiling function */
1391 void *pProfileArg
; /* Argument to profile function */
1392 void *pCommitArg
; /* Argument to xCommitCallback() */
1393 int (*xCommitCallback
)(void*); /* Invoked at every commit. */
1394 void *pRollbackArg
; /* Argument to xRollbackCallback() */
1395 void (*xRollbackCallback
)(void*); /* Invoked at every commit. */
1397 void (*xUpdateCallback
)(void*,int, const char*,const char*,sqlite_int64
);
1398 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1399 void *pPreUpdateArg
; /* First argument to xPreUpdateCallback */
1400 void (*xPreUpdateCallback
)( /* Registered using sqlite3_preupdate_hook() */
1401 void*,sqlite3
*,int,char const*,char const*,sqlite3_int64
,sqlite3_int64
1403 PreUpdate
*pPreUpdate
; /* Context for active pre-update callback */
1404 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
1405 #ifndef SQLITE_OMIT_WAL
1406 int (*xWalCallback
)(void *, sqlite3
*, const char *, int);
1409 void(*xCollNeeded
)(void*,sqlite3
*,int eTextRep
,const char*);
1410 void(*xCollNeeded16
)(void*,sqlite3
*,int eTextRep
,const void*);
1411 void *pCollNeededArg
;
1412 sqlite3_value
*pErr
; /* Most recent error message */
1414 volatile int isInterrupted
; /* True if sqlite3_interrupt has been called */
1415 double notUsed1
; /* Spacer */
1417 Lookaside lookaside
; /* Lookaside malloc configuration */
1418 #ifndef SQLITE_OMIT_AUTHORIZATION
1419 sqlite3_xauth xAuth
; /* Access authorization function */
1420 void *pAuthArg
; /* 1st argument to the access auth function */
1422 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1423 int (*xProgress
)(void *); /* The progress callback */
1424 void *pProgressArg
; /* Argument to the progress callback */
1425 unsigned nProgressOps
; /* Number of opcodes for progress callback */
1427 #ifndef SQLITE_OMIT_VIRTUALTABLE
1428 int nVTrans
; /* Allocated size of aVTrans */
1429 Hash aModule
; /* populated by sqlite3_create_module() */
1430 VtabCtx
*pVtabCtx
; /* Context for active vtab connect/create */
1431 VTable
**aVTrans
; /* Virtual tables with open transactions */
1432 VTable
*pDisconnect
; /* Disconnect these in next sqlite3_prepare() */
1434 Hash aFunc
; /* Hash table of connection functions */
1435 Hash aCollSeq
; /* All collating sequences */
1436 BusyHandler busyHandler
; /* Busy callback */
1437 Db aDbStatic
[2]; /* Static space for the 2 default backends */
1438 Savepoint
*pSavepoint
; /* List of active savepoints */
1439 int busyTimeout
; /* Busy handler timeout, in msec */
1440 int nSavepoint
; /* Number of non-transaction savepoints */
1441 int nStatement
; /* Number of nested statement-transactions */
1442 i64 nDeferredCons
; /* Net deferred constraints this transaction. */
1443 i64 nDeferredImmCons
; /* Net deferred immediate constraints */
1444 int *pnBytesFreed
; /* If not NULL, increment this in DbFree() */
1445 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
1446 /* The following variables are all protected by the STATIC_MASTER
1447 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
1449 ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
1450 ** unlock so that it can proceed.
1452 ** When X.pBlockingConnection==Y, that means that something that X tried
1453 ** tried to do recently failed with an SQLITE_LOCKED error due to locks
1456 sqlite3
*pBlockingConnection
; /* Connection that caused SQLITE_LOCKED */
1457 sqlite3
*pUnlockConnection
; /* Connection to watch for unlock */
1458 void *pUnlockArg
; /* Argument to xUnlockNotify */
1459 void (*xUnlockNotify
)(void **, int); /* Unlock notify callback */
1460 sqlite3
*pNextBlocked
; /* Next in list of all blocked connections */
1462 #ifdef SQLITE_USER_AUTHENTICATION
1463 sqlite3_userauth auth
; /* User authentication information */
1468 ** A macro to discover the encoding of a database.
1470 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
1471 #define ENC(db) ((db)->enc)
1474 ** Possible values for the sqlite3.flags.
1476 ** Value constraints (enforced via assert()):
1477 ** SQLITE_FullFSync == PAGER_FULLFSYNC
1478 ** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
1479 ** SQLITE_CacheSpill == PAGER_CACHE_SPILL
1481 #define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_MASTER */
1482 #define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */
1483 #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
1484 #define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */
1485 #define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */
1486 #define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */
1487 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
1488 #define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */
1489 /* DELETE, or UPDATE and return */
1490 /* the count using a callback. */
1491 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
1492 /* result set is empty */
1493 #define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */
1494 #define SQLITE_ReadUncommit 0x00000400 /* READ UNCOMMITTED in shared-cache */
1495 #define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */
1496 #define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */
1497 #define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */
1498 #define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */
1499 #define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */
1500 #define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */
1501 #define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */
1502 #define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */
1503 #define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */
1504 #define SQLITE_QueryOnly 0x00100000 /* Disable database changes */
1505 #define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */
1506 #define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */
1507 #define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/
1508 #define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */
1510 /* Flags used only if debugging */
1512 #define SQLITE_SqlTrace 0x08000000 /* Debug print SQL as it executes */
1513 #define SQLITE_VdbeListing 0x10000000 /* Debug listings of VDBE programs */
1514 #define SQLITE_VdbeTrace 0x20000000 /* True to trace VDBE execution */
1515 #define SQLITE_VdbeAddopTrace 0x40000000 /* Trace sqlite3VdbeAddOp() calls */
1516 #define SQLITE_VdbeEQP 0x80000000 /* Debug EXPLAIN QUERY PLAN */
1520 ** Allowed values for sqlite3.mDbFlags
1522 #define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */
1523 #define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */
1524 #define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */
1527 ** Bits of the sqlite3.dbOptFlags field that are used by the
1528 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
1529 ** selectively disable various optimizations.
1531 #define SQLITE_QueryFlattener 0x0001 /* Query flattening */
1532 #define SQLITE_ColumnCache 0x0002 /* Column cache */
1533 #define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */
1534 #define SQLITE_FactorOutConst 0x0008 /* Constant factoring */
1535 #define SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */
1536 #define SQLITE_CoverIdxScan 0x0020 /* Covering index scans */
1537 #define SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */
1538 #define SQLITE_Transitive 0x0080 /* Transitive constraints */
1539 #define SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */
1540 #define SQLITE_CountOfView 0x0200 /* The count-of-view optimization */
1541 #define SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */
1542 #define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */
1543 /* TH3 expects the Stat34 ^^^^^^ value to be 0x0800. Don't change it */
1544 #define SQLITE_PushDown 0x1000 /* The push-down optimization */
1545 #define SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */
1546 #define SQLITE_AllOpts 0xffff /* All optimizations */
1549 ** Macros for testing whether or not optimizations are enabled or disabled.
1551 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
1552 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
1555 ** Return true if it OK to factor constant expressions into the initialization
1556 ** code. The argument is a Parse object for the code generator.
1558 #define ConstFactorOk(P) ((P)->okConstFactor)
1561 ** Possible values for the sqlite.magic field.
1562 ** The numbers are obtained at random and have no special meaning, other
1563 ** than being distinct from one another.
1565 #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
1566 #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
1567 #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
1568 #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
1569 #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
1570 #define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */
1573 ** Each SQL function is defined by an instance of the following
1574 ** structure. For global built-in functions (ex: substr(), max(), count())
1575 ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
1576 ** For per-connection application-defined functions, a pointer to this
1577 ** structure is held in the db->aHash hash table.
1579 ** The u.pHash field is used by the global built-ins. The u.pDestructor
1580 ** field is used by per-connection app-def functions.
1583 i8 nArg
; /* Number of arguments. -1 means unlimited */
1584 u16 funcFlags
; /* Some combination of SQLITE_FUNC_* */
1585 void *pUserData
; /* User data parameter */
1586 FuncDef
*pNext
; /* Next function with same name */
1587 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**); /* func or agg-step */
1588 void (*xFinalize
)(sqlite3_context
*); /* Agg finalizer */
1589 const char *zName
; /* SQL name of the function. */
1591 FuncDef
*pHash
; /* Next with a different name but the same hash */
1592 FuncDestructor
*pDestructor
; /* Reference counted destructor function */
1597 ** This structure encapsulates a user-function destructor callback (as
1598 ** configured using create_function_v2()) and a reference counter. When
1599 ** create_function_v2() is called to create a function with a destructor,
1600 ** a single object of this type is allocated. FuncDestructor.nRef is set to
1601 ** the number of FuncDef objects created (either 1 or 3, depending on whether
1602 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
1603 ** member of each of the new FuncDef objects is set to point to the allocated
1606 ** Thereafter, when one of the FuncDef objects is deleted, the reference
1607 ** count on this object is decremented. When it reaches 0, the destructor
1608 ** is invoked and the FuncDestructor structure freed.
1610 struct FuncDestructor
{
1612 void (*xDestroy
)(void *);
1617 ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
1618 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
1619 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
1620 ** are assert() statements in the code to verify this.
1622 ** Value constraints (enforced via assert()):
1623 ** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
1624 ** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
1625 ** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
1626 ** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
1627 ** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
1629 #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
1630 #define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */
1631 #define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
1632 #define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
1633 #define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
1634 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
1635 #define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
1636 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
1637 #define SQLITE_FUNC_COALESCE 0x0200 /* Built-in coalesce() or ifnull() */
1638 #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
1639 #define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
1640 #define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
1641 #define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
1642 ** single query - might change over time */
1643 #define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
1644 #define SQLITE_FUNC_OFFSET 0x8000 /* Built-in sqlite_offset() function */
1647 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
1648 ** used to create the initializers for the FuncDef structures.
1650 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
1651 ** Used to create a scalar function definition of a function zName
1652 ** implemented by C function xFunc that accepts nArg arguments. The
1653 ** value passed as iArg is cast to a (void*) and made available
1654 ** as the user-data (sqlite3_user_data()) for the function. If
1655 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
1657 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
1658 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
1660 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
1661 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
1662 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
1663 ** and functions like sqlite_version() that can change, but not during
1664 ** a single query. The iArg is ignored. The user-data is always set
1665 ** to a NULL pointer. The bNC parameter is not used.
1667 ** PURE_DATE(zName, nArg, iArg, bNC, xFunc)
1668 ** Used for "pure" date/time functions, this macro is like DFUNCTION
1669 ** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is
1670 ** ignored and the user-data for these functions is set to an
1671 ** arbitrary non-NULL pointer. The bNC parameter is not used.
1673 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
1674 ** Used to create an aggregate function definition implemented by
1675 ** the C functions xStep and xFinal. The first four parameters
1676 ** are interpreted in the same way as the first 4 parameters to
1679 ** LIKEFUNC(zName, nArg, pArg, flags)
1680 ** Used to create a scalar function definition of a function zName
1681 ** that accepts nArg arguments and is implemented by a call to C
1682 ** function likeFunc. Argument pArg is cast to a (void *) and made
1683 ** available as the function user-data (sqlite3_user_data()). The
1684 ** FuncDef.flags variable is set to the value passed as the flags
1687 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
1688 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1689 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1690 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1691 {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1692 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1693 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1694 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
1695 0, 0, xFunc, 0, #zName, {0} }
1696 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
1697 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
1698 (void*)&sqlite3Config, 0, xFunc, 0, #zName, {0} }
1699 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
1700 {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
1701 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1702 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
1703 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1704 pArg, 0, xFunc, 0, #zName, }
1705 #define LIKEFUNC(zName, nArg, arg, flags) \
1706 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
1707 (void *)arg, 0, likeFunc, 0, #zName, {0} }
1708 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
1709 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
1710 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1711 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
1712 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
1713 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1716 ** All current savepoints are stored in a linked list starting at
1717 ** sqlite3.pSavepoint. The first element in the list is the most recently
1718 ** opened savepoint. Savepoints are added to the list by the vdbe
1719 ** OP_Savepoint instruction.
1722 char *zName
; /* Savepoint name (nul-terminated) */
1723 i64 nDeferredCons
; /* Number of deferred fk violations */
1724 i64 nDeferredImmCons
; /* Number of deferred imm fk. */
1725 Savepoint
*pNext
; /* Parent savepoint (if any) */
1729 ** The following are used as the second parameter to sqlite3Savepoint(),
1730 ** and as the P1 argument to the OP_Savepoint instruction.
1732 #define SAVEPOINT_BEGIN 0
1733 #define SAVEPOINT_RELEASE 1
1734 #define SAVEPOINT_ROLLBACK 2
1738 ** Each SQLite module (virtual table definition) is defined by an
1739 ** instance of the following structure, stored in the sqlite3.aModule
1743 const sqlite3_module
*pModule
; /* Callback pointers */
1744 const char *zName
; /* Name passed to create_module() */
1745 void *pAux
; /* pAux passed to create_module() */
1746 void (*xDestroy
)(void *); /* Module destructor function */
1747 Table
*pEpoTab
; /* Eponymous table for this module */
1751 ** information about each column of an SQL table is held in an instance
1752 ** of this structure.
1755 char *zName
; /* Name of this column, \000, then the type */
1756 Expr
*pDflt
; /* Default value of this column */
1757 char *zColl
; /* Collating sequence. If NULL, use the default */
1758 u8 notNull
; /* An OE_ code for handling a NOT NULL constraint */
1759 char affinity
; /* One of the SQLITE_AFF_... values */
1760 u8 szEst
; /* Estimated size of value in this column. sizeof(INT)==1 */
1761 u8 colFlags
; /* Boolean properties. See COLFLAG_ defines below */
1764 /* Allowed values for Column.colFlags:
1766 #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
1767 #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
1768 #define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
1769 #define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */
1770 #define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */
1773 ** A "Collating Sequence" is defined by an instance of the following
1774 ** structure. Conceptually, a collating sequence consists of a name and
1775 ** a comparison routine that defines the order of that sequence.
1777 ** If CollSeq.xCmp is NULL, it means that the
1778 ** collating sequence is undefined. Indices built on an undefined
1779 ** collating sequence may not be read or written.
1782 char *zName
; /* Name of the collating sequence, UTF-8 encoded */
1783 u8 enc
; /* Text encoding handled by xCmp() */
1784 void *pUser
; /* First argument to xCmp() */
1785 int (*xCmp
)(void*,int, const void*, int, const void*);
1786 void (*xDel
)(void*); /* Destructor for pUser */
1790 ** A sort order can be either ASC or DESC.
1792 #define SQLITE_SO_ASC 0 /* Sort in ascending order */
1793 #define SQLITE_SO_DESC 1 /* Sort in ascending order */
1794 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
1797 ** Column affinity types.
1799 ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
1800 ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
1801 ** the speed a little by numbering the values consecutively.
1803 ** But rather than start with 0 or 1, we begin with 'A'. That way,
1804 ** when multiple affinity types are concatenated into a string and
1805 ** used as the P4 operand, they will be more readable.
1807 ** Note also that the numeric types are grouped together so that testing
1808 ** for a numeric type is a single comparison. And the BLOB type is first.
1810 #define SQLITE_AFF_BLOB 'A'
1811 #define SQLITE_AFF_TEXT 'B'
1812 #define SQLITE_AFF_NUMERIC 'C'
1813 #define SQLITE_AFF_INTEGER 'D'
1814 #define SQLITE_AFF_REAL 'E'
1816 #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
1819 ** The SQLITE_AFF_MASK values masks off the significant bits of an
1822 #define SQLITE_AFF_MASK 0x47
1825 ** Additional bit values that can be ORed with an affinity without
1826 ** changing the affinity.
1828 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
1829 ** It causes an assert() to fire if either operand to a comparison
1830 ** operator is NULL. It is added to certain comparison operators to
1831 ** prove that the operands are always NOT NULL.
1833 #define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */
1834 #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
1835 #define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */
1836 #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
1837 #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */
1840 ** An object of this type is created for each virtual table present in
1841 ** the database schema.
1843 ** If the database schema is shared, then there is one instance of this
1844 ** structure for each database connection (sqlite3*) that uses the shared
1845 ** schema. This is because each database connection requires its own unique
1846 ** instance of the sqlite3_vtab* handle used to access the virtual table
1847 ** implementation. sqlite3_vtab* handles can not be shared between
1848 ** database connections, even when the rest of the in-memory database
1849 ** schema is shared, as the implementation often stores the database
1850 ** connection handle passed to it via the xConnect() or xCreate() method
1851 ** during initialization internally. This database connection handle may
1852 ** then be used by the virtual table implementation to access real tables
1853 ** within the database. So that they appear as part of the callers
1854 ** transaction, these accesses need to be made via the same database
1855 ** connection as that used to execute SQL operations on the virtual table.
1857 ** All VTable objects that correspond to a single table in a shared
1858 ** database schema are initially stored in a linked-list pointed to by
1859 ** the Table.pVTable member variable of the corresponding Table object.
1860 ** When an sqlite3_prepare() operation is required to access the virtual
1861 ** table, it searches the list for the VTable that corresponds to the
1862 ** database connection doing the preparing so as to use the correct
1863 ** sqlite3_vtab* handle in the compiled query.
1865 ** When an in-memory Table object is deleted (for example when the
1866 ** schema is being reloaded for some reason), the VTable objects are not
1867 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
1868 ** immediately. Instead, they are moved from the Table.pVTable list to
1869 ** another linked list headed by the sqlite3.pDisconnect member of the
1870 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
1871 ** next time a statement is prepared using said sqlite3*. This is done
1872 ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
1873 ** Refer to comments above function sqlite3VtabUnlockList() for an
1874 ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
1875 ** list without holding the corresponding sqlite3.mutex mutex.
1877 ** The memory for objects of this type is always allocated by
1878 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
1879 ** the first argument.
1882 sqlite3
*db
; /* Database connection associated with this table */
1883 Module
*pMod
; /* Pointer to module implementation */
1884 sqlite3_vtab
*pVtab
; /* Pointer to vtab instance */
1885 int nRef
; /* Number of pointers to this structure */
1886 u8 bConstraint
; /* True if constraints are supported */
1887 int iSavepoint
; /* Depth of the SAVEPOINT stack */
1888 VTable
*pNext
; /* Next in linked list (see above) */
1892 ** The schema for each SQL table and view is represented in memory
1893 ** by an instance of the following structure.
1896 char *zName
; /* Name of the table or view */
1897 Column
*aCol
; /* Information about each column */
1898 Index
*pIndex
; /* List of SQL indexes on this table. */
1899 Select
*pSelect
; /* NULL for tables. Points to definition if a view. */
1900 FKey
*pFKey
; /* Linked list of all foreign keys in this table */
1901 char *zColAff
; /* String defining the affinity of each column */
1902 ExprList
*pCheck
; /* All CHECK constraints */
1903 /* ... also used as column name list in a VIEW */
1904 int tnum
; /* Root BTree page for this table */
1905 u32 nTabRef
; /* Number of pointers to this Table */
1906 u32 tabFlags
; /* Mask of TF_* values */
1907 i16 iPKey
; /* If not negative, use aCol[iPKey] as the rowid */
1908 i16 nCol
; /* Number of columns in this table */
1909 LogEst nRowLogEst
; /* Estimated rows in table - from sqlite_stat1 table */
1910 LogEst szTabRow
; /* Estimated size of each table row in bytes */
1911 #ifdef SQLITE_ENABLE_COSTMULT
1912 LogEst costMult
; /* Cost multiplier for using this table */
1914 u8 keyConf
; /* What to do in case of uniqueness conflict on iPKey */
1915 #ifndef SQLITE_OMIT_ALTERTABLE
1916 int addColOffset
; /* Offset in CREATE TABLE stmt to add a new column */
1918 #ifndef SQLITE_OMIT_VIRTUALTABLE
1919 int nModuleArg
; /* Number of arguments to the module */
1920 char **azModuleArg
; /* 0: module 1: schema 2: vtab name 3...: args */
1921 VTable
*pVTable
; /* List of VTable objects. */
1923 Trigger
*pTrigger
; /* List of triggers stored in pSchema */
1924 Schema
*pSchema
; /* Schema that contains this table */
1925 Table
*pNextZombie
; /* Next on the Parse.pZombieTab list */
1929 ** Allowed values for Table.tabFlags.
1931 ** TF_OOOHidden applies to tables or view that have hidden columns that are
1932 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
1933 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
1934 ** the TF_OOOHidden attribute would apply in this case. Such tables require
1935 ** special handling during INSERT processing.
1937 #define TF_Readonly 0x0001 /* Read-only system table */
1938 #define TF_Ephemeral 0x0002 /* An ephemeral table */
1939 #define TF_HasPrimaryKey 0x0004 /* Table has a primary key */
1940 #define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */
1941 #define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */
1942 #define TF_WithoutRowid 0x0020 /* No rowid. PRIMARY KEY is the key */
1943 #define TF_NoVisibleRowid 0x0040 /* No user-visible "rowid" column */
1944 #define TF_OOOHidden 0x0080 /* Out-of-Order hidden columns */
1945 #define TF_StatsUsed 0x0100 /* Query planner decisions affected by
1946 ** Index.aiRowLogEst[] values */
1947 #define TF_HasNotNull 0x0200 /* Contains NOT NULL constraints */
1950 ** Test to see whether or not a table is a virtual table. This is
1951 ** done as a macro so that it will be optimized out when virtual
1952 ** table support is omitted from the build.
1954 #ifndef SQLITE_OMIT_VIRTUALTABLE
1955 # define IsVirtual(X) ((X)->nModuleArg)
1957 # define IsVirtual(X) 0
1961 ** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn()
1962 ** only works for non-virtual tables (ordinary tables and views) and is
1963 ** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The
1964 ** IsHiddenColumn() macro is general purpose.
1966 #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS)
1967 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1968 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1969 #elif !defined(SQLITE_OMIT_VIRTUALTABLE)
1970 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1971 # define IsOrdinaryHiddenColumn(X) 0
1973 # define IsHiddenColumn(X) 0
1974 # define IsOrdinaryHiddenColumn(X) 0
1978 /* Does the table have a rowid */
1979 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
1980 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
1983 ** Each foreign key constraint is an instance of the following structure.
1985 ** A foreign key is associated with two tables. The "from" table is
1986 ** the table that contains the REFERENCES clause that creates the foreign
1987 ** key. The "to" table is the table that is named in the REFERENCES clause.
1988 ** Consider this example:
1990 ** CREATE TABLE ex1(
1991 ** a INTEGER PRIMARY KEY,
1992 ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
1995 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
1996 ** Equivalent names:
1998 ** from-table == child-table
1999 ** to-table == parent-table
2001 ** Each REFERENCES clause generates an instance of the following structure
2002 ** which is attached to the from-table. The to-table need not exist when
2003 ** the from-table is created. The existence of the to-table is not checked.
2005 ** The list of all parents for child Table X is held at X.pFKey.
2007 ** A list of all children for a table named Z (which might not even exist)
2008 ** is held in Schema.fkeyHash with a hash key of Z.
2011 Table
*pFrom
; /* Table containing the REFERENCES clause (aka: Child) */
2012 FKey
*pNextFrom
; /* Next FKey with the same in pFrom. Next parent of pFrom */
2013 char *zTo
; /* Name of table that the key points to (aka: Parent) */
2014 FKey
*pNextTo
; /* Next with the same zTo. Next child of zTo. */
2015 FKey
*pPrevTo
; /* Previous with the same zTo */
2016 int nCol
; /* Number of columns in this key */
2017 /* EV: R-30323-21917 */
2018 u8 isDeferred
; /* True if constraint checking is deferred till COMMIT */
2019 u8 aAction
[2]; /* ON DELETE and ON UPDATE actions, respectively */
2020 Trigger
*apTrigger
[2];/* Triggers for aAction[] actions */
2021 struct sColMap
{ /* Mapping of columns in pFrom to columns in zTo */
2022 int iFrom
; /* Index of column in pFrom */
2023 char *zCol
; /* Name of column in zTo. If NULL use PRIMARY KEY */
2024 } aCol
[1]; /* One entry for each of nCol columns */
2028 ** SQLite supports many different ways to resolve a constraint
2029 ** error. ROLLBACK processing means that a constraint violation
2030 ** causes the operation in process to fail and for the current transaction
2031 ** to be rolled back. ABORT processing means the operation in process
2032 ** fails and any prior changes from that one operation are backed out,
2033 ** but the transaction is not rolled back. FAIL processing means that
2034 ** the operation in progress stops and returns an error code. But prior
2035 ** changes due to the same operation are not backed out and no rollback
2036 ** occurs. IGNORE means that the particular row that caused the constraint
2037 ** error is not inserted or updated. Processing continues and no error
2038 ** is returned. REPLACE means that preexisting database rows that caused
2039 ** a UNIQUE constraint violation are removed so that the new insert or
2040 ** update can proceed. Processing continues and no error is reported.
2042 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
2043 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
2044 ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
2045 ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
2046 ** referenced table row is propagated into the row that holds the
2049 ** The following symbolic values are used to record which type
2050 ** of action to take.
2052 #define OE_None 0 /* There is no constraint to check */
2053 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
2054 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
2055 #define OE_Fail 3 /* Stop the operation but leave all prior changes */
2056 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
2057 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
2058 #define OE_Update 6 /* Process as a DO UPDATE in an upsert */
2059 #define OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
2060 #define OE_SetNull 8 /* Set the foreign key value to NULL */
2061 #define OE_SetDflt 9 /* Set the foreign key value to its default */
2062 #define OE_Cascade 10 /* Cascade the changes */
2063 #define OE_Default 11 /* Do whatever the default action is */
2067 ** An instance of the following structure is passed as the first
2068 ** argument to sqlite3VdbeKeyCompare and is used to control the
2069 ** comparison of the two index keys.
2071 ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
2072 ** are nField slots for the columns of an index then one extra slot
2073 ** for the rowid at the end.
2076 u32 nRef
; /* Number of references to this KeyInfo object */
2077 u8 enc
; /* Text encoding - one of the SQLITE_UTF* values */
2078 u16 nKeyField
; /* Number of key columns in the index */
2079 u16 nAllField
; /* Total columns, including key plus others */
2080 sqlite3
*db
; /* The database connection */
2081 u8
*aSortOrder
; /* Sort order for each column. */
2082 CollSeq
*aColl
[1]; /* Collating sequence for each term of the key */
2086 ** This object holds a record which has been parsed out into individual
2087 ** fields, for the purposes of doing a comparison.
2089 ** A record is an object that contains one or more fields of data.
2090 ** Records are used to store the content of a table row and to store
2091 ** the key of an index. A blob encoding of a record is created by
2092 ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
2093 ** OP_Column opcode.
2095 ** An instance of this object serves as a "key" for doing a search on
2096 ** an index b+tree. The goal of the search is to find the entry that
2097 ** is closed to the key described by this object. This object might hold
2098 ** just a prefix of the key. The number of fields is given by
2099 ** pKeyInfo->nField.
2101 ** The r1 and r2 fields are the values to return if this key is less than
2102 ** or greater than a key in the btree, respectively. These are normally
2103 ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
2104 ** is in DESC order.
2106 ** The key comparison functions actually return default_rc when they find
2107 ** an equals comparison. default_rc can be -1, 0, or +1. If there are
2108 ** multiple entries in the b-tree with the same key (when only looking
2109 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
2110 ** cause the search to find the last match, or +1 to cause the search to
2111 ** find the first match.
2113 ** The key comparison functions will set eqSeen to true if they ever
2114 ** get and equal results when comparing this structure to a b-tree record.
2115 ** When default_rc!=0, the search might end up on the record immediately
2116 ** before the first match or immediately after the last match. The
2117 ** eqSeen field will indicate whether or not an exact match exists in the
2120 struct UnpackedRecord
{
2121 KeyInfo
*pKeyInfo
; /* Collation and sort-order information */
2122 Mem
*aMem
; /* Values */
2123 u16 nField
; /* Number of entries in apMem[] */
2124 i8 default_rc
; /* Comparison result if keys are equal */
2125 u8 errCode
; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
2126 i8 r1
; /* Value to return if (lhs < rhs) */
2127 i8 r2
; /* Value to return if (lhs > rhs) */
2128 u8 eqSeen
; /* True if an equality comparison has been seen */
2133 ** Each SQL index is represented in memory by an
2134 ** instance of the following structure.
2136 ** The columns of the table that are to be indexed are described
2137 ** by the aiColumn[] field of this structure. For example, suppose
2138 ** we have the following table and index:
2140 ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
2141 ** CREATE INDEX Ex2 ON Ex1(c3,c1);
2143 ** In the Table structure describing Ex1, nCol==3 because there are
2144 ** three columns in the table. In the Index structure describing
2145 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
2146 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
2147 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
2148 ** The second column to be indexed (c1) has an index of 0 in
2149 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
2151 ** The Index.onError field determines whether or not the indexed columns
2152 ** must be unique and what to do if they are not. When Index.onError=OE_None,
2153 ** it means this is not a unique index. Otherwise it is a unique index
2154 ** and the value of Index.onError indicate the which conflict resolution
2155 ** algorithm to employ whenever an attempt is made to insert a non-unique
2158 ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
2159 ** generate VDBE code (as opposed to parsing one read from an sqlite_master
2160 ** table as part of parsing an existing database schema), transient instances
2161 ** of this structure may be created. In this case the Index.tnum variable is
2162 ** used to store the address of a VDBE instruction, not a database page
2163 ** number (it cannot - the database page is not allocated until the VDBE
2164 ** program is executed). See convertToWithoutRowidTable() for details.
2167 char *zName
; /* Name of this index */
2168 i16
*aiColumn
; /* Which columns are used by this index. 1st is 0 */
2169 LogEst
*aiRowLogEst
; /* From ANALYZE: Est. rows selected by each column */
2170 Table
*pTable
; /* The SQL table being indexed */
2171 char *zColAff
; /* String defining the affinity of each column */
2172 Index
*pNext
; /* The next index associated with the same table */
2173 Schema
*pSchema
; /* Schema containing this index */
2174 u8
*aSortOrder
; /* for each column: True==DESC, False==ASC */
2175 const char **azColl
; /* Array of collation sequence names for index */
2176 Expr
*pPartIdxWhere
; /* WHERE clause for partial indices */
2177 ExprList
*aColExpr
; /* Column expressions */
2178 int tnum
; /* DB Page containing root of this index */
2179 LogEst szIdxRow
; /* Estimated average row size in bytes */
2180 u16 nKeyCol
; /* Number of columns forming the key */
2181 u16 nColumn
; /* Number of columns stored in the index */
2182 u8 onError
; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2183 unsigned idxType
:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
2184 unsigned bUnordered
:1; /* Use this index for == or IN queries only */
2185 unsigned uniqNotNull
:1; /* True if UNIQUE and NOT NULL for all columns */
2186 unsigned isResized
:1; /* True if resizeIndexObject() has been called */
2187 unsigned isCovering
:1; /* True if this is a covering index */
2188 unsigned noSkipScan
:1; /* Do not try to use skip-scan if true */
2189 unsigned hasStat1
:1; /* aiRowLogEst values come from sqlite_stat1 */
2190 unsigned bNoQuery
:1; /* Do not use this index to optimize queries */
2191 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
2192 int nSample
; /* Number of elements in aSample[] */
2193 int nSampleCol
; /* Size of IndexSample.anEq[] and so on */
2194 tRowcnt
*aAvgEq
; /* Average nEq values for keys not in aSample */
2195 IndexSample
*aSample
; /* Samples of the left-most key */
2196 tRowcnt
*aiRowEst
; /* Non-logarithmic stat1 data for this index */
2197 tRowcnt nRowEst0
; /* Non-logarithmic number of rows in the index */
2202 ** Allowed values for Index.idxType
2204 #define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
2205 #define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */
2206 #define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */
2208 /* Return true if index X is a PRIMARY KEY index */
2209 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
2211 /* Return true if index X is a UNIQUE index */
2212 #define IsUniqueIndex(X) ((X)->onError!=OE_None)
2214 /* The Index.aiColumn[] values are normally positive integer. But
2215 ** there are some negative values that have special meaning:
2217 #define XN_ROWID (-1) /* Indexed column is the rowid */
2218 #define XN_EXPR (-2) /* Indexed column is an expression */
2221 ** Each sample stored in the sqlite_stat3 table is represented in memory
2222 ** using a structure of this type. See documentation at the top of the
2223 ** analyze.c source file for additional information.
2225 struct IndexSample
{
2226 void *p
; /* Pointer to sampled record */
2227 int n
; /* Size of record in bytes */
2228 tRowcnt
*anEq
; /* Est. number of rows where the key equals this sample */
2229 tRowcnt
*anLt
; /* Est. number of rows where key is less than this sample */
2230 tRowcnt
*anDLt
; /* Est. number of distinct keys less than this sample */
2234 ** Each token coming out of the lexer is an instance of
2235 ** this structure. Tokens are also used as part of an expression.
2237 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
2238 ** may contain random values. Do not make any assumptions about Token.dyn
2239 ** and Token.n when Token.z==0.
2242 const char *z
; /* Text of the token. Not NULL-terminated! */
2243 unsigned int n
; /* Number of characters in this token */
2247 ** An instance of this structure contains information needed to generate
2248 ** code for a SELECT that contains aggregate functions.
2250 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
2251 ** pointer to this structure. The Expr.iColumn field is the index in
2252 ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
2253 ** code for that node.
2255 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
2256 ** original Select structure that describes the SELECT statement. These
2257 ** fields do not need to be freed when deallocating the AggInfo structure.
2260 u8 directMode
; /* Direct rendering mode means take data directly
2261 ** from source tables rather than from accumulators */
2262 u8 useSortingIdx
; /* In direct mode, reference the sorting index rather
2263 ** than the source table */
2264 int sortingIdx
; /* Cursor number of the sorting index */
2265 int sortingIdxPTab
; /* Cursor number of pseudo-table */
2266 int nSortingColumn
; /* Number of columns in the sorting index */
2267 int mnReg
, mxReg
; /* Range of registers allocated for aCol and aFunc */
2268 ExprList
*pGroupBy
; /* The group by clause */
2269 struct AggInfo_col
{ /* For each column used in source tables */
2270 Table
*pTab
; /* Source table */
2271 int iTable
; /* Cursor number of the source table */
2272 int iColumn
; /* Column number within the source table */
2273 int iSorterColumn
; /* Column number in the sorting index */
2274 int iMem
; /* Memory location that acts as accumulator */
2275 Expr
*pExpr
; /* The original expression */
2277 int nColumn
; /* Number of used entries in aCol[] */
2278 int nAccumulator
; /* Number of columns that show through to the output.
2279 ** Additional columns are used only as parameters to
2280 ** aggregate functions */
2281 struct AggInfo_func
{ /* For each aggregate function */
2282 Expr
*pExpr
; /* Expression encoding the function */
2283 FuncDef
*pFunc
; /* The aggregate function implementation */
2284 int iMem
; /* Memory location that acts as accumulator */
2285 int iDistinct
; /* Ephemeral table used to enforce DISTINCT */
2287 int nFunc
; /* Number of entries in aFunc[] */
2291 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
2292 ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
2293 ** than 32767 we have to make it 32-bit. 16-bit is preferred because
2294 ** it uses less memory in the Expr object, which is a big memory user
2295 ** in systems with lots of prepared statements. And few applications
2296 ** need more than about 10 or 20 variables. But some extreme users want
2297 ** to have prepared statements with over 32767 variables, and for them
2298 ** the option is available (at compile-time).
2300 #if SQLITE_MAX_VARIABLE_NUMBER<=32767
2307 ** Each node of an expression in the parse tree is an instance
2308 ** of this structure.
2310 ** Expr.op is the opcode. The integer parser token codes are reused
2311 ** as opcodes here. For example, the parser defines TK_GE to be an integer
2312 ** code representing the ">=" operator. This same integer code is reused
2313 ** to represent the greater-than-or-equal-to operator in the expression
2316 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
2317 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
2318 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
2319 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
2320 ** then Expr.token contains the name of the function.
2322 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
2323 ** binary operator. Either or both may be NULL.
2325 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
2326 ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
2327 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
2328 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
2329 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
2332 ** An expression of the form ID or ID.ID refers to a column in a table.
2333 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
2334 ** the integer cursor number of a VDBE cursor pointing to that table and
2335 ** Expr.iColumn is the column number for the specific column. If the
2336 ** expression is used as a result in an aggregate SELECT, then the
2337 ** value is also stored in the Expr.iAgg column in the aggregate so that
2338 ** it can be accessed after all aggregates are computed.
2340 ** If the expression is an unbound variable marker (a question mark
2341 ** character '?' in the original SQL) then the Expr.iTable holds the index
2342 ** number for that variable.
2344 ** If the expression is a subquery then Expr.iColumn holds an integer
2345 ** register number containing the result of the subquery. If the
2346 ** subquery gives a constant result, then iTable is -1. If the subquery
2347 ** gives a different answer at different times during statement processing
2348 ** then iTable is the address of a subroutine that computes the subquery.
2350 ** If the Expr is of type OP_Column, and the table it is selecting from
2351 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
2352 ** corresponding table definition.
2354 ** ALLOCATION NOTES:
2356 ** Expr objects can use a lot of memory space in database schema. To
2357 ** help reduce memory requirements, sometimes an Expr object will be
2358 ** truncated. And to reduce the number of memory allocations, sometimes
2359 ** two or more Expr objects will be stored in a single memory allocation,
2360 ** together with Expr.zToken strings.
2362 ** If the EP_Reduced and EP_TokenOnly flags are set when
2363 ** an Expr object is truncated. When EP_Reduced is set, then all
2364 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
2365 ** are contained within the same memory allocation. Note, however, that
2366 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
2367 ** allocated, regardless of whether or not EP_Reduced is set.
2370 u8 op
; /* Operation performed by this node */
2371 char affinity
; /* The affinity of the column or 0 if not a column */
2372 u32 flags
; /* Various flags. EP_* See below */
2374 char *zToken
; /* Token value. Zero terminated and dequoted */
2375 int iValue
; /* Non-negative integer value if EP_IntValue */
2378 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
2379 ** space is allocated for the fields below this point. An attempt to
2380 ** access them will result in a segfault or malfunction.
2381 *********************************************************************/
2383 Expr
*pLeft
; /* Left subnode */
2384 Expr
*pRight
; /* Right subnode */
2386 ExprList
*pList
; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
2387 Select
*pSelect
; /* EP_xIsSelect and op = IN, EXISTS, SELECT */
2390 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
2391 ** space is allocated for the fields below this point. An attempt to
2392 ** access them will result in a segfault or malfunction.
2393 *********************************************************************/
2395 #if SQLITE_MAX_EXPR_DEPTH>0
2396 int nHeight
; /* Height of the tree headed by this node */
2398 int iTable
; /* TK_COLUMN: cursor number of table holding column
2399 ** TK_REGISTER: register number
2400 ** TK_TRIGGER: 1 -> new, 0 -> old
2401 ** EP_Unlikely: 134217728 times likelihood
2402 ** TK_SELECT: 1st register of result vector */
2403 ynVar iColumn
; /* TK_COLUMN: column index. -1 for rowid.
2404 ** TK_VARIABLE: variable number (always >= 1).
2405 ** TK_SELECT_COLUMN: column of the result vector */
2406 i16 iAgg
; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
2407 i16 iRightJoinTable
; /* If EP_FromJoin, the right table of the join */
2408 u8 op2
; /* TK_REGISTER: original value of Expr.op
2409 ** TK_COLUMN: the value of p5 for OP_Column
2410 ** TK_AGG_FUNCTION: nesting depth */
2411 AggInfo
*pAggInfo
; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
2412 Table
*pTab
; /* Table for TK_COLUMN expressions. Can be NULL
2413 ** for a column of an index on an expression */
2417 ** The following are the meanings of bits in the Expr.flags field.
2419 #define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */
2420 #define EP_Agg 0x000002 /* Contains one or more aggregate functions */
2421 #define EP_HasFunc 0x000004 /* Contains one or more functions of any kind */
2422 /* 0x000008 // available for use */
2423 #define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */
2424 #define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */
2425 #define EP_DblQuoted 0x000040 /* token.z was originally in "..." */
2426 #define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */
2427 #define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */
2428 #define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */
2429 #define EP_IntValue 0x000400 /* Integer value contained in u.iValue */
2430 #define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */
2431 #define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */
2432 #define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
2433 #define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
2434 #define EP_Static 0x008000 /* Held in memory not obtained from malloc() */
2435 #define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */
2436 #define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
2437 #define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */
2438 #define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
2439 #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
2440 #define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
2441 #define EP_Alias 0x400000 /* Is an alias for a result set column */
2442 #define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
2445 ** The EP_Propagate mask is a set of properties that automatically propagate
2446 ** upwards into parent nodes.
2448 #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)
2451 ** These macros can be used to test, set, or clear bits in the
2452 ** Expr.flags field.
2454 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
2455 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
2456 #define ExprSetProperty(E,P) (E)->flags|=(P)
2457 #define ExprClearProperty(E,P) (E)->flags&=~(P)
2459 /* The ExprSetVVAProperty() macro is used for Verification, Validation,
2460 ** and Accreditation only. It works like ExprSetProperty() during VVA
2461 ** processes but is a no-op for delivery.
2464 # define ExprSetVVAProperty(E,P) (E)->flags|=(P)
2466 # define ExprSetVVAProperty(E,P)
2470 ** Macros to determine the number of bytes required by a normal Expr
2471 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
2472 ** and an Expr struct with the EP_TokenOnly flag set.
2474 #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
2475 #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
2476 #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
2479 ** Flags passed to the sqlite3ExprDup() function. See the header comment
2480 ** above sqlite3ExprDup() for details.
2482 #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
2485 ** A list of expressions. Each expression may optionally have a
2486 ** name. An expr/name combination can be used in several ways, such
2487 ** as the list of "expr AS ID" fields following a "SELECT" or in the
2488 ** list of "ID = expr" items in an UPDATE. A list of expressions can
2489 ** also be used as the argument to a function, in which case the a.zName
2490 ** field is not used.
2492 ** By default the Expr.zSpan field holds a human-readable description of
2493 ** the expression that is used in the generation of error messages and
2494 ** column labels. In this case, Expr.zSpan is typically the text of a
2495 ** column expression as it exists in a SELECT statement. However, if
2496 ** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
2497 ** of the result column in the form: DATABASE.TABLE.COLUMN. This later
2498 ** form is used for name resolution with nested FROM clauses.
2501 int nExpr
; /* Number of expressions on the list */
2502 struct ExprList_item
{ /* For each expression in the list */
2503 Expr
*pExpr
; /* The parse tree for this expression */
2504 char *zName
; /* Token associated with this expression */
2505 char *zSpan
; /* Original text of the expression */
2506 u8 sortOrder
; /* 1 for DESC or 0 for ASC */
2507 unsigned done
:1; /* A flag to indicate when processing is finished */
2508 unsigned bSpanIsTab
:1; /* zSpan holds DB.TABLE.COLUMN */
2509 unsigned reusable
:1; /* Constant expression is reusable */
2510 unsigned bSorterRef
:1; /* Defer evaluation until after sorting */
2513 u16 iOrderByCol
; /* For ORDER BY, column number in result set */
2514 u16 iAlias
; /* Index into Parse.aAlias[] for zName */
2516 int iConstExprReg
; /* Register in which Expr value is cached */
2518 } a
[1]; /* One slot for each expression in the list */
2522 ** An instance of this structure can hold a simple list of identifiers,
2523 ** such as the list "a,b,c" in the following statements:
2525 ** INSERT INTO t(a,b,c) VALUES ...;
2526 ** CREATE INDEX idx ON t(a,b,c);
2527 ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
2529 ** The IdList.a.idx field is used when the IdList represents the list of
2530 ** column names after a table name in an INSERT statement. In the statement
2532 ** INSERT INTO t(a,b,c) ...
2534 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
2537 struct IdList_item
{
2538 char *zName
; /* Name of the identifier */
2539 int idx
; /* Index in some Table.aCol[] of a column named zName */
2541 int nId
; /* Number of identifiers on the list */
2545 ** The bitmask datatype defined below is used for various optimizations.
2547 ** Changing this from a 64-bit to a 32-bit type limits the number of
2548 ** tables in a join to 32 instead of 64. But it also reduces the size
2549 ** of the library by 738 bytes on ix86.
2551 #ifdef SQLITE_BITMASK_TYPE
2552 typedef SQLITE_BITMASK_TYPE Bitmask
;
2554 typedef u64 Bitmask
;
2558 ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
2560 #define BMS ((int)(sizeof(Bitmask)*8))
2563 ** A bit in a Bitmask
2565 #define MASKBIT(n) (((Bitmask)1)<<(n))
2566 #define MASKBIT32(n) (((unsigned int)1)<<(n))
2567 #define ALLBITS ((Bitmask)-1)
2570 ** The following structure describes the FROM clause of a SELECT statement.
2571 ** Each table or subquery in the FROM clause is a separate element of
2572 ** the SrcList.a[] array.
2574 ** With the addition of multiple database support, the following structure
2575 ** can also be used to describe a particular table such as the table that
2576 ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
2577 ** such a table must be a simple name: ID. But in SQLite, the table can
2578 ** now be identified by a database name, a dot, then the table name: ID.ID.
2580 ** The jointype starts out showing the join type between the current table
2581 ** and the next table on the list. The parser builds the list this way.
2582 ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
2583 ** jointype expresses the join between the table and the previous table.
2585 ** In the colUsed field, the high-order bit (bit 63) is set if the table
2586 ** contains more than 63 columns and the 64-th or later column is used.
2589 int nSrc
; /* Number of tables or subqueries in the FROM clause */
2590 u32 nAlloc
; /* Number of entries allocated in a[] below */
2591 struct SrcList_item
{
2592 Schema
*pSchema
; /* Schema to which this item is fixed */
2593 char *zDatabase
; /* Name of database holding this table */
2594 char *zName
; /* Name of the table */
2595 char *zAlias
; /* The "B" part of a "A AS B" phrase. zName is the "A" */
2596 Table
*pTab
; /* An SQL table corresponding to zName */
2597 Select
*pSelect
; /* A SELECT statement used in place of a table name */
2598 int addrFillSub
; /* Address of subroutine to manifest a subquery */
2599 int regReturn
; /* Register holding return address of addrFillSub */
2600 int regResult
; /* Registers holding results of a co-routine */
2602 u8 jointype
; /* Type of join between this table and the previous */
2603 unsigned notIndexed
:1; /* True if there is a NOT INDEXED clause */
2604 unsigned isIndexedBy
:1; /* True if there is an INDEXED BY clause */
2605 unsigned isTabFunc
:1; /* True if table-valued-function syntax */
2606 unsigned isCorrelated
:1; /* True if sub-query is correlated */
2607 unsigned viaCoroutine
:1; /* Implemented as a co-routine */
2608 unsigned isRecursive
:1; /* True for recursive reference in WITH */
2610 #ifndef SQLITE_OMIT_EXPLAIN
2611 u8 iSelectId
; /* If pSelect!=0, the id of the sub-select in EQP */
2613 int iCursor
; /* The VDBE cursor number used to access this table */
2614 Expr
*pOn
; /* The ON clause of a join */
2615 IdList
*pUsing
; /* The USING clause of a join */
2616 Bitmask colUsed
; /* Bit N (1<<N) set if column N of pTab is used */
2618 char *zIndexedBy
; /* Identifier from "INDEXED BY <zIndex>" clause */
2619 ExprList
*pFuncArg
; /* Arguments to table-valued-function */
2621 Index
*pIBIndex
; /* Index structure corresponding to u1.zIndexedBy */
2622 } a
[1]; /* One entry for each identifier on the list */
2626 ** Permitted values of the SrcList.a.jointype field
2628 #define JT_INNER 0x0001 /* Any kind of inner or cross join */
2629 #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
2630 #define JT_NATURAL 0x0004 /* True for a "natural" join */
2631 #define JT_LEFT 0x0008 /* Left outer join */
2632 #define JT_RIGHT 0x0010 /* Right outer join */
2633 #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
2634 #define JT_ERROR 0x0040 /* unknown or unsupported join type */
2638 ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
2639 ** and the WhereInfo.wctrlFlags member.
2641 ** Value constraints (enforced via assert()):
2642 ** WHERE_USE_LIMIT == SF_FixedLimit
2644 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
2645 #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
2646 #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
2647 #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
2648 #define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
2649 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
2650 #define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
2651 ** the OR optimization */
2652 #define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */
2653 #define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */
2654 #define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */
2655 #define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
2656 #define WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */
2657 #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
2658 #define WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */
2659 /* 0x2000 not currently used */
2660 #define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
2661 /* 0x8000 not currently used */
2663 /* Allowed return values from sqlite3WhereIsDistinct()
2665 #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
2666 #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */
2667 #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */
2668 #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */
2671 ** A NameContext defines a context in which to resolve table and column
2672 ** names. The context consists of a list of tables (the pSrcList) field and
2673 ** a list of named expression (pEList). The named expression list may
2674 ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
2675 ** to the table being operated on by INSERT, UPDATE, or DELETE. The
2676 ** pEList corresponds to the result set of a SELECT and is NULL for
2677 ** other statements.
2679 ** NameContexts can be nested. When resolving names, the inner-most
2680 ** context is searched first. If no match is found, the next outer
2681 ** context is checked. If there is still no match, the next context
2682 ** is checked. This process continues until either a match is found
2683 ** or all contexts are check. When a match is found, the nRef member of
2684 ** the context containing the match is incremented.
2686 ** Each subquery gets a new NameContext. The pNext field points to the
2687 ** NameContext in the parent query. Thus the process of scanning the
2688 ** NameContext list corresponds to searching through successively outer
2689 ** subqueries looking for a match.
2691 struct NameContext
{
2692 Parse
*pParse
; /* The parser */
2693 SrcList
*pSrcList
; /* One or more tables used to resolve names */
2695 ExprList
*pEList
; /* Optional list of result-set columns */
2696 AggInfo
*pAggInfo
; /* Information about aggregates at this level */
2697 Upsert
*pUpsert
; /* ON CONFLICT clause information from an upsert */
2699 NameContext
*pNext
; /* Next outer name context. NULL for outermost */
2700 int nRef
; /* Number of names resolved by this context */
2701 int nErr
; /* Number of errors encountered while resolving names */
2702 u16 ncFlags
; /* Zero or more NC_* flags defined below */
2706 ** Allowed values for the NameContext, ncFlags field.
2708 ** Value constraints (all checked via assert()):
2709 ** NC_HasAgg == SF_HasAgg
2710 ** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
2713 #define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */
2714 #define NC_PartIdx 0x0002 /* True if resolving a partial index WHERE */
2715 #define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */
2716 #define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */
2717 #define NC_HasAgg 0x0010 /* One or more aggregate functions seen */
2718 #define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */
2719 #define NC_VarSelect 0x0040 /* A correlated subquery has been seen */
2720 #define NC_UEList 0x0080 /* True if uNC.pEList is used */
2721 #define NC_UAggInfo 0x0100 /* True if uNC.pAggInfo is used */
2722 #define NC_UUpsert 0x0200 /* True if uNC.pUpsert is used */
2723 #define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */
2724 #define NC_Complex 0x2000 /* True if a function or subquery seen */
2727 ** An instance of the following object describes a single ON CONFLICT
2728 ** clause in an upsert.
2730 ** The pUpsertTarget field is only set if the ON CONFLICT clause includes
2731 ** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the
2732 ** conflict-target clause.) The pUpsertTargetWhere is the optional
2733 ** WHERE clause used to identify partial unique indexes.
2735 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
2736 ** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING. The
2737 ** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the
2738 ** WHERE clause is omitted.
2741 ExprList
*pUpsertTarget
; /* Optional description of conflicting index */
2742 Expr
*pUpsertTargetWhere
; /* WHERE clause for partial index targets */
2743 Index
*pUpsertIdx
; /* Constraint that pUpsertTarget identifies */
2744 ExprList
*pUpsertSet
; /* The SET clause from an ON CONFLICT UPDATE */
2745 Expr
*pUpsertWhere
; /* WHERE clause for the ON CONFLICT UPDATE */
2746 /* The fields above comprise the parse tree for the upsert clause.
2747 ** The fields below are used to transfer information from the INSERT
2748 ** processing down into the UPDATE processing while generating code.
2749 ** Upsert owns the memory allocated above, but not the memory below. */
2750 SrcList
*pUpsertSrc
; /* Table to be updated */
2751 int regData
; /* First register holding array of VALUES */
2752 int iDataCur
; /* Index of the data cursor */
2753 int iIdxCur
; /* Index of the first index cursor */
2757 ** An instance of the following structure contains all information
2758 ** needed to generate code for a single SELECT statement.
2760 ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
2761 ** If there is a LIMIT clause, the parser sets nLimit to the value of the
2762 ** limit and nOffset to the value of the offset (or 0 if there is not
2763 ** offset). But later on, nLimit and nOffset become the memory locations
2764 ** in the VDBE that record the limit and offset counters.
2766 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
2767 ** These addresses must be stored so that we can go back and fill in
2768 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
2769 ** the number of columns in P2 can be computed at the same time
2770 ** as the OP_OpenEphm instruction is coded because not
2771 ** enough information about the compound query is known at that point.
2772 ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
2773 ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
2774 ** sequences for the ORDER BY clause.
2777 ExprList
*pEList
; /* The fields of the result */
2778 u8 op
; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
2779 LogEst nSelectRow
; /* Estimated number of result rows */
2780 u32 selFlags
; /* Various SF_* values */
2781 int iLimit
, iOffset
; /* Memory registers holding LIMIT & OFFSET counters */
2782 #if SELECTTRACE_ENABLED
2783 char zSelName
[12]; /* Symbolic name of this SELECT use for debugging */
2785 int addrOpenEphm
[2]; /* OP_OpenEphem opcodes related to this select */
2786 SrcList
*pSrc
; /* The FROM clause */
2787 Expr
*pWhere
; /* The WHERE clause */
2788 ExprList
*pGroupBy
; /* The GROUP BY clause */
2789 Expr
*pHaving
; /* The HAVING clause */
2790 ExprList
*pOrderBy
; /* The ORDER BY clause */
2791 Select
*pPrior
; /* Prior select in a compound select statement */
2792 Select
*pNext
; /* Next select to the left in a compound */
2793 Expr
*pLimit
; /* LIMIT expression. NULL means not used. */
2794 With
*pWith
; /* WITH clause attached to this select. Or NULL. */
2798 ** Allowed values for Select.selFlags. The "SF" prefix stands for
2801 ** Value constraints (all checked via assert())
2802 ** SF_HasAgg == NC_HasAgg
2803 ** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX
2804 ** SF_FixedLimit == WHERE_USE_LIMIT
2806 #define SF_Distinct 0x00001 /* Output should be DISTINCT */
2807 #define SF_All 0x00002 /* Includes the ALL keyword */
2808 #define SF_Resolved 0x00004 /* Identifiers have been resolved */
2809 #define SF_Aggregate 0x00008 /* Contains agg functions or a GROUP BY */
2810 #define SF_HasAgg 0x00010 /* Contains aggregate functions */
2811 #define SF_UsesEphemeral 0x00020 /* Uses the OpenEphemeral opcode */
2812 #define SF_Expanded 0x00040 /* sqlite3SelectExpand() called on this */
2813 #define SF_HasTypeInfo 0x00080 /* FROM subqueries have Table metadata */
2814 #define SF_Compound 0x00100 /* Part of a compound query */
2815 #define SF_Values 0x00200 /* Synthesized from VALUES clause */
2816 #define SF_MultiValue 0x00400 /* Single VALUES term with multiple rows */
2817 #define SF_NestedFrom 0x00800 /* Part of a parenthesized FROM clause */
2818 #define SF_MinMaxAgg 0x01000 /* Aggregate containing min() or max() */
2819 #define SF_Recursive 0x02000 /* The recursive part of a recursive CTE */
2820 #define SF_FixedLimit 0x04000 /* nSelectRow set by a constant LIMIT */
2821 #define SF_MaybeConvert 0x08000 /* Need convertCompoundSelectToSubquery() */
2822 #define SF_Converted 0x10000 /* By convertCompoundSelectToSubquery() */
2823 #define SF_IncludeHidden 0x20000 /* Include hidden columns in output */
2824 #define SF_ComplexResult 0x40000 /* Result set contains subquery or function */
2828 ** The results of a SELECT can be distributed in several ways, as defined
2829 ** by one of the following macros. The "SRT" prefix means "SELECT Result
2832 ** SRT_Union Store results as a key in a temporary index
2833 ** identified by pDest->iSDParm.
2835 ** SRT_Except Remove results from the temporary index pDest->iSDParm.
2837 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
2838 ** set is not empty.
2840 ** SRT_Discard Throw the results away. This is used by SELECT
2841 ** statements within triggers whose only purpose is
2842 ** the side-effects of functions.
2844 ** All of the above are free to ignore their ORDER BY clause. Those that
2845 ** follow must honor the ORDER BY clause.
2847 ** SRT_Output Generate a row of output (using the OP_ResultRow
2848 ** opcode) for each row in the result set.
2850 ** SRT_Mem Only valid if the result is a single column.
2851 ** Store the first column of the first result row
2852 ** in register pDest->iSDParm then abandon the rest
2853 ** of the query. This destination implies "LIMIT 1".
2855 ** SRT_Set The result must be a single column. Store each
2856 ** row of result as the key in table pDest->iSDParm.
2857 ** Apply the affinity pDest->affSdst before storing
2858 ** results. Used to implement "IN (SELECT ...)".
2860 ** SRT_EphemTab Create an temporary table pDest->iSDParm and store
2861 ** the result there. The cursor is left open after
2862 ** returning. This is like SRT_Table except that
2863 ** this destination uses OP_OpenEphemeral to create
2866 ** SRT_Coroutine Generate a co-routine that returns a new row of
2867 ** results each time it is invoked. The entry point
2868 ** of the co-routine is stored in register pDest->iSDParm
2869 ** and the result row is stored in pDest->nDest registers
2870 ** starting with pDest->iSdst.
2872 ** SRT_Table Store results in temporary table pDest->iSDParm.
2873 ** SRT_Fifo This is like SRT_EphemTab except that the table
2874 ** is assumed to already be open. SRT_Fifo has
2875 ** the additional property of being able to ignore
2876 ** the ORDER BY clause.
2878 ** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
2879 ** But also use temporary table pDest->iSDParm+1 as
2880 ** a record of all prior results and ignore any duplicate
2881 ** rows. Name means: "Distinct Fifo".
2883 ** SRT_Queue Store results in priority queue pDest->iSDParm (really
2884 ** an index). Append a sequence number so that all entries
2887 ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
2888 ** the same record has never been stored before. The
2889 ** index at pDest->iSDParm+1 hold all prior stores.
2891 #define SRT_Union 1 /* Store result as keys in an index */
2892 #define SRT_Except 2 /* Remove result from a UNION index */
2893 #define SRT_Exists 3 /* Store 1 if the result is not empty */
2894 #define SRT_Discard 4 /* Do not save the results anywhere */
2895 #define SRT_Fifo 5 /* Store result as data with an automatic rowid */
2896 #define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */
2897 #define SRT_Queue 7 /* Store result in an queue */
2898 #define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */
2900 /* The ORDER BY clause is ignored for all of the above */
2901 #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)
2903 #define SRT_Output 9 /* Output each row of result */
2904 #define SRT_Mem 10 /* Store result in a memory cell */
2905 #define SRT_Set 11 /* Store results as keys in an index */
2906 #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */
2907 #define SRT_Coroutine 13 /* Generate a single row of result */
2908 #define SRT_Table 14 /* Store result as data with an automatic rowid */
2911 ** An instance of this object describes where to put of the results of
2912 ** a SELECT statement.
2915 u8 eDest
; /* How to dispose of the results. On of SRT_* above. */
2916 int iSDParm
; /* A parameter used by the eDest disposal method */
2917 int iSdst
; /* Base register where results are written */
2918 int nSdst
; /* Number of registers allocated */
2919 char *zAffSdst
; /* Affinity used when eDest==SRT_Set */
2920 ExprList
*pOrderBy
; /* Key columns for SRT_Queue and SRT_DistQueue */
2924 ** During code generation of statements that do inserts into AUTOINCREMENT
2925 ** tables, the following information is attached to the Table.u.autoInc.p
2926 ** pointer of each autoincrement table to record some side information that
2927 ** the code generator needs. We have to keep per-table autoincrement
2928 ** information in case inserts are done within triggers. Triggers do not
2929 ** normally coordinate their activities, but we do need to coordinate the
2930 ** loading and saving of autoincrement information.
2932 struct AutoincInfo
{
2933 AutoincInfo
*pNext
; /* Next info block in a list of them all */
2934 Table
*pTab
; /* Table this info block refers to */
2935 int iDb
; /* Index in sqlite3.aDb[] of database holding pTab */
2936 int regCtr
; /* Memory register holding the rowid counter */
2940 ** Size of the column cache
2942 #ifndef SQLITE_N_COLCACHE
2943 # define SQLITE_N_COLCACHE 10
2947 ** At least one instance of the following structure is created for each
2948 ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
2949 ** statement. All such objects are stored in the linked list headed at
2950 ** Parse.pTriggerPrg and deleted once statement compilation has been
2953 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
2954 ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
2955 ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
2956 ** The Parse.pTriggerPrg list never contains two entries with the same
2957 ** values for both pTrigger and orconf.
2959 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
2960 ** accessed (or set to 0 for triggers fired as a result of INSERT
2961 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
2962 ** a mask of new.* columns used by the program.
2965 Trigger
*pTrigger
; /* Trigger this program was coded from */
2966 TriggerPrg
*pNext
; /* Next entry in Parse.pTriggerPrg list */
2967 SubProgram
*pProgram
; /* Program implementing pTrigger/orconf */
2968 int orconf
; /* Default ON CONFLICT policy */
2969 u32 aColmask
[2]; /* Masks of old.*, new.* columns accessed */
2973 ** The yDbMask datatype for the bitmask of all attached databases.
2975 #if SQLITE_MAX_ATTACHED>30
2976 typedef unsigned char yDbMask
[(SQLITE_MAX_ATTACHED
+9)/8];
2977 # define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0)
2978 # define DbMaskZero(M) memset((M),0,sizeof(M))
2979 # define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7))
2980 # define DbMaskAllZero(M) sqlite3DbMaskAllZero(M)
2981 # define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0)
2983 typedef unsigned int yDbMask
;
2984 # define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0)
2985 # define DbMaskZero(M) (M)=0
2986 # define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I))
2987 # define DbMaskAllZero(M) (M)==0
2988 # define DbMaskNonZero(M) (M)!=0
2992 ** An SQL parser context. A copy of this structure is passed through
2993 ** the parser and down into all the parser action routine in order to
2994 ** carry around information that is global to the entire parse.
2996 ** The structure is divided into two parts. When the parser and code
2997 ** generate call themselves recursively, the first part of the structure
2998 ** is constant but the second part is reset at the beginning and end of
3001 ** The nTableLock and aTableLock variables are only used if the shared-cache
3002 ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
3003 ** used to store the set of table-locks required by the statement being
3004 ** compiled. Function sqlite3TableLock() is used to add entries to the
3008 sqlite3
*db
; /* The main database structure */
3009 char *zErrMsg
; /* An error message */
3010 Vdbe
*pVdbe
; /* An engine for executing database bytecode */
3011 int rc
; /* Return code from execution */
3012 u8 colNamesSet
; /* TRUE after OP_ColumnName has been issued to pVdbe */
3013 u8 checkSchema
; /* Causes schema cookie check after an error */
3014 u8 nested
; /* Number of nested calls to the parser/code generator */
3015 u8 nTempReg
; /* Number of temporary registers in aTempReg[] */
3016 u8 isMultiWrite
; /* True if statement may modify/insert multiple rows */
3017 u8 mayAbort
; /* True if statement may throw an ABORT exception */
3018 u8 hasCompound
; /* Need to invoke convertCompoundSelectToSubquery() */
3019 u8 okConstFactor
; /* OK to factor out constants */
3020 u8 disableLookaside
; /* Number of times lookaside has been disabled */
3021 u8 nColCache
; /* Number of entries in aColCache[] */
3022 int nRangeReg
; /* Size of the temporary register block */
3023 int iRangeReg
; /* First register in temporary register block */
3024 int nErr
; /* Number of errors seen */
3025 int nTab
; /* Number of previously allocated VDBE cursors */
3026 int nMem
; /* Number of memory cells used so far */
3027 int nOpAlloc
; /* Number of slots allocated for Vdbe.aOp[] */
3028 int szOpAlloc
; /* Bytes of memory space allocated for Vdbe.aOp[] */
3029 int iSelfTab
; /* Table associated with an index on expr, or negative
3030 ** of the base register during check-constraint eval */
3031 int iCacheLevel
; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
3032 int iCacheCnt
; /* Counter used to generate aColCache[].lru values */
3033 int nLabel
; /* Number of labels used */
3034 int *aLabel
; /* Space to hold the labels */
3035 ExprList
*pConstExpr
;/* Constant expressions */
3036 Token constraintName
;/* Name of the constraint currently being parsed */
3037 yDbMask writeMask
; /* Start a write transaction on these databases */
3038 yDbMask cookieMask
; /* Bitmask of schema verified databases */
3039 int regRowid
; /* Register holding rowid of CREATE TABLE entry */
3040 int regRoot
; /* Register holding root page number for new objects */
3041 int nMaxArg
; /* Max args passed to user function by sub-program */
3042 #if SELECTTRACE_ENABLED
3043 int nSelect
; /* Number of SELECT statements seen */
3045 #ifndef SQLITE_OMIT_SHARED_CACHE
3046 int nTableLock
; /* Number of locks in aTableLock */
3047 TableLock
*aTableLock
; /* Required table locks for shared-cache mode */
3049 AutoincInfo
*pAinc
; /* Information about AUTOINCREMENT counters */
3050 Parse
*pToplevel
; /* Parse structure for main program (or NULL) */
3051 Table
*pTriggerTab
; /* Table triggers are being coded for */
3052 int addrCrTab
; /* Address of OP_CreateBtree opcode on CREATE TABLE */
3053 u32 nQueryLoop
; /* Est number of iterations of a query (10*log2(N)) */
3054 u32 oldmask
; /* Mask of old.* columns referenced */
3055 u32 newmask
; /* Mask of new.* columns referenced */
3056 u8 eTriggerOp
; /* TK_UPDATE, TK_INSERT or TK_DELETE */
3057 u8 eOrconf
; /* Default ON CONFLICT policy for trigger steps */
3058 u8 disableTriggers
; /* True to disable triggers */
3060 /**************************************************************************
3061 ** Fields above must be initialized to zero. The fields that follow,
3062 ** down to the beginning of the recursive section, do not need to be
3063 ** initialized as they will be set before being used. The boundary is
3064 ** determined by offsetof(Parse,aColCache).
3065 **************************************************************************/
3068 int iTable
; /* Table cursor number */
3069 i16 iColumn
; /* Table column number */
3070 u8 tempReg
; /* iReg is a temp register that needs to be freed */
3071 int iLevel
; /* Nesting level */
3072 int iReg
; /* Reg with value of this column. 0 means none. */
3073 int lru
; /* Least recently used entry has the smallest value */
3074 } aColCache
[SQLITE_N_COLCACHE
]; /* One for each column cache entry */
3075 int aTempReg
[8]; /* Holding area for temporary registers */
3076 Token sNameToken
; /* Token with unqualified schema object name */
3078 /************************************************************************
3079 ** Above is constant between recursions. Below is reset before and after
3080 ** each recursion. The boundary between these two regions is determined
3081 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
3082 ** first field in the recursive region.
3083 ************************************************************************/
3085 Token sLastToken
; /* The last token parsed */
3086 ynVar nVar
; /* Number of '?' variables seen in the SQL so far */
3087 u8 iPkSortOrder
; /* ASC or DESC for INTEGER PRIMARY KEY */
3088 u8 explain
; /* True if the EXPLAIN flag is found on the query */
3089 #ifndef SQLITE_OMIT_VIRTUALTABLE
3090 u8 declareVtab
; /* True if inside sqlite3_declare_vtab() */
3091 int nVtabLock
; /* Number of virtual tables to lock */
3093 int nHeight
; /* Expression tree height of current sub-select */
3094 #ifndef SQLITE_OMIT_EXPLAIN
3095 int iSelectId
; /* ID of current select for EXPLAIN output */
3096 int iNextSelectId
; /* Next available select ID for EXPLAIN output */
3098 VList
*pVList
; /* Mapping between variable names and numbers */
3099 Vdbe
*pReprepare
; /* VM being reprepared (sqlite3Reprepare()) */
3100 const char *zTail
; /* All SQL text past the last semicolon parsed */
3101 Table
*pNewTable
; /* A table being constructed by CREATE TABLE */
3102 Trigger
*pNewTrigger
; /* Trigger under construct by a CREATE TRIGGER */
3103 const char *zAuthContext
; /* The 6th parameter to db->xAuth callbacks */
3104 #ifndef SQLITE_OMIT_VIRTUALTABLE
3105 Token sArg
; /* Complete text of a module argument */
3106 Table
**apVtabLock
; /* Pointer to virtual tables needing locking */
3108 Table
*pZombieTab
; /* List of Table objects to delete after code gen */
3109 TriggerPrg
*pTriggerPrg
; /* Linked list of coded triggers */
3110 With
*pWith
; /* Current WITH clause, or NULL */
3111 With
*pWithToFree
; /* Free this WITH object at the end of the parse */
3115 ** Sizes and pointers of various parts of the Parse object.
3117 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
3118 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
3119 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
3120 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
3123 ** Return true if currently inside an sqlite3_declare_vtab() call.
3125 #ifdef SQLITE_OMIT_VIRTUALTABLE
3126 #define IN_DECLARE_VTAB 0
3128 #define IN_DECLARE_VTAB (pParse->declareVtab)
3132 ** An instance of the following structure can be declared on a stack and used
3133 ** to save the Parse.zAuthContext value so that it can be restored later.
3135 struct AuthContext
{
3136 const char *zAuthContext
; /* Put saved Parse.zAuthContext here */
3137 Parse
*pParse
; /* The Parse structure */
3141 ** Bitfield flags for P5 value in various opcodes.
3143 ** Value constraints (enforced via assert()):
3144 ** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH
3145 ** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF
3146 ** OPFLAG_BULKCSR == BTREE_BULKLOAD
3147 ** OPFLAG_SEEKEQ == BTREE_SEEK_EQ
3148 ** OPFLAG_FORDELETE == BTREE_FORDELETE
3149 ** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
3150 ** OPFLAG_AUXDELETE == BTREE_AUXDELETE
3152 #define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
3153 /* Also used in P2 (not P5) of OP_Delete */
3154 #define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
3155 #define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
3156 #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
3157 #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
3158 #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
3159 #define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
3160 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
3161 #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
3162 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
3163 #define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
3164 #define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
3165 #define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
3166 #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
3167 #define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */
3168 #define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */
3169 #define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */
3172 * Each trigger present in the database schema is stored as an instance of
3175 * Pointers to instances of struct Trigger are stored in two ways.
3176 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
3177 * database). This allows Trigger structures to be retrieved by name.
3178 * 2. All triggers associated with a single table form a linked list, using the
3179 * pNext member of struct Trigger. A pointer to the first element of the
3180 * linked list is stored as the "pTrigger" member of the associated
3183 * The "step_list" member points to the first element of a linked list
3184 * containing the SQL statements specified as the trigger program.
3187 char *zName
; /* The name of the trigger */
3188 char *table
; /* The table or view to which the trigger applies */
3189 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
3190 u8 tr_tm
; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
3191 Expr
*pWhen
; /* The WHEN clause of the expression (may be NULL) */
3192 IdList
*pColumns
; /* If this is an UPDATE OF <column-list> trigger,
3193 the <column-list> is stored here */
3194 Schema
*pSchema
; /* Schema containing the trigger */
3195 Schema
*pTabSchema
; /* Schema containing the table */
3196 TriggerStep
*step_list
; /* Link list of trigger program steps */
3197 Trigger
*pNext
; /* Next trigger associated with the table */
3201 ** A trigger is either a BEFORE or an AFTER trigger. The following constants
3204 ** If there are multiple triggers, you might of some BEFORE and some AFTER.
3205 ** In that cases, the constants below can be ORed together.
3207 #define TRIGGER_BEFORE 1
3208 #define TRIGGER_AFTER 2
3211 * An instance of struct TriggerStep is used to store a single SQL statement
3212 * that is a part of a trigger-program.
3214 * Instances of struct TriggerStep are stored in a singly linked list (linked
3215 * using the "pNext" member) referenced by the "step_list" member of the
3216 * associated struct Trigger instance. The first element of the linked list is
3217 * the first step of the trigger-program.
3219 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
3220 * "SELECT" statement. The meanings of the other members is determined by the
3221 * value of "op" as follows:
3224 * orconf -> stores the ON CONFLICT algorithm
3225 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
3226 * this stores a pointer to the SELECT statement. Otherwise NULL.
3227 * zTarget -> Dequoted name of the table to insert into.
3228 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
3229 * this stores values to be inserted. Otherwise NULL.
3230 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
3231 * statement, then this stores the column-names to be
3235 * zTarget -> Dequoted name of the table to delete from.
3236 * pWhere -> The WHERE clause of the DELETE statement if one is specified.
3240 * zTarget -> Dequoted name of the table to update.
3241 * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
3243 * pExprList -> A list of the columns to update and the expressions to update
3244 * them to. See sqlite3Update() documentation of "pChanges"
3248 struct TriggerStep
{
3249 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
3250 u8 orconf
; /* OE_Rollback etc. */
3251 Trigger
*pTrig
; /* The trigger that this step is a part of */
3252 Select
*pSelect
; /* SELECT statement or RHS of INSERT INTO SELECT ... */
3253 char *zTarget
; /* Target table for DELETE, UPDATE, INSERT */
3254 Expr
*pWhere
; /* The WHERE clause for DELETE or UPDATE steps */
3255 ExprList
*pExprList
; /* SET clause for UPDATE */
3256 IdList
*pIdList
; /* Column names for INSERT */
3257 Upsert
*pUpsert
; /* Upsert clauses on an INSERT */
3258 char *zSpan
; /* Original SQL text of this command */
3259 TriggerStep
*pNext
; /* Next in the link-list */
3260 TriggerStep
*pLast
; /* Last element in link-list. Valid for 1st elem only */
3264 ** The following structure contains information used by the sqliteFix...
3265 ** routines as they walk the parse tree to make database references
3268 typedef struct DbFixer DbFixer
;
3270 Parse
*pParse
; /* The parsing context. Error messages written here */
3271 Schema
*pSchema
; /* Fix items to this schema */
3272 int bVarOnly
; /* Check for variable references only */
3273 const char *zDb
; /* Make sure all objects are contained in this database */
3274 const char *zType
; /* Type of the container - used for error messages */
3275 const Token
*pName
; /* Name of the container - used for error messages */
3279 ** An objected used to accumulate the text of a string where we
3280 ** do not necessarily know how big the string will be in the end.
3283 sqlite3
*db
; /* Optional database for lookaside. Can be NULL */
3284 char *zText
; /* The string collected so far */
3285 u32 nAlloc
; /* Amount of space allocated in zText */
3286 u32 mxAlloc
; /* Maximum allowed allocation. 0 for no malloc usage */
3287 u32 nChar
; /* Length of the string so far */
3288 u8 accError
; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
3289 u8 printfFlags
; /* SQLITE_PRINTF flags below */
3291 #define STRACCUM_NOMEM 1
3292 #define STRACCUM_TOOBIG 2
3293 #define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
3294 #define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */
3295 #define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */
3297 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
3301 ** A pointer to this structure is used to communicate information
3302 ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
3305 sqlite3
*db
; /* The database being initialized */
3306 char **pzErrMsg
; /* Error message stored here */
3307 int iDb
; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
3308 int rc
; /* Result code stored here */
3312 ** Structure containing global configuration data for the SQLite library.
3314 ** This structure also contains some state information.
3316 struct Sqlite3Config
{
3317 int bMemstat
; /* True to enable memory status */
3318 int bCoreMutex
; /* True to enable core mutexing */
3319 int bFullMutex
; /* True to enable full mutexing */
3320 int bOpenUri
; /* True to interpret filenames as URIs */
3321 int bUseCis
; /* Use covering indices for full-scans */
3322 int bSmallMalloc
; /* Avoid large memory allocations if true */
3323 int mxStrlen
; /* Maximum string length */
3324 int neverCorrupt
; /* Database is always well-formed */
3325 int szLookaside
; /* Default lookaside buffer size */
3326 int nLookaside
; /* Default lookaside buffer count */
3327 int nStmtSpill
; /* Stmt-journal spill-to-disk threshold */
3328 sqlite3_mem_methods m
; /* Low-level memory allocation interface */
3329 sqlite3_mutex_methods mutex
; /* Low-level mutex interface */
3330 sqlite3_pcache_methods2 pcache2
; /* Low-level page-cache interface */
3331 void *pHeap
; /* Heap storage space */
3332 int nHeap
; /* Size of pHeap[] */
3333 int mnReq
, mxReq
; /* Min and max heap requests sizes */
3334 sqlite3_int64 szMmap
; /* mmap() space per open file */
3335 sqlite3_int64 mxMmap
; /* Maximum value for szMmap */
3336 void *pPage
; /* Page cache memory */
3337 int szPage
; /* Size of each page in pPage[] */
3338 int nPage
; /* Number of pages in pPage[] */
3339 int mxParserStack
; /* maximum depth of the parser stack */
3340 int sharedCacheEnabled
; /* true if shared-cache mode enabled */
3341 u32 szPma
; /* Maximum Sorter PMA size */
3342 /* The above might be initialized to non-zero. The following need to always
3343 ** initially be zero, however. */
3344 int isInit
; /* True after initialization has finished */
3345 int inProgress
; /* True while initialization in progress */
3346 int isMutexInit
; /* True after mutexes are initialized */
3347 int isMallocInit
; /* True after malloc is initialized */
3348 int isPCacheInit
; /* True after malloc is initialized */
3349 int nRefInitMutex
; /* Number of users of pInitMutex */
3350 sqlite3_mutex
*pInitMutex
; /* Mutex used by sqlite3_initialize() */
3351 void (*xLog
)(void*,int,const char*); /* Function for logging */
3352 void *pLogArg
; /* First argument to xLog() */
3353 #ifdef SQLITE_ENABLE_SQLLOG
3354 void(*xSqllog
)(void*,sqlite3
*,const char*, int);
3357 #ifdef SQLITE_VDBE_COVERAGE
3358 /* The following callback (if not NULL) is invoked on every VDBE branch
3359 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
3361 void (*xVdbeBranch
)(void*,int iSrcLine
,u8 eThis
,u8 eMx
); /* Callback */
3362 void *pVdbeBranchArg
; /* 1st argument */
3364 #ifndef SQLITE_UNTESTABLE
3365 int (*xTestCallback
)(int); /* Invoked by sqlite3FaultSim() */
3367 int bLocaltimeFault
; /* True to fail localtime() calls */
3368 int iOnceResetThreshold
; /* When to reset OP_Once counters */
3369 u32 szSorterRef
; /* Min size in bytes to use sorter-refs */
3373 ** This macro is used inside of assert() statements to indicate that
3374 ** the assert is only valid on a well-formed database. Instead of:
3380 ** assert( X || CORRUPT_DB );
3382 ** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate
3383 ** that the database is definitely corrupt, only that it might be corrupt.
3384 ** For most test cases, CORRUPT_DB is set to false using a special
3385 ** sqlite3_test_control(). This enables assert() statements to prove
3386 ** things that are always true for well-formed databases.
3388 #define CORRUPT_DB (sqlite3Config.neverCorrupt==0)
3391 ** Context pointer passed down through the tree-walk.
3394 Parse
*pParse
; /* Parser context. */
3395 int (*xExprCallback
)(Walker
*, Expr
*); /* Callback for expressions */
3396 int (*xSelectCallback
)(Walker
*,Select
*); /* Callback for SELECTs */
3397 void (*xSelectCallback2
)(Walker
*,Select
*);/* Second callback for SELECTs */
3398 int walkerDepth
; /* Number of subqueries */
3399 u8 eCode
; /* A small processing code */
3400 union { /* Extra data for callback */
3401 NameContext
*pNC
; /* Naming context */
3402 int n
; /* A counter */
3403 int iCur
; /* A cursor number */
3404 SrcList
*pSrcList
; /* FROM clause */
3405 struct SrcCount
*pSrcCount
; /* Counting column references */
3406 struct CCurHint
*pCCurHint
; /* Used by codeCursorHint() */
3407 int *aiCol
; /* array of column indexes */
3408 struct IdxCover
*pIdxCover
; /* Check for index coverage */
3409 struct IdxExprTrans
*pIdxTrans
; /* Convert idxed expr to column */
3410 ExprList
*pGroupBy
; /* GROUP BY clause */
3411 Select
*pSelect
; /* HAVING to WHERE clause ctx */
3415 /* Forward declarations */
3416 int sqlite3WalkExpr(Walker
*, Expr
*);
3417 int sqlite3WalkExprList(Walker
*, ExprList
*);
3418 int sqlite3WalkSelect(Walker
*, Select
*);
3419 int sqlite3WalkSelectExpr(Walker
*, Select
*);
3420 int sqlite3WalkSelectFrom(Walker
*, Select
*);
3421 int sqlite3ExprWalkNoop(Walker
*, Expr
*);
3422 int sqlite3SelectWalkNoop(Walker
*, Select
*);
3423 int sqlite3SelectWalkFail(Walker
*, Select
*);
3425 void sqlite3SelectWalkAssert2(Walker
*, Select
*);
3429 ** Return code from the parse-tree walking primitives and their
3432 #define WRC_Continue 0 /* Continue down into children */
3433 #define WRC_Prune 1 /* Omit children but continue walking siblings */
3434 #define WRC_Abort 2 /* Abandon the tree walk */
3437 ** An instance of this structure represents a set of one or more CTEs
3438 ** (common table expressions) created by a single WITH clause.
3441 int nCte
; /* Number of CTEs in the WITH clause */
3442 With
*pOuter
; /* Containing WITH clause, or NULL */
3443 struct Cte
{ /* For each CTE in the WITH clause.... */
3444 char *zName
; /* Name of this CTE */
3445 ExprList
*pCols
; /* List of explicit column names, or NULL */
3446 Select
*pSelect
; /* The definition of this CTE */
3447 const char *zCteErr
; /* Error message for circular references */
3453 ** An instance of the TreeView object is used for printing the content of
3454 ** data structures on sqlite3DebugPrintf() using a tree-like view.
3457 int iLevel
; /* Which level of the tree we are on */
3458 u8 bLine
[100]; /* Draw vertical in column i if bLine[i] is true */
3460 #endif /* SQLITE_DEBUG */
3463 ** Assuming zIn points to the first byte of a UTF-8 character,
3464 ** advance zIn to point to the first byte of the next UTF-8 character.
3466 #define SQLITE_SKIP_UTF8(zIn) { \
3467 if( (*(zIn++))>=0xc0 ){ \
3468 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
3473 ** The SQLITE_*_BKPT macros are substitutes for the error codes with
3474 ** the same name but without the _BKPT suffix. These macros invoke
3475 ** routines that report the line-number on which the error originated
3476 ** using sqlite3_log(). The routines also provide a convenient place
3477 ** to set a debugger breakpoint.
3479 int sqlite3ReportError(int iErr
, int lineno
, const char *zType
);
3480 int sqlite3CorruptError(int);
3481 int sqlite3MisuseError(int);
3482 int sqlite3CantopenError(int);
3483 #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
3484 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
3485 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
3487 int sqlite3NomemError(int);
3488 int sqlite3IoerrnomemError(int);
3489 int sqlite3CorruptPgnoError(int,Pgno
);
3490 # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
3491 # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
3492 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P))
3494 # define SQLITE_NOMEM_BKPT SQLITE_NOMEM
3495 # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
3496 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__)
3500 ** FTS3 and FTS4 both require virtual table support
3502 #if defined(SQLITE_OMIT_VIRTUALTABLE)
3503 # undef SQLITE_ENABLE_FTS3
3504 # undef SQLITE_ENABLE_FTS4
3508 ** FTS4 is really an extension for FTS3. It is enabled using the
3509 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call
3510 ** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
3512 #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
3513 # define SQLITE_ENABLE_FTS3 1
3517 ** The ctype.h header is needed for non-ASCII systems. It is also
3518 ** needed by FTS3 when FTS3 is included in the amalgamation.
3520 #if !defined(SQLITE_ASCII) || \
3521 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
3526 ** The following macros mimic the standard library functions toupper(),
3527 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
3528 ** sqlite versions only work for ASCII characters, regardless of locale.
3531 # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
3532 # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
3533 # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
3534 # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
3535 # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
3536 # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
3537 # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
3538 # define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
3540 # define sqlite3Toupper(x) toupper((unsigned char)(x))
3541 # define sqlite3Isspace(x) isspace((unsigned char)(x))
3542 # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
3543 # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
3544 # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
3545 # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
3546 # define sqlite3Tolower(x) tolower((unsigned char)(x))
3547 # define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
3549 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
3550 int sqlite3IsIdChar(u8
);
3554 ** Internal function prototypes
3556 int sqlite3StrICmp(const char*,const char*);
3557 int sqlite3Strlen30(const char*);
3558 char *sqlite3ColumnType(Column
*,char*);
3559 #define sqlite3StrNICmp sqlite3_strnicmp
3561 int sqlite3MallocInit(void);
3562 void sqlite3MallocEnd(void);
3563 void *sqlite3Malloc(u64
);
3564 void *sqlite3MallocZero(u64
);
3565 void *sqlite3DbMallocZero(sqlite3
*, u64
);
3566 void *sqlite3DbMallocRaw(sqlite3
*, u64
);
3567 void *sqlite3DbMallocRawNN(sqlite3
*, u64
);
3568 char *sqlite3DbStrDup(sqlite3
*,const char*);
3569 char *sqlite3DbStrNDup(sqlite3
*,const char*, u64
);
3570 char *sqlite3DbSpanDup(sqlite3
*,const char*,const char*);
3571 void *sqlite3Realloc(void*, u64
);
3572 void *sqlite3DbReallocOrFree(sqlite3
*, void *, u64
);
3573 void *sqlite3DbRealloc(sqlite3
*, void *, u64
);
3574 void sqlite3DbFree(sqlite3
*, void*);
3575 void sqlite3DbFreeNN(sqlite3
*, void*);
3576 int sqlite3MallocSize(void*);
3577 int sqlite3DbMallocSize(sqlite3
*, void*);
3578 void *sqlite3PageMalloc(int);
3579 void sqlite3PageFree(void*);
3580 void sqlite3MemSetDefault(void);
3581 #ifndef SQLITE_UNTESTABLE
3582 void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
3584 int sqlite3HeapNearlyFull(void);
3587 ** On systems with ample stack space and that support alloca(), make
3588 ** use of alloca() to obtain space for large automatic objects. By default,
3589 ** obtain space from malloc().
3591 ** The alloca() routine never returns NULL. This will cause code paths
3592 ** that deal with sqlite3StackAlloc() failures to be unreachable.
3594 #ifdef SQLITE_USE_ALLOCA
3595 # define sqlite3StackAllocRaw(D,N) alloca(N)
3596 # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
3597 # define sqlite3StackFree(D,P)
3599 # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
3600 # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
3601 # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
3604 /* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they
3605 ** are, disable MEMSYS3
3607 #ifdef SQLITE_ENABLE_MEMSYS5
3608 const sqlite3_mem_methods
*sqlite3MemGetMemsys5(void);
3609 #undef SQLITE_ENABLE_MEMSYS3
3611 #ifdef SQLITE_ENABLE_MEMSYS3
3612 const sqlite3_mem_methods
*sqlite3MemGetMemsys3(void);
3616 #ifndef SQLITE_MUTEX_OMIT
3617 sqlite3_mutex_methods
const *sqlite3DefaultMutex(void);
3618 sqlite3_mutex_methods
const *sqlite3NoopMutex(void);
3619 sqlite3_mutex
*sqlite3MutexAlloc(int);
3620 int sqlite3MutexInit(void);
3621 int sqlite3MutexEnd(void);
3623 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
3624 void sqlite3MemoryBarrier(void);
3626 # define sqlite3MemoryBarrier()
3629 sqlite3_int64
sqlite3StatusValue(int);
3630 void sqlite3StatusUp(int, int);
3631 void sqlite3StatusDown(int, int);
3632 void sqlite3StatusHighwater(int, int);
3633 int sqlite3LookasideUsed(sqlite3
*,int*);
3635 /* Access to mutexes used by sqlite3_status() */
3636 sqlite3_mutex
*sqlite3Pcache1Mutex(void);
3637 sqlite3_mutex
*sqlite3MallocMutex(void);
3639 #if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT)
3640 void sqlite3MutexWarnOnContention(sqlite3_mutex
*);
3642 # define sqlite3MutexWarnOnContention(x)
3645 #ifndef SQLITE_OMIT_FLOATING_POINT
3646 int sqlite3IsNaN(double);
3648 # define sqlite3IsNaN(X) 0
3652 ** An instance of the following structure holds information about SQL
3653 ** functions arguments that are the parameters to the printf() function.
3655 struct PrintfArguments
{
3656 int nArg
; /* Total number of arguments */
3657 int nUsed
; /* Number of arguments used so far */
3658 sqlite3_value
**apArg
; /* The argument values */
3661 void sqlite3VXPrintf(StrAccum
*, const char*, va_list);
3662 void sqlite3XPrintf(StrAccum
*, const char*, ...);
3663 char *sqlite3MPrintf(sqlite3
*,const char*, ...);
3664 char *sqlite3VMPrintf(sqlite3
*,const char*, va_list);
3665 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
3666 void sqlite3DebugPrintf(const char*, ...);
3668 #if defined(SQLITE_TEST)
3669 void *sqlite3TestTextToPtr(const char*);
3672 #if defined(SQLITE_DEBUG)
3673 void sqlite3TreeViewExpr(TreeView
*, const Expr
*, u8
);
3674 void sqlite3TreeViewBareExprList(TreeView
*, const ExprList
*, const char*);
3675 void sqlite3TreeViewExprList(TreeView
*, const ExprList
*, u8
, const char*);
3676 void sqlite3TreeViewSelect(TreeView
*, const Select
*, u8
);
3677 void sqlite3TreeViewWith(TreeView
*, const With
*, u8
);
3681 void sqlite3SetString(char **, sqlite3
*, const char*);
3682 void sqlite3ErrorMsg(Parse
*, const char*, ...);
3683 void sqlite3Dequote(char*);
3684 void sqlite3TokenInit(Token
*,char*);
3685 int sqlite3KeywordCode(const unsigned char*, int);
3686 int sqlite3RunParser(Parse
*, const char*, char **);
3687 void sqlite3FinishCoding(Parse
*);
3688 int sqlite3GetTempReg(Parse
*);
3689 void sqlite3ReleaseTempReg(Parse
*,int);
3690 int sqlite3GetTempRange(Parse
*,int);
3691 void sqlite3ReleaseTempRange(Parse
*,int,int);
3692 void sqlite3ClearTempRegCache(Parse
*);
3694 int sqlite3NoTempsInRange(Parse
*,int,int);
3696 Expr
*sqlite3ExprAlloc(sqlite3
*,int,const Token
*,int);
3697 Expr
*sqlite3Expr(sqlite3
*,int,const char*);
3698 void sqlite3ExprAttachSubtrees(sqlite3
*,Expr
*,Expr
*,Expr
*);
3699 Expr
*sqlite3PExpr(Parse
*, int, Expr
*, Expr
*);
3700 void sqlite3PExprAddSelect(Parse
*, Expr
*, Select
*);
3701 Expr
*sqlite3ExprAnd(sqlite3
*,Expr
*, Expr
*);
3702 Expr
*sqlite3ExprFunction(Parse
*,ExprList
*, Token
*);
3703 void sqlite3ExprAssignVarNumber(Parse
*, Expr
*, u32
);
3704 void sqlite3ExprDelete(sqlite3
*, Expr
*);
3705 ExprList
*sqlite3ExprListAppend(Parse
*,ExprList
*,Expr
*);
3706 ExprList
*sqlite3ExprListAppendVector(Parse
*,ExprList
*,IdList
*,Expr
*);
3707 void sqlite3ExprListSetSortOrder(ExprList
*,int);
3708 void sqlite3ExprListSetName(Parse
*,ExprList
*,Token
*,int);
3709 void sqlite3ExprListSetSpan(Parse
*,ExprList
*,const char*,const char*);
3710 void sqlite3ExprListDelete(sqlite3
*, ExprList
*);
3711 u32
sqlite3ExprListFlags(const ExprList
*);
3712 int sqlite3Init(sqlite3
*, char**);
3713 int sqlite3InitCallback(void*, int, char**, char**);
3714 void sqlite3Pragma(Parse
*,Token
*,Token
*,Token
*,int);
3715 #ifndef SQLITE_OMIT_VIRTUALTABLE
3716 Module
*sqlite3PragmaVtabRegister(sqlite3
*,const char *zName
);
3718 void sqlite3ResetAllSchemasOfConnection(sqlite3
*);
3719 void sqlite3ResetOneSchema(sqlite3
*,int);
3720 void sqlite3CollapseDatabaseArray(sqlite3
*);
3721 void sqlite3CommitInternalChanges(sqlite3
*);
3722 void sqlite3DeleteColumnNames(sqlite3
*,Table
*);
3723 int sqlite3ColumnsFromExprList(Parse
*,ExprList
*,i16
*,Column
**);
3724 void sqlite3SelectAddColumnTypeAndCollation(Parse
*,Table
*,Select
*);
3725 Table
*sqlite3ResultSetOfSelect(Parse
*,Select
*);
3726 void sqlite3OpenMasterTable(Parse
*, int);
3727 Index
*sqlite3PrimaryKeyIndex(Table
*);
3728 i16
sqlite3ColumnOfIndex(Index
*, i16
);
3729 void sqlite3StartTable(Parse
*,Token
*,Token
*,int,int,int,int);
3730 #if SQLITE_ENABLE_HIDDEN_COLUMNS
3731 void sqlite3ColumnPropertiesFromName(Table
*, Column
*);
3733 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
3735 void sqlite3AddColumn(Parse
*,Token
*,Token
*);
3736 void sqlite3AddNotNull(Parse
*, int);
3737 void sqlite3AddPrimaryKey(Parse
*, ExprList
*, int, int, int);
3738 void sqlite3AddCheckConstraint(Parse
*, Expr
*);
3739 void sqlite3AddDefaultValue(Parse
*,Expr
*,const char*,const char*);
3740 void sqlite3AddCollateType(Parse
*, Token
*);
3741 void sqlite3EndTable(Parse
*,Token
*,Token
*,u8
,Select
*);
3742 int sqlite3ParseUri(const char*,const char*,unsigned int*,
3743 sqlite3_vfs
**,char**,char **);
3744 Btree
*sqlite3DbNameToBtree(sqlite3
*,const char*);
3746 #ifdef SQLITE_UNTESTABLE
3747 # define sqlite3FaultSim(X) SQLITE_OK
3749 int sqlite3FaultSim(int);
3752 Bitvec
*sqlite3BitvecCreate(u32
);
3753 int sqlite3BitvecTest(Bitvec
*, u32
);
3754 int sqlite3BitvecTestNotNull(Bitvec
*, u32
);
3755 int sqlite3BitvecSet(Bitvec
*, u32
);
3756 void sqlite3BitvecClear(Bitvec
*, u32
, void*);
3757 void sqlite3BitvecDestroy(Bitvec
*);
3758 u32
sqlite3BitvecSize(Bitvec
*);
3759 #ifndef SQLITE_UNTESTABLE
3760 int sqlite3BitvecBuiltinTest(int,int*);
3763 RowSet
*sqlite3RowSetInit(sqlite3
*, void*, unsigned int);
3764 void sqlite3RowSetClear(RowSet
*);
3765 void sqlite3RowSetInsert(RowSet
*, i64
);
3766 int sqlite3RowSetTest(RowSet
*, int iBatch
, i64
);
3767 int sqlite3RowSetNext(RowSet
*, i64
*);
3769 void sqlite3CreateView(Parse
*,Token
*,Token
*,Token
*,ExprList
*,Select
*,int,int);
3771 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3772 int sqlite3ViewGetColumnNames(Parse
*,Table
*);
3774 # define sqlite3ViewGetColumnNames(A,B) 0
3777 #if SQLITE_MAX_ATTACHED>30
3778 int sqlite3DbMaskAllZero(yDbMask
);
3780 void sqlite3DropTable(Parse
*, SrcList
*, int, int);
3781 void sqlite3CodeDropTable(Parse
*, Table
*, int, int);
3782 void sqlite3DeleteTable(sqlite3
*, Table
*);
3783 #ifndef SQLITE_OMIT_AUTOINCREMENT
3784 void sqlite3AutoincrementBegin(Parse
*pParse
);
3785 void sqlite3AutoincrementEnd(Parse
*pParse
);
3787 # define sqlite3AutoincrementBegin(X)
3788 # define sqlite3AutoincrementEnd(X)
3790 void sqlite3Insert(Parse
*, SrcList
*, Select
*, IdList
*, int, Upsert
*);
3791 void *sqlite3ArrayAllocate(sqlite3
*,void*,int,int*,int*);
3792 IdList
*sqlite3IdListAppend(sqlite3
*, IdList
*, Token
*);
3793 int sqlite3IdListIndex(IdList
*,const char*);
3794 SrcList
*sqlite3SrcListEnlarge(sqlite3
*, SrcList
*, int, int);
3795 SrcList
*sqlite3SrcListAppend(sqlite3
*, SrcList
*, Token
*, Token
*);
3796 SrcList
*sqlite3SrcListAppendFromTerm(Parse
*, SrcList
*, Token
*, Token
*,
3797 Token
*, Select
*, Expr
*, IdList
*);
3798 void sqlite3SrcListIndexedBy(Parse
*, SrcList
*, Token
*);
3799 void sqlite3SrcListFuncArgs(Parse
*, SrcList
*, ExprList
*);
3800 int sqlite3IndexedByLookup(Parse
*, struct SrcList_item
*);
3801 void sqlite3SrcListShiftJoinType(SrcList
*);
3802 void sqlite3SrcListAssignCursors(Parse
*, SrcList
*);
3803 void sqlite3IdListDelete(sqlite3
*, IdList
*);
3804 void sqlite3SrcListDelete(sqlite3
*, SrcList
*);
3805 Index
*sqlite3AllocateIndexObject(sqlite3
*,i16
,int,char**);
3806 void sqlite3CreateIndex(Parse
*,Token
*,Token
*,SrcList
*,ExprList
*,int,Token
*,
3807 Expr
*, int, int, u8
);
3808 void sqlite3DropIndex(Parse
*, SrcList
*, int);
3809 int sqlite3Select(Parse
*, Select
*, SelectDest
*);
3810 Select
*sqlite3SelectNew(Parse
*,ExprList
*,SrcList
*,Expr
*,ExprList
*,
3811 Expr
*,ExprList
*,u32
,Expr
*);
3812 void sqlite3SelectDelete(sqlite3
*, Select
*);
3813 Table
*sqlite3SrcListLookup(Parse
*, SrcList
*);
3814 int sqlite3IsReadOnly(Parse
*, Table
*, int);
3815 void sqlite3OpenTable(Parse
*, int iCur
, int iDb
, Table
*, int);
3816 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
3817 Expr
*sqlite3LimitWhere(Parse
*,SrcList
*,Expr
*,ExprList
*,Expr
*,char*);
3819 void sqlite3DeleteFrom(Parse
*, SrcList
*, Expr
*, ExprList
*, Expr
*);
3820 void sqlite3Update(Parse
*, SrcList
*, ExprList
*,Expr
*,int,ExprList
*,Expr
*,
3822 WhereInfo
*sqlite3WhereBegin(Parse
*,SrcList
*,Expr
*,ExprList
*,ExprList
*,u16
,int);
3823 void sqlite3WhereEnd(WhereInfo
*);
3824 LogEst
sqlite3WhereOutputRowCount(WhereInfo
*);
3825 int sqlite3WhereIsDistinct(WhereInfo
*);
3826 int sqlite3WhereIsOrdered(WhereInfo
*);
3827 int sqlite3WhereOrderedInnerLoop(WhereInfo
*);
3828 int sqlite3WhereIsSorted(WhereInfo
*);
3829 int sqlite3WhereContinueLabel(WhereInfo
*);
3830 int sqlite3WhereBreakLabel(WhereInfo
*);
3831 int sqlite3WhereOkOnePass(WhereInfo
*, int*);
3832 #define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */
3833 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
3834 #define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */
3835 void sqlite3ExprCodeLoadIndexColumn(Parse
*, Index
*, int, int, int);
3836 int sqlite3ExprCodeGetColumn(Parse
*, Table
*, int, int, int, u8
);
3837 void sqlite3ExprCodeGetColumnToReg(Parse
*, Table
*, int, int, int);
3838 void sqlite3ExprCodeGetColumnOfTable(Vdbe
*, Table
*, int, int, int);
3839 void sqlite3ExprCodeMove(Parse
*, int, int, int);
3840 void sqlite3ExprCacheStore(Parse
*, int, int, int);
3841 void sqlite3ExprCachePush(Parse
*);
3842 void sqlite3ExprCachePop(Parse
*);
3843 void sqlite3ExprCacheRemove(Parse
*, int, int);
3844 void sqlite3ExprCacheClear(Parse
*);
3845 void sqlite3ExprCacheAffinityChange(Parse
*, int, int);
3846 void sqlite3ExprCode(Parse
*, Expr
*, int);
3847 void sqlite3ExprCodeCopy(Parse
*, Expr
*, int);
3848 void sqlite3ExprCodeFactorable(Parse
*, Expr
*, int);
3849 int sqlite3ExprCodeAtInit(Parse
*, Expr
*, int);
3850 int sqlite3ExprCodeTemp(Parse
*, Expr
*, int*);
3851 int sqlite3ExprCodeTarget(Parse
*, Expr
*, int);
3852 void sqlite3ExprCodeAndCache(Parse
*, Expr
*, int);
3853 int sqlite3ExprCodeExprList(Parse
*, ExprList
*, int, int, u8
);
3854 #define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
3855 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
3856 #define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */
3857 #define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */
3858 void sqlite3ExprIfTrue(Parse
*, Expr
*, int, int);
3859 void sqlite3ExprIfFalse(Parse
*, Expr
*, int, int);
3860 void sqlite3ExprIfFalseDup(Parse
*, Expr
*, int, int);
3861 Table
*sqlite3FindTable(sqlite3
*,const char*, const char*);
3862 #define LOCATE_VIEW 0x01
3863 #define LOCATE_NOERR 0x02
3864 Table
*sqlite3LocateTable(Parse
*,u32 flags
,const char*, const char*);
3865 Table
*sqlite3LocateTableItem(Parse
*,u32 flags
,struct SrcList_item
*);
3866 Index
*sqlite3FindIndex(sqlite3
*,const char*, const char*);
3867 void sqlite3UnlinkAndDeleteTable(sqlite3
*,int,const char*);
3868 void sqlite3UnlinkAndDeleteIndex(sqlite3
*,int,const char*);
3869 void sqlite3Vacuum(Parse
*,Token
*);
3870 int sqlite3RunVacuum(char**, sqlite3
*, int);
3871 char *sqlite3NameFromToken(sqlite3
*, Token
*);
3872 int sqlite3ExprCompare(Parse
*,Expr
*, Expr
*, int);
3873 int sqlite3ExprCompareSkip(Expr
*, Expr
*, int);
3874 int sqlite3ExprListCompare(ExprList
*, ExprList
*, int);
3875 int sqlite3ExprImpliesExpr(Parse
*,Expr
*, Expr
*, int);
3876 int sqlite3ExprImpliesNonNullRow(Expr
*,int);
3877 void sqlite3ExprAnalyzeAggregates(NameContext
*, Expr
*);
3878 void sqlite3ExprAnalyzeAggList(NameContext
*,ExprList
*);
3879 int sqlite3ExprCoveredByIndex(Expr
*, int iCur
, Index
*pIdx
);
3880 int sqlite3FunctionUsesThisSrc(Expr
*, SrcList
*);
3881 Vdbe
*sqlite3GetVdbe(Parse
*);
3882 #ifndef SQLITE_UNTESTABLE
3883 void sqlite3PrngSaveState(void);
3884 void sqlite3PrngRestoreState(void);
3886 void sqlite3RollbackAll(sqlite3
*,int);
3887 void sqlite3CodeVerifySchema(Parse
*, int);
3888 void sqlite3CodeVerifyNamedSchema(Parse
*, const char *zDb
);
3889 void sqlite3BeginTransaction(Parse
*, int);
3890 void sqlite3EndTransaction(Parse
*,int);
3891 void sqlite3Savepoint(Parse
*, int, Token
*);
3892 void sqlite3CloseSavepoints(sqlite3
*);
3893 void sqlite3LeaveMutexAndCloseZombie(sqlite3
*);
3894 int sqlite3ExprIdToTrueFalse(Expr
*);
3895 int sqlite3ExprTruthValue(const Expr
*);
3896 int sqlite3ExprIsConstant(Expr
*);
3897 int sqlite3ExprIsConstantNotJoin(Expr
*);
3898 int sqlite3ExprIsConstantOrFunction(Expr
*, u8
);
3899 int sqlite3ExprIsConstantOrGroupBy(Parse
*, Expr
*, ExprList
*);
3900 int sqlite3ExprIsTableConstant(Expr
*,int);
3901 #ifdef SQLITE_ENABLE_CURSOR_HINTS
3902 int sqlite3ExprContainsSubquery(Expr
*);
3904 int sqlite3ExprIsInteger(Expr
*, int*);
3905 int sqlite3ExprCanBeNull(const Expr
*);
3906 int sqlite3ExprNeedsNoAffinityChange(const Expr
*, char);
3907 int sqlite3IsRowid(const char*);
3908 void sqlite3GenerateRowDelete(
3909 Parse
*,Table
*,Trigger
*,int,int,int,i16
,u8
,u8
,u8
,int);
3910 void sqlite3GenerateRowIndexDelete(Parse
*, Table
*, int, int, int*, int);
3911 int sqlite3GenerateIndexKey(Parse
*, Index
*, int, int, int, int*,Index
*,int);
3912 void sqlite3ResolvePartIdxLabel(Parse
*,int);
3913 void sqlite3GenerateConstraintChecks(Parse
*,Table
*,int*,int,int,int,int,
3914 u8
,u8
,int,int*,int*,Upsert
*);
3915 #ifdef SQLITE_ENABLE_NULL_TRIM
3916 void sqlite3SetMakeRecordP5(Vdbe
*,Table
*);
3918 # define sqlite3SetMakeRecordP5(A,B)
3920 void sqlite3CompleteInsertion(Parse
*,Table
*,int,int,int,int*,int,int,int);
3921 int sqlite3OpenTableAndIndices(Parse
*, Table
*, int, u8
, int, u8
*, int*, int*);
3922 void sqlite3BeginWriteOperation(Parse
*, int, int);
3923 void sqlite3MultiWrite(Parse
*);
3924 void sqlite3MayAbort(Parse
*);
3925 void sqlite3HaltConstraint(Parse
*, int, int, char*, i8
, u8
);
3926 void sqlite3UniqueConstraint(Parse
*, int, Index
*);
3927 void sqlite3RowidConstraint(Parse
*, int, Table
*);
3928 Expr
*sqlite3ExprDup(sqlite3
*,Expr
*,int);
3929 ExprList
*sqlite3ExprListDup(sqlite3
*,ExprList
*,int);
3930 SrcList
*sqlite3SrcListDup(sqlite3
*,SrcList
*,int);
3931 IdList
*sqlite3IdListDup(sqlite3
*,IdList
*);
3932 Select
*sqlite3SelectDup(sqlite3
*,Select
*,int);
3933 #if SELECTTRACE_ENABLED
3934 void sqlite3SelectSetName(Select
*,const char*);
3936 # define sqlite3SelectSetName(A,B)
3938 void sqlite3InsertBuiltinFuncs(FuncDef
*,int);
3939 FuncDef
*sqlite3FindFunction(sqlite3
*,const char*,int,u8
,u8
);
3940 void sqlite3RegisterBuiltinFunctions(void);
3941 void sqlite3RegisterDateTimeFunctions(void);
3942 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3
*);
3943 int sqlite3SafetyCheckOk(sqlite3
*);
3944 int sqlite3SafetyCheckSickOrOk(sqlite3
*);
3945 void sqlite3ChangeCookie(Parse
*, int);
3947 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
3948 void sqlite3MaterializeView(Parse
*, Table
*, Expr
*, ExprList
*,Expr
*,int);
3951 #ifndef SQLITE_OMIT_TRIGGER
3952 void sqlite3BeginTrigger(Parse
*, Token
*,Token
*,int,int,IdList
*,SrcList
*,
3954 void sqlite3FinishTrigger(Parse
*, TriggerStep
*, Token
*);
3955 void sqlite3DropTrigger(Parse
*, SrcList
*, int);
3956 void sqlite3DropTriggerPtr(Parse
*, Trigger
*);
3957 Trigger
*sqlite3TriggersExist(Parse
*, Table
*, int, ExprList
*, int *pMask
);
3958 Trigger
*sqlite3TriggerList(Parse
*, Table
*);
3959 void sqlite3CodeRowTrigger(Parse
*, Trigger
*, int, ExprList
*, int, Table
*,
3961 void sqlite3CodeRowTriggerDirect(Parse
*, Trigger
*, Table
*, int, int, int);
3962 void sqliteViewTriggers(Parse
*, Table
*, Expr
*, int, ExprList
*);
3963 void sqlite3DeleteTriggerStep(sqlite3
*, TriggerStep
*);
3964 TriggerStep
*sqlite3TriggerSelectStep(sqlite3
*,Select
*,
3965 const char*,const char*);
3966 TriggerStep
*sqlite3TriggerInsertStep(sqlite3
*,Token
*, IdList
*,
3968 const char*,const char*);
3969 TriggerStep
*sqlite3TriggerUpdateStep(sqlite3
*,Token
*,ExprList
*, Expr
*, u8
,
3970 const char*,const char*);
3971 TriggerStep
*sqlite3TriggerDeleteStep(sqlite3
*,Token
*, Expr
*,
3972 const char*,const char*);
3973 void sqlite3DeleteTrigger(sqlite3
*, Trigger
*);
3974 void sqlite3UnlinkAndDeleteTrigger(sqlite3
*,int,const char*);
3975 u32
sqlite3TriggerColmask(Parse
*,Trigger
*,ExprList
*,int,int,Table
*,int);
3976 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
3977 # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
3979 # define sqlite3TriggersExist(B,C,D,E,F) 0
3980 # define sqlite3DeleteTrigger(A,B)
3981 # define sqlite3DropTriggerPtr(A,B)
3982 # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
3983 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
3984 # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
3985 # define sqlite3TriggerList(X, Y) 0
3986 # define sqlite3ParseToplevel(p) p
3987 # define sqlite3IsToplevel(p) 1
3988 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
3991 int sqlite3JoinType(Parse
*, Token
*, Token
*, Token
*);
3992 void sqlite3CreateForeignKey(Parse
*, ExprList
*, Token
*, ExprList
*, int);
3993 void sqlite3DeferForeignKey(Parse
*, int);
3994 #ifndef SQLITE_OMIT_AUTHORIZATION
3995 void sqlite3AuthRead(Parse
*,Expr
*,Schema
*,SrcList
*);
3996 int sqlite3AuthCheck(Parse
*,int, const char*, const char*, const char*);
3997 void sqlite3AuthContextPush(Parse
*, AuthContext
*, const char*);
3998 void sqlite3AuthContextPop(AuthContext
*);
3999 int sqlite3AuthReadCol(Parse
*, const char *, const char *, int);
4001 # define sqlite3AuthRead(a,b,c,d)
4002 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
4003 # define sqlite3AuthContextPush(a,b,c)
4004 # define sqlite3AuthContextPop(a) ((void)(a))
4006 void sqlite3Attach(Parse
*, Expr
*, Expr
*, Expr
*);
4007 void sqlite3Detach(Parse
*, Expr
*);
4008 void sqlite3FixInit(DbFixer
*, Parse
*, int, const char*, const Token
*);
4009 int sqlite3FixSrcList(DbFixer
*, SrcList
*);
4010 int sqlite3FixSelect(DbFixer
*, Select
*);
4011 int sqlite3FixExpr(DbFixer
*, Expr
*);
4012 int sqlite3FixExprList(DbFixer
*, ExprList
*);
4013 int sqlite3FixTriggerStep(DbFixer
*, TriggerStep
*);
4014 int sqlite3AtoF(const char *z
, double*, int, u8
);
4015 int sqlite3GetInt32(const char *, int*);
4016 int sqlite3Atoi(const char*);
4017 #ifndef SQLITE_OMIT_UTF16
4018 int sqlite3Utf16ByteLen(const void *pData
, int nChar
);
4020 int sqlite3Utf8CharLen(const char *pData
, int nByte
);
4021 u32
sqlite3Utf8Read(const u8
**);
4022 LogEst
sqlite3LogEst(u64
);
4023 LogEst
sqlite3LogEstAdd(LogEst
,LogEst
);
4024 #ifndef SQLITE_OMIT_VIRTUALTABLE
4025 LogEst
sqlite3LogEstFromDouble(double);
4027 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
4028 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
4029 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
4030 u64
sqlite3LogEstToInt(LogEst
);
4032 VList
*sqlite3VListAdd(sqlite3
*,VList
*,const char*,int,int);
4033 const char *sqlite3VListNumToName(VList
*,int);
4034 int sqlite3VListNameToNum(VList
*,const char*,int);
4037 ** Routines to read and write variable-length integers. These used to
4038 ** be defined locally, but now we use the varint routines in the util.c
4041 int sqlite3PutVarint(unsigned char*, u64
);
4042 u8
sqlite3GetVarint(const unsigned char *, u64
*);
4043 u8
sqlite3GetVarint32(const unsigned char *, u32
*);
4044 int sqlite3VarintLen(u64 v
);
4047 ** The common case is for a varint to be a single byte. They following
4048 ** macros handle the common case without a procedure call, but then call
4049 ** the procedure for larger varints.
4051 #define getVarint32(A,B) \
4052 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
4053 #define putVarint32(A,B) \
4054 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
4055 sqlite3PutVarint((A),(B)))
4056 #define getVarint sqlite3GetVarint
4057 #define putVarint sqlite3PutVarint
4060 const char *sqlite3IndexAffinityStr(sqlite3
*, Index
*);
4061 void sqlite3TableAffinity(Vdbe
*, Table
*, int);
4062 char sqlite3CompareAffinity(Expr
*pExpr
, char aff2
);
4063 int sqlite3IndexAffinityOk(Expr
*pExpr
, char idx_affinity
);
4064 char sqlite3TableColumnAffinity(Table
*,int);
4065 char sqlite3ExprAffinity(Expr
*pExpr
);
4066 int sqlite3Atoi64(const char*, i64
*, int, u8
);
4067 int sqlite3DecOrHexToI64(const char*, i64
*);
4068 void sqlite3ErrorWithMsg(sqlite3
*, int, const char*,...);
4069 void sqlite3Error(sqlite3
*,int);
4070 void sqlite3SystemError(sqlite3
*,int);
4071 void *sqlite3HexToBlob(sqlite3
*, const char *z
, int n
);
4072 u8
sqlite3HexToInt(int h
);
4073 int sqlite3TwoPartName(Parse
*, Token
*, Token
*, Token
**);
4075 #if defined(SQLITE_NEED_ERR_NAME)
4076 const char *sqlite3ErrName(int);
4079 #ifdef SQLITE_ENABLE_DESERIALIZE
4080 int sqlite3MemdbInit(void);
4083 const char *sqlite3ErrStr(int);
4084 int sqlite3ReadSchema(Parse
*pParse
);
4085 CollSeq
*sqlite3FindCollSeq(sqlite3
*,u8 enc
, const char*,int);
4086 CollSeq
*sqlite3LocateCollSeq(Parse
*pParse
, const char*zName
);
4087 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, Expr
*pExpr
);
4088 CollSeq
*sqlite3ExprNNCollSeq(Parse
*pParse
, Expr
*pExpr
);
4089 int sqlite3ExprCollSeqMatch(Parse
*,Expr
*,Expr
*);
4090 Expr
*sqlite3ExprAddCollateToken(Parse
*pParse
, Expr
*, const Token
*, int);
4091 Expr
*sqlite3ExprAddCollateString(Parse
*,Expr
*,const char*);
4092 Expr
*sqlite3ExprSkipCollate(Expr
*);
4093 int sqlite3CheckCollSeq(Parse
*, CollSeq
*);
4094 int sqlite3CheckObjectName(Parse
*, const char *);
4095 void sqlite3VdbeSetChanges(sqlite3
*, int);
4096 int sqlite3AddInt64(i64
*,i64
);
4097 int sqlite3SubInt64(i64
*,i64
);
4098 int sqlite3MulInt64(i64
*,i64
);
4099 int sqlite3AbsInt32(int);
4100 #ifdef SQLITE_ENABLE_8_3_NAMES
4101 void sqlite3FileSuffix3(const char*, char*);
4103 # define sqlite3FileSuffix3(X,Y)
4105 u8
sqlite3GetBoolean(const char *z
,u8
);
4107 const void *sqlite3ValueText(sqlite3_value
*, u8
);
4108 int sqlite3ValueBytes(sqlite3_value
*, u8
);
4109 void sqlite3ValueSetStr(sqlite3_value
*, int, const void *,u8
,
4111 void sqlite3ValueSetNull(sqlite3_value
*);
4112 void sqlite3ValueFree(sqlite3_value
*);
4113 sqlite3_value
*sqlite3ValueNew(sqlite3
*);
4114 #ifndef SQLITE_OMIT_UTF16
4115 char *sqlite3Utf16to8(sqlite3
*, const void*, int, u8
);
4117 int sqlite3ValueFromExpr(sqlite3
*, Expr
*, u8
, u8
, sqlite3_value
**);
4118 void sqlite3ValueApplyAffinity(sqlite3_value
*, u8
, u8
);
4119 #ifndef SQLITE_AMALGAMATION
4120 extern const unsigned char sqlite3OpcodeProperty
[];
4121 extern const char sqlite3StrBINARY
[];
4122 extern const unsigned char sqlite3UpperToLower
[];
4123 extern const unsigned char sqlite3CtypeMap
[];
4124 extern const Token sqlite3IntTokens
[];
4125 extern SQLITE_WSD
struct Sqlite3Config sqlite3Config
;
4126 extern FuncDefHash sqlite3BuiltinFunctions
;
4127 #ifndef SQLITE_OMIT_WSD
4128 extern int sqlite3PendingByte
;
4132 extern sqlite3_uint64 sqlite3NProfileCnt
;
4134 void sqlite3RootPageMoved(sqlite3
*, int, int, int);
4135 void sqlite3Reindex(Parse
*, Token
*, Token
*);
4136 void sqlite3AlterFunctions(void);
4137 void sqlite3AlterRenameTable(Parse
*, SrcList
*, Token
*);
4138 int sqlite3GetToken(const unsigned char *, int *);
4139 void sqlite3NestedParse(Parse
*, const char*, ...);
4140 void sqlite3ExpirePreparedStatements(sqlite3
*);
4141 int sqlite3CodeSubselect(Parse
*, Expr
*, int, int);
4142 void sqlite3SelectPrep(Parse
*, Select
*, NameContext
*);
4143 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
);
4144 int sqlite3MatchSpanName(const char*, const char*, const char*, const char*);
4145 int sqlite3ResolveExprNames(NameContext
*, Expr
*);
4146 int sqlite3ResolveExprListNames(NameContext
*, ExprList
*);
4147 void sqlite3ResolveSelectNames(Parse
*, Select
*, NameContext
*);
4148 void sqlite3ResolveSelfReference(Parse
*,Table
*,int,Expr
*,ExprList
*);
4149 int sqlite3ResolveOrderGroupBy(Parse
*, Select
*, ExprList
*, const char*);
4150 void sqlite3ColumnDefault(Vdbe
*, Table
*, int, int);
4151 void sqlite3AlterFinishAddColumn(Parse
*, Token
*);
4152 void sqlite3AlterBeginAddColumn(Parse
*, SrcList
*);
4153 CollSeq
*sqlite3GetCollSeq(Parse
*, u8
, CollSeq
*, const char*);
4154 char sqlite3AffinityType(const char*, Column
*);
4155 void sqlite3Analyze(Parse
*, Token
*, Token
*);
4156 int sqlite3InvokeBusyHandler(BusyHandler
*, sqlite3_file
*);
4157 int sqlite3FindDb(sqlite3
*, Token
*);
4158 int sqlite3FindDbName(sqlite3
*, const char *);
4159 int sqlite3AnalysisLoad(sqlite3
*,int iDB
);
4160 void sqlite3DeleteIndexSamples(sqlite3
*,Index
*);
4161 void sqlite3DefaultRowEst(Index
*);
4162 void sqlite3RegisterLikeFunctions(sqlite3
*, int);
4163 int sqlite3IsLikeFunction(sqlite3
*,Expr
*,int*,char*);
4164 void sqlite3SchemaClear(void *);
4165 Schema
*sqlite3SchemaGet(sqlite3
*, Btree
*);
4166 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*);
4167 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*,int,int);
4168 void sqlite3KeyInfoUnref(KeyInfo
*);
4169 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*);
4170 KeyInfo
*sqlite3KeyInfoOfIndex(Parse
*, Index
*);
4172 int sqlite3KeyInfoIsWriteable(KeyInfo
*);
4174 int sqlite3CreateFunc(sqlite3
*, const char *, int, int, void *,
4175 void (*)(sqlite3_context
*,int,sqlite3_value
**),
4176 void (*)(sqlite3_context
*,int,sqlite3_value
**), void (*)(sqlite3_context
*),
4177 FuncDestructor
*pDestructor
4179 void sqlite3OomFault(sqlite3
*);
4180 void sqlite3OomClear(sqlite3
*);
4181 int sqlite3ApiExit(sqlite3
*db
, int);
4182 int sqlite3OpenTempDatabase(Parse
*);
4184 void sqlite3StrAccumInit(StrAccum
*, sqlite3
*, char*, int, int);
4185 void sqlite3StrAccumAppend(StrAccum
*,const char*,int);
4186 void sqlite3StrAccumAppendAll(StrAccum
*,const char*);
4187 void sqlite3AppendChar(StrAccum
*,int,char);
4188 char *sqlite3StrAccumFinish(StrAccum
*);
4189 void sqlite3StrAccumReset(StrAccum
*);
4190 void sqlite3SelectDestInit(SelectDest
*,int,int);
4191 Expr
*sqlite3CreateColumnExpr(sqlite3
*, SrcList
*, int, int);
4193 void sqlite3BackupRestart(sqlite3_backup
*);
4194 void sqlite3BackupUpdate(sqlite3_backup
*, Pgno
, const u8
*);
4196 #ifndef SQLITE_OMIT_SUBQUERY
4197 int sqlite3ExprCheckIN(Parse
*, Expr
*);
4199 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
4202 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
4203 void sqlite3AnalyzeFunctions(void);
4204 int sqlite3Stat4ProbeSetValue(
4205 Parse
*,Index
*,UnpackedRecord
**,Expr
*,int,int,int*);
4206 int sqlite3Stat4ValueFromExpr(Parse
*, Expr
*, u8
, sqlite3_value
**);
4207 void sqlite3Stat4ProbeFree(UnpackedRecord
*);
4208 int sqlite3Stat4Column(sqlite3
*, const void*, int, int, sqlite3_value
**);
4209 char sqlite3IndexColumnAffinity(sqlite3
*, Index
*, int);
4213 ** The interface to the LEMON-generated parser
4215 #ifndef SQLITE_AMALGAMATION
4216 void *sqlite3ParserAlloc(void*(*)(u64
), Parse
*);
4217 void sqlite3ParserFree(void*, void(*)(void*));
4219 void sqlite3Parser(void*, int, Token
);
4220 #ifdef YYTRACKMAXSTACKDEPTH
4221 int sqlite3ParserStackPeak(void*);
4224 void sqlite3AutoLoadExtensions(sqlite3
*);
4225 #ifndef SQLITE_OMIT_LOAD_EXTENSION
4226 void sqlite3CloseExtensions(sqlite3
*);
4228 # define sqlite3CloseExtensions(X)
4231 #ifndef SQLITE_OMIT_SHARED_CACHE
4232 void sqlite3TableLock(Parse
*, int, int, u8
, const char *);
4234 #define sqlite3TableLock(v,w,x,y,z)
4238 int sqlite3Utf8To8(unsigned char*);
4241 #ifdef SQLITE_OMIT_VIRTUALTABLE
4242 # define sqlite3VtabClear(Y)
4243 # define sqlite3VtabSync(X,Y) SQLITE_OK
4244 # define sqlite3VtabRollback(X)
4245 # define sqlite3VtabCommit(X)
4246 # define sqlite3VtabInSync(db) 0
4247 # define sqlite3VtabLock(X)
4248 # define sqlite3VtabUnlock(X)
4249 # define sqlite3VtabUnlockList(X)
4250 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
4251 # define sqlite3GetVTable(X,Y) ((VTable*)0)
4253 void sqlite3VtabClear(sqlite3
*db
, Table
*);
4254 void sqlite3VtabDisconnect(sqlite3
*db
, Table
*p
);
4255 int sqlite3VtabSync(sqlite3
*db
, Vdbe
*);
4256 int sqlite3VtabRollback(sqlite3
*db
);
4257 int sqlite3VtabCommit(sqlite3
*db
);
4258 void sqlite3VtabLock(VTable
*);
4259 void sqlite3VtabUnlock(VTable
*);
4260 void sqlite3VtabUnlockList(sqlite3
*);
4261 int sqlite3VtabSavepoint(sqlite3
*, int, int);
4262 void sqlite3VtabImportErrmsg(Vdbe
*, sqlite3_vtab
*);
4263 VTable
*sqlite3GetVTable(sqlite3
*, Table
*);
4264 Module
*sqlite3VtabCreateModule(
4267 const sqlite3_module
*,
4271 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
4273 int sqlite3VtabEponymousTableInit(Parse
*,Module
*);
4274 void sqlite3VtabEponymousTableClear(sqlite3
*,Module
*);
4275 void sqlite3VtabMakeWritable(Parse
*,Table
*);
4276 void sqlite3VtabBeginParse(Parse
*, Token
*, Token
*, Token
*, int);
4277 void sqlite3VtabFinishParse(Parse
*, Token
*);
4278 void sqlite3VtabArgInit(Parse
*);
4279 void sqlite3VtabArgExtend(Parse
*, Token
*);
4280 int sqlite3VtabCallCreate(sqlite3
*, int, const char *, char **);
4281 int sqlite3VtabCallConnect(Parse
*, Table
*);
4282 int sqlite3VtabCallDestroy(sqlite3
*, int, const char *);
4283 int sqlite3VtabBegin(sqlite3
*, VTable
*);
4284 FuncDef
*sqlite3VtabOverloadFunction(sqlite3
*,FuncDef
*, int nArg
, Expr
*);
4285 void sqlite3InvalidFunction(sqlite3_context
*,int,sqlite3_value
**);
4286 sqlite3_int64
sqlite3StmtCurrentTime(sqlite3_context
*);
4287 int sqlite3VdbeParameterIndex(Vdbe
*, const char*, int);
4288 int sqlite3TransferBindings(sqlite3_stmt
*, sqlite3_stmt
*);
4289 void sqlite3ParserReset(Parse
*);
4290 int sqlite3Reprepare(Vdbe
*);
4291 void sqlite3ExprListCheckLength(Parse
*, ExprList
*, const char*);
4292 CollSeq
*sqlite3BinaryCompareCollSeq(Parse
*, Expr
*, Expr
*);
4293 int sqlite3TempInMemory(const sqlite3
*);
4294 const char *sqlite3JournalModename(int);
4295 #ifndef SQLITE_OMIT_WAL
4296 int sqlite3Checkpoint(sqlite3
*, int, int, int*, int*);
4297 int sqlite3WalDefaultHook(void*,sqlite3
*,const char*,int);
4299 #ifndef SQLITE_OMIT_CTE
4300 With
*sqlite3WithAdd(Parse
*,With
*,Token
*,ExprList
*,Select
*);
4301 void sqlite3WithDelete(sqlite3
*,With
*);
4302 void sqlite3WithPush(Parse
*, With
*, u8
);
4304 #define sqlite3WithPush(x,y,z)
4305 #define sqlite3WithDelete(x,y)
4307 #ifndef SQLITE_OMIT_UPSERT
4308 Upsert
*sqlite3UpsertNew(sqlite3
*,ExprList
*,Expr
*,ExprList
*,Expr
*);
4309 void sqlite3UpsertDelete(sqlite3
*,Upsert
*);
4310 Upsert
*sqlite3UpsertDup(sqlite3
*,Upsert
*);
4311 int sqlite3UpsertAnalyzeTarget(Parse
*,SrcList
*,Upsert
*);
4312 void sqlite3UpsertDoUpdate(Parse
*,Upsert
*,Table
*,Index
*,int);
4314 #define sqlite3UpsertNew(v,w,x,y,z) ((Upsert*)0)
4315 #define sqlite3UpsertDelete(x,y)
4316 #define sqlite3UpsertDup(x,y) ((Upsert*)0)
4320 /* Declarations for functions in fkey.c. All of these are replaced by
4321 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
4322 ** key functionality is available. If OMIT_TRIGGER is defined but
4323 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
4324 ** this case foreign keys are parsed, but no other functionality is
4325 ** provided (enforcement of FK constraints requires the triggers sub-system).
4327 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
4328 void sqlite3FkCheck(Parse
*, Table
*, int, int, int*, int);
4329 void sqlite3FkDropTable(Parse
*, SrcList
*, Table
*);
4330 void sqlite3FkActions(Parse
*, Table
*, ExprList
*, int, int*, int);
4331 int sqlite3FkRequired(Parse
*, Table
*, int*, int);
4332 u32
sqlite3FkOldmask(Parse
*, Table
*);
4333 FKey
*sqlite3FkReferences(Table
*);
4335 #define sqlite3FkActions(a,b,c,d,e,f)
4336 #define sqlite3FkCheck(a,b,c,d,e,f)
4337 #define sqlite3FkDropTable(a,b,c)
4338 #define sqlite3FkOldmask(a,b) 0
4339 #define sqlite3FkRequired(a,b,c,d) 0
4340 #define sqlite3FkReferences(a) 0
4342 #ifndef SQLITE_OMIT_FOREIGN_KEY
4343 void sqlite3FkDelete(sqlite3
*, Table
*);
4344 int sqlite3FkLocateIndex(Parse
*,Table
*,FKey
*,Index
**,int**);
4346 #define sqlite3FkDelete(a,b)
4347 #define sqlite3FkLocateIndex(a,b,c,d,e)
4352 ** Available fault injectors. Should be numbered beginning with 0.
4354 #define SQLITE_FAULTINJECTOR_MALLOC 0
4355 #define SQLITE_FAULTINJECTOR_COUNT 1
4358 ** The interface to the code in fault.c used for identifying "benign"
4359 ** malloc failures. This is only present if SQLITE_UNTESTABLE
4362 #ifndef SQLITE_UNTESTABLE
4363 void sqlite3BeginBenignMalloc(void);
4364 void sqlite3EndBenignMalloc(void);
4366 #define sqlite3BeginBenignMalloc()
4367 #define sqlite3EndBenignMalloc()
4371 ** Allowed return values from sqlite3FindInIndex()
4373 #define IN_INDEX_ROWID 1 /* Search the rowid of the table */
4374 #define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
4375 #define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */
4376 #define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */
4377 #define IN_INDEX_NOOP 5 /* No table available. Use comparisons */
4379 ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
4381 #define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
4382 #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
4383 #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
4384 int sqlite3FindInIndex(Parse
*, Expr
*, u32
, int*, int*);
4386 int sqlite3JournalOpen(sqlite3_vfs
*, const char *, sqlite3_file
*, int, int);
4387 int sqlite3JournalSize(sqlite3_vfs
*);
4388 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
4389 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
4390 int sqlite3JournalCreate(sqlite3_file
*);
4393 int sqlite3JournalIsInMemory(sqlite3_file
*p
);
4394 void sqlite3MemJournalOpen(sqlite3_file
*);
4396 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
);
4397 #if SQLITE_MAX_EXPR_DEPTH>0
4398 int sqlite3SelectExprHeight(Select
*);
4399 int sqlite3ExprCheckHeight(Parse
*, int);
4401 #define sqlite3SelectExprHeight(x) 0
4402 #define sqlite3ExprCheckHeight(x,y)
4405 u32
sqlite3Get4byte(const u8
*);
4406 void sqlite3Put4byte(u8
*, u32
);
4408 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
4409 void sqlite3ConnectionBlocked(sqlite3
*, sqlite3
*);
4410 void sqlite3ConnectionUnlocked(sqlite3
*db
);
4411 void sqlite3ConnectionClosed(sqlite3
*db
);
4413 #define sqlite3ConnectionBlocked(x,y)
4414 #define sqlite3ConnectionUnlocked(x)
4415 #define sqlite3ConnectionClosed(x)
4419 void sqlite3ParserTrace(FILE*, char *);
4421 #if defined(YYCOVERAGE)
4422 int sqlite3ParserCoverage(FILE*);
4426 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
4427 ** sqlite3IoTrace is a pointer to a printf-like routine used to
4428 ** print I/O tracing messages.
4430 #ifdef SQLITE_ENABLE_IOTRACE
4431 # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
4432 void sqlite3VdbeIOTraceSql(Vdbe
*);
4433 SQLITE_API SQLITE_EXTERN
void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*,...);
4436 # define sqlite3VdbeIOTraceSql(X)
4440 ** These routines are available for the mem2.c debugging memory allocator
4441 ** only. They are used to verify that different "types" of memory
4442 ** allocations are properly tracked by the system.
4444 ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
4445 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
4446 ** a single bit set.
4448 ** sqlite3MemdebugHasType() returns true if any of the bits in its second
4449 ** argument match the type set by the previous sqlite3MemdebugSetType().
4450 ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
4452 ** sqlite3MemdebugNoType() returns true if none of the bits in its second
4453 ** argument match the type set by the previous sqlite3MemdebugSetType().
4455 ** Perhaps the most important point is the difference between MEMTYPE_HEAP
4456 ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
4457 ** it might have been allocated by lookaside, except the allocation was
4458 ** too large or lookaside was already full. It is important to verify
4459 ** that allocations that might have been satisfied by lookaside are not
4460 ** passed back to non-lookaside free() routines. Asserts such as the
4461 ** example above are placed on the non-lookaside free() routines to verify
4464 ** All of this is no-op for a production build. It only comes into
4465 ** play when the SQLITE_MEMDEBUG compile-time option is used.
4467 #ifdef SQLITE_MEMDEBUG
4468 void sqlite3MemdebugSetType(void*,u8
);
4469 int sqlite3MemdebugHasType(void*,u8
);
4470 int sqlite3MemdebugNoType(void*,u8
);
4472 # define sqlite3MemdebugSetType(X,Y) /* no-op */
4473 # define sqlite3MemdebugHasType(X,Y) 1
4474 # define sqlite3MemdebugNoType(X,Y) 1
4476 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
4477 #define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */
4478 #define MEMTYPE_PCACHE 0x04 /* Page cache allocations */
4481 ** Threading interface
4483 #if SQLITE_MAX_WORKER_THREADS>0
4484 int sqlite3ThreadCreate(SQLiteThread
**,void*(*)(void*),void*);
4485 int sqlite3ThreadJoin(SQLiteThread
*, void**);
4488 #if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)
4489 int sqlite3DbpageRegister(sqlite3
*);
4491 #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
4492 int sqlite3DbstatRegister(sqlite3
*);
4495 int sqlite3ExprVectorSize(Expr
*pExpr
);
4496 int sqlite3ExprIsVector(Expr
*pExpr
);
4497 Expr
*sqlite3VectorFieldSubexpr(Expr
*, int);
4498 Expr
*sqlite3ExprForVectorField(Parse
*,Expr
*,int);
4499 void sqlite3VectorErrorMsg(Parse
*, Expr
*);
4501 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
4502 const char **sqlite3CompileOptions(int *pnOpt
);
4505 #endif /* SQLITEINT_H */