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 ** The compile-time options SQLITE_MMAP_READWRITE and
642 ** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.
643 ** You must choose one or the other (or neither) but not both.
645 #if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
646 #error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE
650 ** GCC does not define the offsetof() macro so we'll have to do it
654 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
658 ** Macros to compute minimum and maximum of two numbers.
661 # define MIN(A,B) ((A)<(B)?(A):(B))
664 # define MAX(A,B) ((A)>(B)?(A):(B))
668 ** Swap two objects of type TYPE.
670 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
673 ** Check to see if this machine uses EBCDIC. (Yes, believe it or
674 ** not, there are still machines out there that use EBCDIC.)
677 # define SQLITE_EBCDIC 1
679 # define SQLITE_ASCII 1
683 ** Integers of known sizes. These typedefs might change for architectures
684 ** where the sizes very. Preprocessor macros are available so that the
685 ** types can be conveniently redefined at compile-type. Like this:
687 ** cc '-DUINTPTR_TYPE=long long int' ...
690 # ifdef HAVE_UINT32_T
691 # define UINT32_TYPE uint32_t
693 # define UINT32_TYPE unsigned int
697 # ifdef HAVE_UINT16_T
698 # define UINT16_TYPE uint16_t
700 # define UINT16_TYPE unsigned short int
705 # define INT16_TYPE int16_t
707 # define INT16_TYPE short int
712 # define UINT8_TYPE uint8_t
714 # define UINT8_TYPE unsigned char
719 # define INT8_TYPE int8_t
721 # define INT8_TYPE signed char
724 #ifndef LONGDOUBLE_TYPE
725 # define LONGDOUBLE_TYPE long double
727 typedef sqlite_int64 i64
; /* 8-byte signed integer */
728 typedef sqlite_uint64 u64
; /* 8-byte unsigned integer */
729 typedef UINT32_TYPE u32
; /* 4-byte unsigned integer */
730 typedef UINT16_TYPE u16
; /* 2-byte unsigned integer */
731 typedef INT16_TYPE i16
; /* 2-byte signed integer */
732 typedef UINT8_TYPE u8
; /* 1-byte unsigned integer */
733 typedef INT8_TYPE i8
; /* 1-byte signed integer */
736 ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
737 ** that can be stored in a u32 without loss of data. The value
738 ** is 0x00000000ffffffff. But because of quirks of some compilers, we
739 ** have to specify the value in the less intuitive manner shown:
741 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
744 ** The datatype used to store estimates of the number of rows in a
745 ** table or index. This is an unsigned integer type. For 99.9% of
746 ** the world, a 32-bit integer is sufficient. But a 64-bit integer
747 ** can be used at compile-time if desired.
749 #ifdef SQLITE_64BIT_STATS
750 typedef u64 tRowcnt
; /* 64-bit only if requested at compile-time */
752 typedef u32 tRowcnt
; /* 32-bit is the default */
756 ** Estimated quantities used for query planning are stored as 16-bit
757 ** logarithms. For quantity X, the value stored is 10*log2(X). This
758 ** gives a possible range of values of approximately 1.0e986 to 1e-986.
759 ** But the allowed values are "grainy". Not every value is representable.
760 ** For example, quantities 16 and 17 are both represented by a LogEst
761 ** of 40. However, since LogEst quantities are suppose to be estimates,
762 ** not exact values, this imprecision is not a problem.
764 ** "LogEst" is short for "Logarithmic Estimate".
767 ** 1 -> 0 20 -> 43 10000 -> 132
768 ** 2 -> 10 25 -> 46 25000 -> 146
769 ** 3 -> 16 100 -> 66 1000000 -> 199
770 ** 4 -> 20 1000 -> 99 1048576 -> 200
771 ** 10 -> 33 1024 -> 100 4294967296 -> 320
773 ** The LogEst can be negative to indicate fractional values.
776 ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
778 typedef INT16_TYPE LogEst
;
781 ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
783 #ifndef SQLITE_PTRSIZE
784 # if defined(__SIZEOF_POINTER__)
785 # define SQLITE_PTRSIZE __SIZEOF_POINTER__
786 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
787 defined(_M_ARM) || defined(__arm__) || defined(__x86)
788 # define SQLITE_PTRSIZE 4
790 # define SQLITE_PTRSIZE 8
794 /* The uptr type is an unsigned integer large enough to hold a pointer
796 #if defined(HAVE_STDINT_H)
797 typedef uintptr_t uptr
;
798 #elif SQLITE_PTRSIZE==4
805 ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
806 ** something between S (inclusive) and E (exclusive).
808 ** In other words, S is a buffer and E is a pointer to the first byte after
809 ** the end of buffer S. This macro returns true if P points to something
810 ** contained within the buffer S.
812 #define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
816 ** Macros to determine whether the machine is big or little endian,
817 ** and whether or not that determination is run-time or compile-time.
819 ** For best performance, an attempt is made to guess at the byte-order
820 ** using C-preprocessor macros. If that is unsuccessful, or if
821 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
824 #ifndef SQLITE_BYTEORDER
825 # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
826 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
827 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
829 # define SQLITE_BYTEORDER 1234
830 # elif defined(sparc) || defined(__ppc__)
831 # define SQLITE_BYTEORDER 4321
833 # define SQLITE_BYTEORDER 0
836 #if SQLITE_BYTEORDER==4321
837 # define SQLITE_BIGENDIAN 1
838 # define SQLITE_LITTLEENDIAN 0
839 # define SQLITE_UTF16NATIVE SQLITE_UTF16BE
840 #elif SQLITE_BYTEORDER==1234
841 # define SQLITE_BIGENDIAN 0
842 # define SQLITE_LITTLEENDIAN 1
843 # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
845 # ifdef SQLITE_AMALGAMATION
846 const int sqlite3one
= 1;
848 extern const int sqlite3one
;
850 # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
851 # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
852 # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
856 ** Constants for the largest and smallest possible 64-bit signed integers.
857 ** These macros are designed to work correctly on both 32-bit and 64-bit
860 #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
861 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
864 ** Round up a number to the next larger multiple of 8. This is used
865 ** to force 8-byte alignment on 64-bit architectures.
867 #define ROUND8(x) (((x)+7)&~7)
870 ** Round down to the nearest multiple of 8
872 #define ROUNDDOWN8(x) ((x)&~7)
875 ** Assert that the pointer X is aligned to an 8-byte boundary. This
876 ** macro is used only within assert() to verify that the code gets
877 ** all alignment restrictions correct.
879 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
880 ** underlying malloc() implementation might return us 4-byte aligned
881 ** pointers. In that case, only verify 4-byte alignment.
883 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
884 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
886 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
890 ** Disable MMAP on platforms where it is known to not work
892 #if defined(__OpenBSD__) || defined(__QNXNTO__)
893 # undef SQLITE_MAX_MMAP_SIZE
894 # define SQLITE_MAX_MMAP_SIZE 0
898 ** Default maximum size of memory used by memory-mapped I/O in the VFS
901 # include <TargetConditionals.h>
903 #ifndef SQLITE_MAX_MMAP_SIZE
904 # if defined(__linux__) \
906 || (defined(__APPLE__) && defined(__MACH__)) \
908 || defined(__FreeBSD__) \
909 || defined(__DragonFly__)
910 # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */
912 # define SQLITE_MAX_MMAP_SIZE 0
917 ** The default MMAP_SIZE is zero on all platforms. Or, even if a larger
918 ** default MMAP_SIZE is specified at compile-time, make sure that it does
919 ** not exceed the maximum mmap size.
921 #ifndef SQLITE_DEFAULT_MMAP_SIZE
922 # define SQLITE_DEFAULT_MMAP_SIZE 0
924 #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
925 # undef SQLITE_DEFAULT_MMAP_SIZE
926 # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
930 ** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.
931 ** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also
932 ** define SQLITE_ENABLE_STAT3_OR_STAT4
934 #ifdef SQLITE_ENABLE_STAT4
935 # undef SQLITE_ENABLE_STAT3
936 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
937 #elif SQLITE_ENABLE_STAT3
938 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
939 #elif SQLITE_ENABLE_STAT3_OR_STAT4
940 # undef SQLITE_ENABLE_STAT3_OR_STAT4
944 ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
945 ** the Select query generator tracing logic is turned on.
947 #if defined(SQLITE_ENABLE_SELECTTRACE)
948 # define SELECTTRACE_ENABLED 1
950 # define SELECTTRACE_ENABLED 0
954 ** An instance of the following structure is used to store the busy-handler
955 ** callback for a given sqlite handle.
957 ** The sqlite.busyHandler member of the sqlite struct contains the busy
958 ** callback for the database handle. Each pager opened via the sqlite
959 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
960 ** callback is currently invoked only from within pager.c.
962 typedef struct BusyHandler BusyHandler
;
964 int (*xBusyHandler
)(void *,int); /* The busy callback */
965 void *pBusyArg
; /* First arg to busy callback */
966 int nBusy
; /* Incremented with each busy call */
970 ** Name of the master database table. The master database table
971 ** is a special table that holds the names and attributes of all
972 ** user tables and indices.
974 #define MASTER_NAME "sqlite_master"
975 #define TEMP_MASTER_NAME "sqlite_temp_master"
978 ** The root-page of the master database table.
980 #define MASTER_ROOT 1
983 ** The name of the schema table.
985 #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
988 ** A convenience macro that returns the number of elements in
991 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
994 ** Determine if the argument is a power of two
996 #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
999 ** The following value as a destructor means to use sqlite3DbFree().
1000 ** The sqlite3DbFree() routine requires two parameters instead of the
1001 ** one parameter that destructors normally want. So we have to introduce
1002 ** this magic value that the code knows to handle differently. Any
1003 ** pointer will work here as long as it is distinct from SQLITE_STATIC
1004 ** and SQLITE_TRANSIENT.
1006 #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)
1009 ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
1010 ** not support Writable Static Data (WSD) such as global and static variables.
1011 ** All variables must either be on the stack or dynamically allocated from
1012 ** the heap. When WSD is unsupported, the variable declarations scattered
1013 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
1014 ** macro is used for this purpose. And instead of referencing the variable
1015 ** directly, we use its constant as a key to lookup the run-time allocated
1016 ** buffer that holds real variable. The constant is also the initializer
1017 ** for the run-time allocated buffer.
1019 ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
1020 ** macros become no-ops and have zero performance impact.
1022 #ifdef SQLITE_OMIT_WSD
1023 #define SQLITE_WSD const
1024 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
1025 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
1026 int sqlite3_wsd_init(int N
, int J
);
1027 void *sqlite3_wsd_find(void *K
, int L
);
1030 #define GLOBAL(t,v) v
1031 #define sqlite3GlobalConfig sqlite3Config
1035 ** The following macros are used to suppress compiler warnings and to
1036 ** make it clear to human readers when a function parameter is deliberately
1037 ** left unused within the body of a function. This usually happens when
1038 ** a function is called via a function pointer. For example the
1039 ** implementation of an SQL aggregate step callback may not use the
1040 ** parameter indicating the number of arguments passed to the aggregate,
1041 ** if it knows that this is enforced elsewhere.
1043 ** When a function parameter is not used at all within the body of a function,
1044 ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
1045 ** However, these macros may also be used to suppress warnings related to
1046 ** parameters that may or may not be used depending on compilation options.
1047 ** For example those parameters only used in assert() statements. In these
1048 ** cases the parameters are named as per the usual conventions.
1050 #define UNUSED_PARAMETER(x) (void)(x)
1051 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
1054 ** Forward references to structures
1056 typedef struct AggInfo AggInfo
;
1057 typedef struct AuthContext AuthContext
;
1058 typedef struct AutoincInfo AutoincInfo
;
1059 typedef struct Bitvec Bitvec
;
1060 typedef struct CollSeq CollSeq
;
1061 typedef struct Column Column
;
1062 typedef struct Db Db
;
1063 typedef struct Schema Schema
;
1064 typedef struct Expr Expr
;
1065 typedef struct ExprList ExprList
;
1066 typedef struct FKey FKey
;
1067 typedef struct FuncDestructor FuncDestructor
;
1068 typedef struct FuncDef FuncDef
;
1069 typedef struct FuncDefHash FuncDefHash
;
1070 typedef struct IdList IdList
;
1071 typedef struct Index Index
;
1072 typedef struct IndexSample IndexSample
;
1073 typedef struct KeyClass KeyClass
;
1074 typedef struct KeyInfo KeyInfo
;
1075 typedef struct Lookaside Lookaside
;
1076 typedef struct LookasideSlot LookasideSlot
;
1077 typedef struct Module Module
;
1078 typedef struct NameContext NameContext
;
1079 typedef struct Parse Parse
;
1080 typedef struct PreUpdate PreUpdate
;
1081 typedef struct PrintfArguments PrintfArguments
;
1082 typedef struct RowSet RowSet
;
1083 typedef struct Savepoint Savepoint
;
1084 typedef struct Select Select
;
1085 typedef struct SQLiteThread SQLiteThread
;
1086 typedef struct SelectDest SelectDest
;
1087 typedef struct SrcList SrcList
;
1088 typedef struct StrAccum StrAccum
;
1089 typedef struct Table Table
;
1090 typedef struct TableLock TableLock
;
1091 typedef struct Token Token
;
1092 typedef struct TreeView TreeView
;
1093 typedef struct Trigger Trigger
;
1094 typedef struct TriggerPrg TriggerPrg
;
1095 typedef struct TriggerStep TriggerStep
;
1096 typedef struct UnpackedRecord UnpackedRecord
;
1097 typedef struct VTable VTable
;
1098 typedef struct VtabCtx VtabCtx
;
1099 typedef struct Walker Walker
;
1100 typedef struct WhereInfo WhereInfo
;
1101 typedef struct With With
;
1103 /* A VList object records a mapping between parameters/variables/wildcards
1104 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
1105 ** variable number associated with that parameter. See the format description
1106 ** on the sqlite3VListAdd() routine for more information. A VList is really
1107 ** just an array of integers.
1112 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
1113 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
1114 ** pointer types (i.e. FuncDef) defined above.
1123 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
1124 ** synchronous setting to EXTRA. It is no longer supported.
1126 #ifdef SQLITE_EXTRA_DURABLE
1127 # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
1128 # define SQLITE_DEFAULT_SYNCHRONOUS 3
1132 ** Default synchronous levels.
1134 ** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ
1135 ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
1137 ** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS
1143 ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
1144 ** In other words, the zero-based numbers are used for all external interfaces
1145 ** and the one-based values are used internally.
1147 #ifndef SQLITE_DEFAULT_SYNCHRONOUS
1148 # define SQLITE_DEFAULT_SYNCHRONOUS 2
1150 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
1151 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
1155 ** Each database file to be accessed by the system is an instance
1156 ** of the following structure. There are normally two of these structures
1157 ** in the sqlite.aDb[] array. aDb[0] is the main database file and
1158 ** aDb[1] is the database file used to hold temporary tables. Additional
1159 ** databases may be attached.
1162 char *zDbSName
; /* Name of this database. (schema name, not filename) */
1163 Btree
*pBt
; /* The B*Tree structure for this database file */
1164 u8 safety_level
; /* How aggressive at syncing data to disk */
1165 u8 bSyncSet
; /* True if "PRAGMA synchronous=N" has been run */
1166 Schema
*pSchema
; /* Pointer to database schema (possibly shared) */
1170 ** An instance of the following structure stores a database schema.
1172 ** Most Schema objects are associated with a Btree. The exception is
1173 ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
1174 ** In shared cache mode, a single Schema object can be shared by multiple
1175 ** Btrees that refer to the same underlying BtShared object.
1177 ** Schema objects are automatically deallocated when the last Btree that
1178 ** references them is destroyed. The TEMP Schema is manually freed by
1181 ** A thread must be holding a mutex on the corresponding Btree in order
1182 ** to access Schema content. This implies that the thread must also be
1183 ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
1184 ** For a TEMP Schema, only the connection mutex is required.
1187 int schema_cookie
; /* Database schema version number for this file */
1188 int iGeneration
; /* Generation counter. Incremented with each change */
1189 Hash tblHash
; /* All tables indexed by name */
1190 Hash idxHash
; /* All (named) indices indexed by name */
1191 Hash trigHash
; /* All triggers indexed by name */
1192 Hash fkeyHash
; /* All foreign keys by referenced table name */
1193 Table
*pSeqTab
; /* The sqlite_sequence table used by AUTOINCREMENT */
1194 u8 file_format
; /* Schema format version for this file */
1195 u8 enc
; /* Text encoding used by this database */
1196 u16 schemaFlags
; /* Flags associated with this schema */
1197 int cache_size
; /* Number of pages to use in the cache */
1201 ** These macros can be used to test, set, or clear bits in the
1202 ** Db.pSchema->flags field.
1204 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
1205 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
1206 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
1207 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
1210 ** Allowed values for the DB.pSchema->flags field.
1212 ** The DB_SchemaLoaded flag is set after the database schema has been
1213 ** read into internal hash tables.
1215 ** DB_UnresetViews means that one or more views have column names that
1216 ** have been filled out. If the schema changes, these column names might
1217 ** changes and so the view will need to be reset.
1219 #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
1220 #define DB_UnresetViews 0x0002 /* Some views have defined column names */
1221 #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
1222 #define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */
1225 ** The number of different kinds of things that can be limited
1226 ** using the sqlite3_limit() interface.
1228 #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
1231 ** Lookaside malloc is a set of fixed-size buffers that can be used
1232 ** to satisfy small transient memory allocation requests for objects
1233 ** associated with a particular database connection. The use of
1234 ** lookaside malloc provides a significant performance enhancement
1235 ** (approx 10%) by avoiding numerous malloc/free requests while parsing
1238 ** The Lookaside structure holds configuration information about the
1239 ** lookaside malloc subsystem. Each available memory allocation in
1240 ** the lookaside subsystem is stored on a linked list of LookasideSlot
1243 ** Lookaside allocations are only allowed for objects that are associated
1244 ** with a particular database connection. Hence, schema information cannot
1245 ** be stored in lookaside because in shared cache mode the schema information
1246 ** is shared by multiple database connections. Therefore, while parsing
1247 ** schema information, the Lookaside.bEnabled flag is cleared so that
1248 ** lookaside allocations are not used to construct the schema objects.
1251 u32 bDisable
; /* Only operate the lookaside when zero */
1252 u16 sz
; /* Size of each buffer in bytes */
1253 u8 bMalloced
; /* True if pStart obtained from sqlite3_malloc() */
1254 u32 nSlot
; /* Number of lookaside slots allocated */
1255 u32 anStat
[3]; /* 0: hits. 1: size misses. 2: full misses */
1256 LookasideSlot
*pInit
; /* List of buffers not previously used */
1257 LookasideSlot
*pFree
; /* List of available buffers */
1258 void *pStart
; /* First byte of available memory space */
1259 void *pEnd
; /* First byte past end of available space */
1261 struct LookasideSlot
{
1262 LookasideSlot
*pNext
; /* Next buffer in the list of free buffers */
1266 ** A hash table for built-in function definitions. (Application-defined
1267 ** functions use a regular table table from hash.h.)
1269 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
1270 ** Collisions are on the FuncDef.u.pHash chain.
1272 #define SQLITE_FUNC_HASH_SZ 23
1273 struct FuncDefHash
{
1274 FuncDef
*a
[SQLITE_FUNC_HASH_SZ
]; /* Hash table for functions */
1277 #ifdef SQLITE_USER_AUTHENTICATION
1279 ** Information held in the "sqlite3" database connection object and used
1280 ** to manage user authentication.
1282 typedef struct sqlite3_userauth sqlite3_userauth
;
1283 struct sqlite3_userauth
{
1284 u8 authLevel
; /* Current authentication level */
1285 int nAuthPW
; /* Size of the zAuthPW in bytes */
1286 char *zAuthPW
; /* Password used to authenticate */
1287 char *zAuthUser
; /* User name used to authenticate */
1290 /* Allowed values for sqlite3_userauth.authLevel */
1291 #define UAUTH_Unknown 0 /* Authentication not yet checked */
1292 #define UAUTH_Fail 1 /* User authentication failed */
1293 #define UAUTH_User 2 /* Authenticated as a normal user */
1294 #define UAUTH_Admin 3 /* Authenticated as an administrator */
1296 /* Functions used only by user authorization logic */
1297 int sqlite3UserAuthTable(const char*);
1298 int sqlite3UserAuthCheckLogin(sqlite3
*,const char*,u8
*);
1299 void sqlite3UserAuthInit(sqlite3
*);
1300 void sqlite3CryptFunc(sqlite3_context
*,int,sqlite3_value
**);
1302 #endif /* SQLITE_USER_AUTHENTICATION */
1305 ** typedef for the authorization callback function.
1307 #ifdef SQLITE_USER_AUTHENTICATION
1308 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1309 const char*, const char*);
1311 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1315 #ifndef SQLITE_OMIT_DEPRECATED
1316 /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
1317 ** in the style of sqlite3_trace()
1319 #define SQLITE_TRACE_LEGACY 0x80
1321 #define SQLITE_TRACE_LEGACY 0
1322 #endif /* SQLITE_OMIT_DEPRECATED */
1326 ** Each database connection is an instance of the following structure.
1329 sqlite3_vfs
*pVfs
; /* OS Interface */
1330 struct Vdbe
*pVdbe
; /* List of active virtual machines */
1331 CollSeq
*pDfltColl
; /* The default collating sequence (BINARY) */
1332 sqlite3_mutex
*mutex
; /* Connection mutex */
1333 Db
*aDb
; /* All backends */
1334 int nDb
; /* Number of backends currently in use */
1335 u32 mDbFlags
; /* flags recording internal state */
1336 u32 flags
; /* flags settable by pragmas. See below */
1337 i64 lastRowid
; /* ROWID of most recent insert (see above) */
1338 i64 szMmap
; /* Default mmap_size setting */
1339 u32 nSchemaLock
; /* Do not reset the schema when non-zero */
1340 unsigned int openFlags
; /* Flags passed to sqlite3_vfs.xOpen() */
1341 int errCode
; /* Most recent error code (SQLITE_*) */
1342 int errMask
; /* & result codes with this before returning */
1343 int iSysErrno
; /* Errno value from last system error */
1344 u16 dbOptFlags
; /* Flags to enable/disable optimizations */
1345 u8 enc
; /* Text encoding */
1346 u8 autoCommit
; /* The auto-commit flag. */
1347 u8 temp_store
; /* 1: file 2: memory 0: default */
1348 u8 mallocFailed
; /* True if we have seen a malloc failure */
1349 u8 bBenignMalloc
; /* Do not require OOMs if true */
1350 u8 dfltLockMode
; /* Default locking-mode for attached dbs */
1351 signed char nextAutovac
; /* Autovac setting after VACUUM if >=0 */
1352 u8 suppressErr
; /* Do not issue error messages if true */
1353 u8 vtabOnConflict
; /* Value to return for s3_vtab_on_conflict() */
1354 u8 isTransactionSavepoint
; /* True if the outermost savepoint is a TS */
1355 u8 mTrace
; /* zero or more SQLITE_TRACE flags */
1356 u8 skipBtreeMutex
; /* True if no shared-cache backends */
1357 u8 nSqlExec
; /* Number of pending OP_SqlExec opcodes */
1358 int nextPagesize
; /* Pagesize after VACUUM if >0 */
1359 u32 magic
; /* Magic number for detect library misuse */
1360 int nChange
; /* Value returned by sqlite3_changes() */
1361 int nTotalChange
; /* Value returned by sqlite3_total_changes() */
1362 int aLimit
[SQLITE_N_LIMIT
]; /* Limits */
1363 int nMaxSorterMmap
; /* Maximum size of regions mapped by sorter */
1364 struct sqlite3InitInfo
{ /* Information used during initialization */
1365 int newTnum
; /* Rootpage of table being initialized */
1366 u8 iDb
; /* Which db file is being initialized */
1367 u8 busy
; /* TRUE if currently initializing */
1368 unsigned orphanTrigger
: 1; /* Last statement is orphaned TEMP trigger */
1369 unsigned imposterTable
: 1; /* Building an imposter table */
1370 unsigned reopenMemdb
: 1; /* ATTACH is really a reopen using MemDB */
1372 int nVdbeActive
; /* Number of VDBEs currently running */
1373 int nVdbeRead
; /* Number of active VDBEs that read or write */
1374 int nVdbeWrite
; /* Number of active VDBEs that read and write */
1375 int nVdbeExec
; /* Number of nested calls to VdbeExec() */
1376 int nVDestroy
; /* Number of active OP_VDestroy operations */
1377 int nExtension
; /* Number of loaded extensions */
1378 void **aExtension
; /* Array of shared library handles */
1379 int (*xTrace
)(u32
,void*,void*,void*); /* Trace function */
1380 void *pTraceArg
; /* Argument to the trace function */
1381 void (*xProfile
)(void*,const char*,u64
); /* Profiling function */
1382 void *pProfileArg
; /* Argument to profile function */
1383 void *pCommitArg
; /* Argument to xCommitCallback() */
1384 int (*xCommitCallback
)(void*); /* Invoked at every commit. */
1385 void *pRollbackArg
; /* Argument to xRollbackCallback() */
1386 void (*xRollbackCallback
)(void*); /* Invoked at every commit. */
1388 void (*xUpdateCallback
)(void*,int, const char*,const char*,sqlite_int64
);
1389 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1390 void *pPreUpdateArg
; /* First argument to xPreUpdateCallback */
1391 void (*xPreUpdateCallback
)( /* Registered using sqlite3_preupdate_hook() */
1392 void*,sqlite3
*,int,char const*,char const*,sqlite3_int64
,sqlite3_int64
1394 PreUpdate
*pPreUpdate
; /* Context for active pre-update callback */
1395 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
1396 #ifndef SQLITE_OMIT_WAL
1397 int (*xWalCallback
)(void *, sqlite3
*, const char *, int);
1400 void(*xCollNeeded
)(void*,sqlite3
*,int eTextRep
,const char*);
1401 void(*xCollNeeded16
)(void*,sqlite3
*,int eTextRep
,const void*);
1402 void *pCollNeededArg
;
1403 sqlite3_value
*pErr
; /* Most recent error message */
1405 volatile int isInterrupted
; /* True if sqlite3_interrupt has been called */
1406 double notUsed1
; /* Spacer */
1408 Lookaside lookaside
; /* Lookaside malloc configuration */
1409 #ifndef SQLITE_OMIT_AUTHORIZATION
1410 sqlite3_xauth xAuth
; /* Access authorization function */
1411 void *pAuthArg
; /* 1st argument to the access auth function */
1413 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1414 int (*xProgress
)(void *); /* The progress callback */
1415 void *pProgressArg
; /* Argument to the progress callback */
1416 unsigned nProgressOps
; /* Number of opcodes for progress callback */
1418 #ifndef SQLITE_OMIT_VIRTUALTABLE
1419 int nVTrans
; /* Allocated size of aVTrans */
1420 Hash aModule
; /* populated by sqlite3_create_module() */
1421 VtabCtx
*pVtabCtx
; /* Context for active vtab connect/create */
1422 VTable
**aVTrans
; /* Virtual tables with open transactions */
1423 VTable
*pDisconnect
; /* Disconnect these in next sqlite3_prepare() */
1425 Hash aFunc
; /* Hash table of connection functions */
1426 Hash aCollSeq
; /* All collating sequences */
1427 BusyHandler busyHandler
; /* Busy callback */
1428 Db aDbStatic
[2]; /* Static space for the 2 default backends */
1429 Savepoint
*pSavepoint
; /* List of active savepoints */
1430 int busyTimeout
; /* Busy handler timeout, in msec */
1431 int nSavepoint
; /* Number of non-transaction savepoints */
1432 int nStatement
; /* Number of nested statement-transactions */
1433 i64 nDeferredCons
; /* Net deferred constraints this transaction. */
1434 i64 nDeferredImmCons
; /* Net deferred immediate constraints */
1435 int *pnBytesFreed
; /* If not NULL, increment this in DbFree() */
1436 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
1437 /* The following variables are all protected by the STATIC_MASTER
1438 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
1440 ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
1441 ** unlock so that it can proceed.
1443 ** When X.pBlockingConnection==Y, that means that something that X tried
1444 ** tried to do recently failed with an SQLITE_LOCKED error due to locks
1447 sqlite3
*pBlockingConnection
; /* Connection that caused SQLITE_LOCKED */
1448 sqlite3
*pUnlockConnection
; /* Connection to watch for unlock */
1449 void *pUnlockArg
; /* Argument to xUnlockNotify */
1450 void (*xUnlockNotify
)(void **, int); /* Unlock notify callback */
1451 sqlite3
*pNextBlocked
; /* Next in list of all blocked connections */
1453 #ifdef SQLITE_USER_AUTHENTICATION
1454 sqlite3_userauth auth
; /* User authentication information */
1459 ** A macro to discover the encoding of a database.
1461 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
1462 #define ENC(db) ((db)->enc)
1465 ** Possible values for the sqlite3.flags.
1467 ** Value constraints (enforced via assert()):
1468 ** SQLITE_FullFSync == PAGER_FULLFSYNC
1469 ** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
1470 ** SQLITE_CacheSpill == PAGER_CACHE_SPILL
1472 #define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_MASTER */
1473 #define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */
1474 #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
1475 #define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */
1476 #define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */
1477 #define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */
1478 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
1479 #define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */
1480 /* DELETE, or UPDATE and return */
1481 /* the count using a callback. */
1482 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
1483 /* result set is empty */
1484 #define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */
1485 #define SQLITE_ReadUncommit 0x00000400 /* READ UNCOMMITTED in shared-cache */
1486 #define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */
1487 #define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */
1488 #define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */
1489 #define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */
1490 #define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */
1491 #define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */
1492 #define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */
1493 #define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */
1494 #define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */
1495 #define SQLITE_QueryOnly 0x00100000 /* Disable database changes */
1496 #define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */
1497 #define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */
1498 #define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/
1499 #define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */
1501 /* Flags used only if debugging */
1503 #define SQLITE_SqlTrace 0x08000000 /* Debug print SQL as it executes */
1504 #define SQLITE_VdbeListing 0x10000000 /* Debug listings of VDBE programs */
1505 #define SQLITE_VdbeTrace 0x20000000 /* True to trace VDBE execution */
1506 #define SQLITE_VdbeAddopTrace 0x40000000 /* Trace sqlite3VdbeAddOp() calls */
1507 #define SQLITE_VdbeEQP 0x80000000 /* Debug EXPLAIN QUERY PLAN */
1511 ** Allowed values for sqlite3.mDbFlags
1513 #define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */
1514 #define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */
1515 #define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */
1518 ** Bits of the sqlite3.dbOptFlags field that are used by the
1519 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
1520 ** selectively disable various optimizations.
1522 #define SQLITE_QueryFlattener 0x0001 /* Query flattening */
1523 #define SQLITE_ColumnCache 0x0002 /* Column cache */
1524 #define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */
1525 #define SQLITE_FactorOutConst 0x0008 /* Constant factoring */
1526 #define SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */
1527 #define SQLITE_CoverIdxScan 0x0020 /* Covering index scans */
1528 #define SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */
1529 #define SQLITE_Transitive 0x0080 /* Transitive constraints */
1530 #define SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */
1531 #define SQLITE_CountOfView 0x0200 /* The count-of-view optimization */
1532 #define SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */
1533 #define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */
1534 /* TH3 expects the Stat34 ^^^^^^ value to be 0x0800. Don't change it */
1535 #define SQLITE_PushDown 0x1000 /* The push-down optimization */
1536 #define SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */
1537 #define SQLITE_AllOpts 0xffff /* All optimizations */
1540 ** Macros for testing whether or not optimizations are enabled or disabled.
1542 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
1543 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
1546 ** Return true if it OK to factor constant expressions into the initialization
1547 ** code. The argument is a Parse object for the code generator.
1549 #define ConstFactorOk(P) ((P)->okConstFactor)
1552 ** Possible values for the sqlite.magic field.
1553 ** The numbers are obtained at random and have no special meaning, other
1554 ** than being distinct from one another.
1556 #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
1557 #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
1558 #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
1559 #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
1560 #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
1561 #define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */
1564 ** Each SQL function is defined by an instance of the following
1565 ** structure. For global built-in functions (ex: substr(), max(), count())
1566 ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
1567 ** For per-connection application-defined functions, a pointer to this
1568 ** structure is held in the db->aHash hash table.
1570 ** The u.pHash field is used by the global built-ins. The u.pDestructor
1571 ** field is used by per-connection app-def functions.
1574 i8 nArg
; /* Number of arguments. -1 means unlimited */
1575 u16 funcFlags
; /* Some combination of SQLITE_FUNC_* */
1576 void *pUserData
; /* User data parameter */
1577 FuncDef
*pNext
; /* Next function with same name */
1578 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**); /* func or agg-step */
1579 void (*xFinalize
)(sqlite3_context
*); /* Agg finalizer */
1580 const char *zName
; /* SQL name of the function. */
1582 FuncDef
*pHash
; /* Next with a different name but the same hash */
1583 FuncDestructor
*pDestructor
; /* Reference counted destructor function */
1588 ** This structure encapsulates a user-function destructor callback (as
1589 ** configured using create_function_v2()) and a reference counter. When
1590 ** create_function_v2() is called to create a function with a destructor,
1591 ** a single object of this type is allocated. FuncDestructor.nRef is set to
1592 ** the number of FuncDef objects created (either 1 or 3, depending on whether
1593 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
1594 ** member of each of the new FuncDef objects is set to point to the allocated
1597 ** Thereafter, when one of the FuncDef objects is deleted, the reference
1598 ** count on this object is decremented. When it reaches 0, the destructor
1599 ** is invoked and the FuncDestructor structure freed.
1601 struct FuncDestructor
{
1603 void (*xDestroy
)(void *);
1608 ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
1609 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
1610 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
1611 ** are assert() statements in the code to verify this.
1613 ** Value constraints (enforced via assert()):
1614 ** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
1615 ** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
1616 ** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
1617 ** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
1618 ** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
1620 #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
1621 #define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */
1622 #define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
1623 #define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
1624 #define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
1625 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
1626 #define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
1627 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
1628 #define SQLITE_FUNC_COALESCE 0x0200 /* Built-in coalesce() or ifnull() */
1629 #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
1630 #define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
1631 #define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
1632 #define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
1633 ** single query - might change over time */
1634 #define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
1635 #define SQLITE_FUNC_OFFSET 0x8000 /* Built-in sqlite_offset() function */
1638 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
1639 ** used to create the initializers for the FuncDef structures.
1641 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
1642 ** Used to create a scalar function definition of a function zName
1643 ** implemented by C function xFunc that accepts nArg arguments. The
1644 ** value passed as iArg is cast to a (void*) and made available
1645 ** as the user-data (sqlite3_user_data()) for the function. If
1646 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
1648 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
1649 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
1651 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
1652 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
1653 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
1654 ** and functions like sqlite_version() that can change, but not during
1655 ** a single query. The iArg is ignored. The user-data is always set
1656 ** to a NULL pointer. The bNC parameter is not used.
1658 ** PURE_DATE(zName, nArg, iArg, bNC, xFunc)
1659 ** Used for "pure" date/time functions, this macro is like DFUNCTION
1660 ** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is
1661 ** ignored and the user-data for these functions is set to an
1662 ** arbitrary non-NULL pointer. The bNC parameter is not used.
1664 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
1665 ** Used to create an aggregate function definition implemented by
1666 ** the C functions xStep and xFinal. The first four parameters
1667 ** are interpreted in the same way as the first 4 parameters to
1670 ** LIKEFUNC(zName, nArg, pArg, flags)
1671 ** Used to create a scalar function definition of a function zName
1672 ** that accepts nArg arguments and is implemented by a call to C
1673 ** function likeFunc. Argument pArg is cast to a (void *) and made
1674 ** available as the function user-data (sqlite3_user_data()). The
1675 ** FuncDef.flags variable is set to the value passed as the flags
1678 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
1679 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1680 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1681 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1682 {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1683 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1684 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1685 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
1686 0, 0, xFunc, 0, #zName, {0} }
1687 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
1688 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
1689 (void*)&sqlite3Config, 0, xFunc, 0, #zName, {0} }
1690 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
1691 {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
1692 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1693 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
1694 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1695 pArg, 0, xFunc, 0, #zName, }
1696 #define LIKEFUNC(zName, nArg, arg, flags) \
1697 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
1698 (void *)arg, 0, likeFunc, 0, #zName, {0} }
1699 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
1700 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
1701 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1702 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
1703 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
1704 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1707 ** All current savepoints are stored in a linked list starting at
1708 ** sqlite3.pSavepoint. The first element in the list is the most recently
1709 ** opened savepoint. Savepoints are added to the list by the vdbe
1710 ** OP_Savepoint instruction.
1713 char *zName
; /* Savepoint name (nul-terminated) */
1714 i64 nDeferredCons
; /* Number of deferred fk violations */
1715 i64 nDeferredImmCons
; /* Number of deferred imm fk. */
1716 Savepoint
*pNext
; /* Parent savepoint (if any) */
1720 ** The following are used as the second parameter to sqlite3Savepoint(),
1721 ** and as the P1 argument to the OP_Savepoint instruction.
1723 #define SAVEPOINT_BEGIN 0
1724 #define SAVEPOINT_RELEASE 1
1725 #define SAVEPOINT_ROLLBACK 2
1729 ** Each SQLite module (virtual table definition) is defined by an
1730 ** instance of the following structure, stored in the sqlite3.aModule
1734 const sqlite3_module
*pModule
; /* Callback pointers */
1735 const char *zName
; /* Name passed to create_module() */
1736 void *pAux
; /* pAux passed to create_module() */
1737 void (*xDestroy
)(void *); /* Module destructor function */
1738 Table
*pEpoTab
; /* Eponymous table for this module */
1742 ** information about each column of an SQL table is held in an instance
1743 ** of this structure.
1746 char *zName
; /* Name of this column, \000, then the type */
1747 Expr
*pDflt
; /* Default value of this column */
1748 char *zColl
; /* Collating sequence. If NULL, use the default */
1749 u8 notNull
; /* An OE_ code for handling a NOT NULL constraint */
1750 char affinity
; /* One of the SQLITE_AFF_... values */
1751 u8 szEst
; /* Estimated size of value in this column. sizeof(INT)==1 */
1752 u8 colFlags
; /* Boolean properties. See COLFLAG_ defines below */
1755 /* Allowed values for Column.colFlags:
1757 #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
1758 #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
1759 #define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
1760 #define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */
1763 ** A "Collating Sequence" is defined by an instance of the following
1764 ** structure. Conceptually, a collating sequence consists of a name and
1765 ** a comparison routine that defines the order of that sequence.
1767 ** If CollSeq.xCmp is NULL, it means that the
1768 ** collating sequence is undefined. Indices built on an undefined
1769 ** collating sequence may not be read or written.
1772 char *zName
; /* Name of the collating sequence, UTF-8 encoded */
1773 u8 enc
; /* Text encoding handled by xCmp() */
1774 void *pUser
; /* First argument to xCmp() */
1775 int (*xCmp
)(void*,int, const void*, int, const void*);
1776 void (*xDel
)(void*); /* Destructor for pUser */
1780 ** A sort order can be either ASC or DESC.
1782 #define SQLITE_SO_ASC 0 /* Sort in ascending order */
1783 #define SQLITE_SO_DESC 1 /* Sort in ascending order */
1784 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
1787 ** Column affinity types.
1789 ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
1790 ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
1791 ** the speed a little by numbering the values consecutively.
1793 ** But rather than start with 0 or 1, we begin with 'A'. That way,
1794 ** when multiple affinity types are concatenated into a string and
1795 ** used as the P4 operand, they will be more readable.
1797 ** Note also that the numeric types are grouped together so that testing
1798 ** for a numeric type is a single comparison. And the BLOB type is first.
1800 #define SQLITE_AFF_BLOB 'A'
1801 #define SQLITE_AFF_TEXT 'B'
1802 #define SQLITE_AFF_NUMERIC 'C'
1803 #define SQLITE_AFF_INTEGER 'D'
1804 #define SQLITE_AFF_REAL 'E'
1806 #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
1809 ** The SQLITE_AFF_MASK values masks off the significant bits of an
1812 #define SQLITE_AFF_MASK 0x47
1815 ** Additional bit values that can be ORed with an affinity without
1816 ** changing the affinity.
1818 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
1819 ** It causes an assert() to fire if either operand to a comparison
1820 ** operator is NULL. It is added to certain comparison operators to
1821 ** prove that the operands are always NOT NULL.
1823 #define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */
1824 #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
1825 #define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */
1826 #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
1827 #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */
1830 ** An object of this type is created for each virtual table present in
1831 ** the database schema.
1833 ** If the database schema is shared, then there is one instance of this
1834 ** structure for each database connection (sqlite3*) that uses the shared
1835 ** schema. This is because each database connection requires its own unique
1836 ** instance of the sqlite3_vtab* handle used to access the virtual table
1837 ** implementation. sqlite3_vtab* handles can not be shared between
1838 ** database connections, even when the rest of the in-memory database
1839 ** schema is shared, as the implementation often stores the database
1840 ** connection handle passed to it via the xConnect() or xCreate() method
1841 ** during initialization internally. This database connection handle may
1842 ** then be used by the virtual table implementation to access real tables
1843 ** within the database. So that they appear as part of the callers
1844 ** transaction, these accesses need to be made via the same database
1845 ** connection as that used to execute SQL operations on the virtual table.
1847 ** All VTable objects that correspond to a single table in a shared
1848 ** database schema are initially stored in a linked-list pointed to by
1849 ** the Table.pVTable member variable of the corresponding Table object.
1850 ** When an sqlite3_prepare() operation is required to access the virtual
1851 ** table, it searches the list for the VTable that corresponds to the
1852 ** database connection doing the preparing so as to use the correct
1853 ** sqlite3_vtab* handle in the compiled query.
1855 ** When an in-memory Table object is deleted (for example when the
1856 ** schema is being reloaded for some reason), the VTable objects are not
1857 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
1858 ** immediately. Instead, they are moved from the Table.pVTable list to
1859 ** another linked list headed by the sqlite3.pDisconnect member of the
1860 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
1861 ** next time a statement is prepared using said sqlite3*. This is done
1862 ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
1863 ** Refer to comments above function sqlite3VtabUnlockList() for an
1864 ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
1865 ** list without holding the corresponding sqlite3.mutex mutex.
1867 ** The memory for objects of this type is always allocated by
1868 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
1869 ** the first argument.
1872 sqlite3
*db
; /* Database connection associated with this table */
1873 Module
*pMod
; /* Pointer to module implementation */
1874 sqlite3_vtab
*pVtab
; /* Pointer to vtab instance */
1875 int nRef
; /* Number of pointers to this structure */
1876 u8 bConstraint
; /* True if constraints are supported */
1877 int iSavepoint
; /* Depth of the SAVEPOINT stack */
1878 VTable
*pNext
; /* Next in linked list (see above) */
1882 ** The schema for each SQL table and view is represented in memory
1883 ** by an instance of the following structure.
1886 char *zName
; /* Name of the table or view */
1887 Column
*aCol
; /* Information about each column */
1888 Index
*pIndex
; /* List of SQL indexes on this table. */
1889 Select
*pSelect
; /* NULL for tables. Points to definition if a view. */
1890 FKey
*pFKey
; /* Linked list of all foreign keys in this table */
1891 char *zColAff
; /* String defining the affinity of each column */
1892 ExprList
*pCheck
; /* All CHECK constraints */
1893 /* ... also used as column name list in a VIEW */
1894 int tnum
; /* Root BTree page for this table */
1895 u32 nTabRef
; /* Number of pointers to this Table */
1896 u32 tabFlags
; /* Mask of TF_* values */
1897 i16 iPKey
; /* If not negative, use aCol[iPKey] as the rowid */
1898 i16 nCol
; /* Number of columns in this table */
1899 LogEst nRowLogEst
; /* Estimated rows in table - from sqlite_stat1 table */
1900 LogEst szTabRow
; /* Estimated size of each table row in bytes */
1901 #ifdef SQLITE_ENABLE_COSTMULT
1902 LogEst costMult
; /* Cost multiplier for using this table */
1904 u8 keyConf
; /* What to do in case of uniqueness conflict on iPKey */
1905 #ifndef SQLITE_OMIT_ALTERTABLE
1906 int addColOffset
; /* Offset in CREATE TABLE stmt to add a new column */
1908 #ifndef SQLITE_OMIT_VIRTUALTABLE
1909 int nModuleArg
; /* Number of arguments to the module */
1910 char **azModuleArg
; /* 0: module 1: schema 2: vtab name 3...: args */
1911 VTable
*pVTable
; /* List of VTable objects. */
1913 Trigger
*pTrigger
; /* List of triggers stored in pSchema */
1914 Schema
*pSchema
; /* Schema that contains this table */
1915 Table
*pNextZombie
; /* Next on the Parse.pZombieTab list */
1919 ** Allowed values for Table.tabFlags.
1921 ** TF_OOOHidden applies to tables or view that have hidden columns that are
1922 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
1923 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
1924 ** the TF_OOOHidden attribute would apply in this case. Such tables require
1925 ** special handling during INSERT processing.
1927 #define TF_Readonly 0x0001 /* Read-only system table */
1928 #define TF_Ephemeral 0x0002 /* An ephemeral table */
1929 #define TF_HasPrimaryKey 0x0004 /* Table has a primary key */
1930 #define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */
1931 #define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */
1932 #define TF_WithoutRowid 0x0020 /* No rowid. PRIMARY KEY is the key */
1933 #define TF_NoVisibleRowid 0x0040 /* No user-visible "rowid" column */
1934 #define TF_OOOHidden 0x0080 /* Out-of-Order hidden columns */
1935 #define TF_StatsUsed 0x0100 /* Query planner decisions affected by
1936 ** Index.aiRowLogEst[] values */
1937 #define TF_HasNotNull 0x0200 /* Contains NOT NULL constraints */
1940 ** Test to see whether or not a table is a virtual table. This is
1941 ** done as a macro so that it will be optimized out when virtual
1942 ** table support is omitted from the build.
1944 #ifndef SQLITE_OMIT_VIRTUALTABLE
1945 # define IsVirtual(X) ((X)->nModuleArg)
1947 # define IsVirtual(X) 0
1951 ** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn()
1952 ** only works for non-virtual tables (ordinary tables and views) and is
1953 ** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The
1954 ** IsHiddenColumn() macro is general purpose.
1956 #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS)
1957 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1958 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1959 #elif !defined(SQLITE_OMIT_VIRTUALTABLE)
1960 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1961 # define IsOrdinaryHiddenColumn(X) 0
1963 # define IsHiddenColumn(X) 0
1964 # define IsOrdinaryHiddenColumn(X) 0
1968 /* Does the table have a rowid */
1969 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
1970 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
1973 ** Each foreign key constraint is an instance of the following structure.
1975 ** A foreign key is associated with two tables. The "from" table is
1976 ** the table that contains the REFERENCES clause that creates the foreign
1977 ** key. The "to" table is the table that is named in the REFERENCES clause.
1978 ** Consider this example:
1980 ** CREATE TABLE ex1(
1981 ** a INTEGER PRIMARY KEY,
1982 ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
1985 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
1986 ** Equivalent names:
1988 ** from-table == child-table
1989 ** to-table == parent-table
1991 ** Each REFERENCES clause generates an instance of the following structure
1992 ** which is attached to the from-table. The to-table need not exist when
1993 ** the from-table is created. The existence of the to-table is not checked.
1995 ** The list of all parents for child Table X is held at X.pFKey.
1997 ** A list of all children for a table named Z (which might not even exist)
1998 ** is held in Schema.fkeyHash with a hash key of Z.
2001 Table
*pFrom
; /* Table containing the REFERENCES clause (aka: Child) */
2002 FKey
*pNextFrom
; /* Next FKey with the same in pFrom. Next parent of pFrom */
2003 char *zTo
; /* Name of table that the key points to (aka: Parent) */
2004 FKey
*pNextTo
; /* Next with the same zTo. Next child of zTo. */
2005 FKey
*pPrevTo
; /* Previous with the same zTo */
2006 int nCol
; /* Number of columns in this key */
2007 /* EV: R-30323-21917 */
2008 u8 isDeferred
; /* True if constraint checking is deferred till COMMIT */
2009 u8 aAction
[2]; /* ON DELETE and ON UPDATE actions, respectively */
2010 Trigger
*apTrigger
[2];/* Triggers for aAction[] actions */
2011 struct sColMap
{ /* Mapping of columns in pFrom to columns in zTo */
2012 int iFrom
; /* Index of column in pFrom */
2013 char *zCol
; /* Name of column in zTo. If NULL use PRIMARY KEY */
2014 } aCol
[1]; /* One entry for each of nCol columns */
2018 ** SQLite supports many different ways to resolve a constraint
2019 ** error. ROLLBACK processing means that a constraint violation
2020 ** causes the operation in process to fail and for the current transaction
2021 ** to be rolled back. ABORT processing means the operation in process
2022 ** fails and any prior changes from that one operation are backed out,
2023 ** but the transaction is not rolled back. FAIL processing means that
2024 ** the operation in progress stops and returns an error code. But prior
2025 ** changes due to the same operation are not backed out and no rollback
2026 ** occurs. IGNORE means that the particular row that caused the constraint
2027 ** error is not inserted or updated. Processing continues and no error
2028 ** is returned. REPLACE means that preexisting database rows that caused
2029 ** a UNIQUE constraint violation are removed so that the new insert or
2030 ** update can proceed. Processing continues and no error is reported.
2032 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
2033 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
2034 ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
2035 ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
2036 ** referenced table row is propagated into the row that holds the
2039 ** The following symbolic values are used to record which type
2040 ** of action to take.
2042 #define OE_None 0 /* There is no constraint to check */
2043 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
2044 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
2045 #define OE_Fail 3 /* Stop the operation but leave all prior changes */
2046 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
2047 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
2049 #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
2050 #define OE_SetNull 7 /* Set the foreign key value to NULL */
2051 #define OE_SetDflt 8 /* Set the foreign key value to its default */
2052 #define OE_Cascade 9 /* Cascade the changes */
2054 #define OE_Default 10 /* Do whatever the default action is */
2058 ** An instance of the following structure is passed as the first
2059 ** argument to sqlite3VdbeKeyCompare and is used to control the
2060 ** comparison of the two index keys.
2062 ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
2063 ** are nField slots for the columns of an index then one extra slot
2064 ** for the rowid at the end.
2067 u32 nRef
; /* Number of references to this KeyInfo object */
2068 u8 enc
; /* Text encoding - one of the SQLITE_UTF* values */
2069 u16 nKeyField
; /* Number of key columns in the index */
2070 u16 nAllField
; /* Total columns, including key plus others */
2071 sqlite3
*db
; /* The database connection */
2072 u8
*aSortOrder
; /* Sort order for each column. */
2073 CollSeq
*aColl
[1]; /* Collating sequence for each term of the key */
2077 ** This object holds a record which has been parsed out into individual
2078 ** fields, for the purposes of doing a comparison.
2080 ** A record is an object that contains one or more fields of data.
2081 ** Records are used to store the content of a table row and to store
2082 ** the key of an index. A blob encoding of a record is created by
2083 ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
2084 ** OP_Column opcode.
2086 ** An instance of this object serves as a "key" for doing a search on
2087 ** an index b+tree. The goal of the search is to find the entry that
2088 ** is closed to the key described by this object. This object might hold
2089 ** just a prefix of the key. The number of fields is given by
2090 ** pKeyInfo->nField.
2092 ** The r1 and r2 fields are the values to return if this key is less than
2093 ** or greater than a key in the btree, respectively. These are normally
2094 ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
2095 ** is in DESC order.
2097 ** The key comparison functions actually return default_rc when they find
2098 ** an equals comparison. default_rc can be -1, 0, or +1. If there are
2099 ** multiple entries in the b-tree with the same key (when only looking
2100 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
2101 ** cause the search to find the last match, or +1 to cause the search to
2102 ** find the first match.
2104 ** The key comparison functions will set eqSeen to true if they ever
2105 ** get and equal results when comparing this structure to a b-tree record.
2106 ** When default_rc!=0, the search might end up on the record immediately
2107 ** before the first match or immediately after the last match. The
2108 ** eqSeen field will indicate whether or not an exact match exists in the
2111 struct UnpackedRecord
{
2112 KeyInfo
*pKeyInfo
; /* Collation and sort-order information */
2113 Mem
*aMem
; /* Values */
2114 u16 nField
; /* Number of entries in apMem[] */
2115 i8 default_rc
; /* Comparison result if keys are equal */
2116 u8 errCode
; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
2117 i8 r1
; /* Value to return if (lhs < rhs) */
2118 i8 r2
; /* Value to return if (lhs > rhs) */
2119 u8 eqSeen
; /* True if an equality comparison has been seen */
2124 ** Each SQL index is represented in memory by an
2125 ** instance of the following structure.
2127 ** The columns of the table that are to be indexed are described
2128 ** by the aiColumn[] field of this structure. For example, suppose
2129 ** we have the following table and index:
2131 ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
2132 ** CREATE INDEX Ex2 ON Ex1(c3,c1);
2134 ** In the Table structure describing Ex1, nCol==3 because there are
2135 ** three columns in the table. In the Index structure describing
2136 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
2137 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
2138 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
2139 ** The second column to be indexed (c1) has an index of 0 in
2140 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
2142 ** The Index.onError field determines whether or not the indexed columns
2143 ** must be unique and what to do if they are not. When Index.onError=OE_None,
2144 ** it means this is not a unique index. Otherwise it is a unique index
2145 ** and the value of Index.onError indicate the which conflict resolution
2146 ** algorithm to employ whenever an attempt is made to insert a non-unique
2149 ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
2150 ** generate VDBE code (as opposed to parsing one read from an sqlite_master
2151 ** table as part of parsing an existing database schema), transient instances
2152 ** of this structure may be created. In this case the Index.tnum variable is
2153 ** used to store the address of a VDBE instruction, not a database page
2154 ** number (it cannot - the database page is not allocated until the VDBE
2155 ** program is executed). See convertToWithoutRowidTable() for details.
2158 char *zName
; /* Name of this index */
2159 i16
*aiColumn
; /* Which columns are used by this index. 1st is 0 */
2160 LogEst
*aiRowLogEst
; /* From ANALYZE: Est. rows selected by each column */
2161 Table
*pTable
; /* The SQL table being indexed */
2162 char *zColAff
; /* String defining the affinity of each column */
2163 Index
*pNext
; /* The next index associated with the same table */
2164 Schema
*pSchema
; /* Schema containing this index */
2165 u8
*aSortOrder
; /* for each column: True==DESC, False==ASC */
2166 const char **azColl
; /* Array of collation sequence names for index */
2167 Expr
*pPartIdxWhere
; /* WHERE clause for partial indices */
2168 ExprList
*aColExpr
; /* Column expressions */
2169 int tnum
; /* DB Page containing root of this index */
2170 LogEst szIdxRow
; /* Estimated average row size in bytes */
2171 u16 nKeyCol
; /* Number of columns forming the key */
2172 u16 nColumn
; /* Number of columns stored in the index */
2173 u8 onError
; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2174 unsigned idxType
:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
2175 unsigned bUnordered
:1; /* Use this index for == or IN queries only */
2176 unsigned uniqNotNull
:1; /* True if UNIQUE and NOT NULL for all columns */
2177 unsigned isResized
:1; /* True if resizeIndexObject() has been called */
2178 unsigned isCovering
:1; /* True if this is a covering index */
2179 unsigned noSkipScan
:1; /* Do not try to use skip-scan if true */
2180 unsigned hasStat1
:1; /* aiRowLogEst values come from sqlite_stat1 */
2181 unsigned bNoQuery
:1; /* Do not use this index to optimize queries */
2182 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
2183 int nSample
; /* Number of elements in aSample[] */
2184 int nSampleCol
; /* Size of IndexSample.anEq[] and so on */
2185 tRowcnt
*aAvgEq
; /* Average nEq values for keys not in aSample */
2186 IndexSample
*aSample
; /* Samples of the left-most key */
2187 tRowcnt
*aiRowEst
; /* Non-logarithmic stat1 data for this index */
2188 tRowcnt nRowEst0
; /* Non-logarithmic number of rows in the index */
2193 ** Allowed values for Index.idxType
2195 #define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
2196 #define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */
2197 #define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */
2199 /* Return true if index X is a PRIMARY KEY index */
2200 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
2202 /* Return true if index X is a UNIQUE index */
2203 #define IsUniqueIndex(X) ((X)->onError!=OE_None)
2205 /* The Index.aiColumn[] values are normally positive integer. But
2206 ** there are some negative values that have special meaning:
2208 #define XN_ROWID (-1) /* Indexed column is the rowid */
2209 #define XN_EXPR (-2) /* Indexed column is an expression */
2212 ** Each sample stored in the sqlite_stat3 table is represented in memory
2213 ** using a structure of this type. See documentation at the top of the
2214 ** analyze.c source file for additional information.
2216 struct IndexSample
{
2217 void *p
; /* Pointer to sampled record */
2218 int n
; /* Size of record in bytes */
2219 tRowcnt
*anEq
; /* Est. number of rows where the key equals this sample */
2220 tRowcnt
*anLt
; /* Est. number of rows where key is less than this sample */
2221 tRowcnt
*anDLt
; /* Est. number of distinct keys less than this sample */
2225 ** Each token coming out of the lexer is an instance of
2226 ** this structure. Tokens are also used as part of an expression.
2228 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
2229 ** may contain random values. Do not make any assumptions about Token.dyn
2230 ** and Token.n when Token.z==0.
2233 const char *z
; /* Text of the token. Not NULL-terminated! */
2234 unsigned int n
; /* Number of characters in this token */
2238 ** An instance of this structure contains information needed to generate
2239 ** code for a SELECT that contains aggregate functions.
2241 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
2242 ** pointer to this structure. The Expr.iColumn field is the index in
2243 ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
2244 ** code for that node.
2246 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
2247 ** original Select structure that describes the SELECT statement. These
2248 ** fields do not need to be freed when deallocating the AggInfo structure.
2251 u8 directMode
; /* Direct rendering mode means take data directly
2252 ** from source tables rather than from accumulators */
2253 u8 useSortingIdx
; /* In direct mode, reference the sorting index rather
2254 ** than the source table */
2255 int sortingIdx
; /* Cursor number of the sorting index */
2256 int sortingIdxPTab
; /* Cursor number of pseudo-table */
2257 int nSortingColumn
; /* Number of columns in the sorting index */
2258 int mnReg
, mxReg
; /* Range of registers allocated for aCol and aFunc */
2259 ExprList
*pGroupBy
; /* The group by clause */
2260 struct AggInfo_col
{ /* For each column used in source tables */
2261 Table
*pTab
; /* Source table */
2262 int iTable
; /* Cursor number of the source table */
2263 int iColumn
; /* Column number within the source table */
2264 int iSorterColumn
; /* Column number in the sorting index */
2265 int iMem
; /* Memory location that acts as accumulator */
2266 Expr
*pExpr
; /* The original expression */
2268 int nColumn
; /* Number of used entries in aCol[] */
2269 int nAccumulator
; /* Number of columns that show through to the output.
2270 ** Additional columns are used only as parameters to
2271 ** aggregate functions */
2272 struct AggInfo_func
{ /* For each aggregate function */
2273 Expr
*pExpr
; /* Expression encoding the function */
2274 FuncDef
*pFunc
; /* The aggregate function implementation */
2275 int iMem
; /* Memory location that acts as accumulator */
2276 int iDistinct
; /* Ephemeral table used to enforce DISTINCT */
2278 int nFunc
; /* Number of entries in aFunc[] */
2282 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
2283 ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
2284 ** than 32767 we have to make it 32-bit. 16-bit is preferred because
2285 ** it uses less memory in the Expr object, which is a big memory user
2286 ** in systems with lots of prepared statements. And few applications
2287 ** need more than about 10 or 20 variables. But some extreme users want
2288 ** to have prepared statements with over 32767 variables, and for them
2289 ** the option is available (at compile-time).
2291 #if SQLITE_MAX_VARIABLE_NUMBER<=32767
2298 ** Each node of an expression in the parse tree is an instance
2299 ** of this structure.
2301 ** Expr.op is the opcode. The integer parser token codes are reused
2302 ** as opcodes here. For example, the parser defines TK_GE to be an integer
2303 ** code representing the ">=" operator. This same integer code is reused
2304 ** to represent the greater-than-or-equal-to operator in the expression
2307 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
2308 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
2309 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
2310 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
2311 ** then Expr.token contains the name of the function.
2313 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
2314 ** binary operator. Either or both may be NULL.
2316 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
2317 ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
2318 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
2319 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
2320 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
2323 ** An expression of the form ID or ID.ID refers to a column in a table.
2324 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
2325 ** the integer cursor number of a VDBE cursor pointing to that table and
2326 ** Expr.iColumn is the column number for the specific column. If the
2327 ** expression is used as a result in an aggregate SELECT, then the
2328 ** value is also stored in the Expr.iAgg column in the aggregate so that
2329 ** it can be accessed after all aggregates are computed.
2331 ** If the expression is an unbound variable marker (a question mark
2332 ** character '?' in the original SQL) then the Expr.iTable holds the index
2333 ** number for that variable.
2335 ** If the expression is a subquery then Expr.iColumn holds an integer
2336 ** register number containing the result of the subquery. If the
2337 ** subquery gives a constant result, then iTable is -1. If the subquery
2338 ** gives a different answer at different times during statement processing
2339 ** then iTable is the address of a subroutine that computes the subquery.
2341 ** If the Expr is of type OP_Column, and the table it is selecting from
2342 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
2343 ** corresponding table definition.
2345 ** ALLOCATION NOTES:
2347 ** Expr objects can use a lot of memory space in database schema. To
2348 ** help reduce memory requirements, sometimes an Expr object will be
2349 ** truncated. And to reduce the number of memory allocations, sometimes
2350 ** two or more Expr objects will be stored in a single memory allocation,
2351 ** together with Expr.zToken strings.
2353 ** If the EP_Reduced and EP_TokenOnly flags are set when
2354 ** an Expr object is truncated. When EP_Reduced is set, then all
2355 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
2356 ** are contained within the same memory allocation. Note, however, that
2357 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
2358 ** allocated, regardless of whether or not EP_Reduced is set.
2361 u8 op
; /* Operation performed by this node */
2362 char affinity
; /* The affinity of the column or 0 if not a column */
2363 u32 flags
; /* Various flags. EP_* See below */
2365 char *zToken
; /* Token value. Zero terminated and dequoted */
2366 int iValue
; /* Non-negative integer value if EP_IntValue */
2369 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
2370 ** space is allocated for the fields below this point. An attempt to
2371 ** access them will result in a segfault or malfunction.
2372 *********************************************************************/
2374 Expr
*pLeft
; /* Left subnode */
2375 Expr
*pRight
; /* Right subnode */
2377 ExprList
*pList
; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
2378 Select
*pSelect
; /* EP_xIsSelect and op = IN, EXISTS, SELECT */
2381 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
2382 ** space is allocated for the fields below this point. An attempt to
2383 ** access them will result in a segfault or malfunction.
2384 *********************************************************************/
2386 #if SQLITE_MAX_EXPR_DEPTH>0
2387 int nHeight
; /* Height of the tree headed by this node */
2389 int iTable
; /* TK_COLUMN: cursor number of table holding column
2390 ** TK_REGISTER: register number
2391 ** TK_TRIGGER: 1 -> new, 0 -> old
2392 ** EP_Unlikely: 134217728 times likelihood
2393 ** TK_SELECT: 1st register of result vector */
2394 ynVar iColumn
; /* TK_COLUMN: column index. -1 for rowid.
2395 ** TK_VARIABLE: variable number (always >= 1).
2396 ** TK_SELECT_COLUMN: column of the result vector */
2397 i16 iAgg
; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
2398 i16 iRightJoinTable
; /* If EP_FromJoin, the right table of the join */
2399 u8 op2
; /* TK_REGISTER: original value of Expr.op
2400 ** TK_COLUMN: the value of p5 for OP_Column
2401 ** TK_AGG_FUNCTION: nesting depth */
2402 AggInfo
*pAggInfo
; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
2403 Table
*pTab
; /* Table for TK_COLUMN expressions. Can be NULL
2404 ** for a column of an index on an expression */
2408 ** The following are the meanings of bits in the Expr.flags field.
2410 #define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */
2411 #define EP_Agg 0x000002 /* Contains one or more aggregate functions */
2412 #define EP_HasFunc 0x000004 /* Contains one or more functions of any kind */
2413 /* 0x000008 // available for use */
2414 #define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */
2415 #define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */
2416 #define EP_DblQuoted 0x000040 /* token.z was originally in "..." */
2417 #define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */
2418 #define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */
2419 #define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */
2420 #define EP_IntValue 0x000400 /* Integer value contained in u.iValue */
2421 #define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */
2422 #define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */
2423 #define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
2424 #define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
2425 #define EP_Static 0x008000 /* Held in memory not obtained from malloc() */
2426 #define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */
2427 #define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
2428 #define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */
2429 #define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
2430 #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
2431 #define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
2432 #define EP_Alias 0x400000 /* Is an alias for a result set column */
2433 #define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
2436 ** The EP_Propagate mask is a set of properties that automatically propagate
2437 ** upwards into parent nodes.
2439 #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)
2442 ** These macros can be used to test, set, or clear bits in the
2443 ** Expr.flags field.
2445 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
2446 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
2447 #define ExprSetProperty(E,P) (E)->flags|=(P)
2448 #define ExprClearProperty(E,P) (E)->flags&=~(P)
2450 /* The ExprSetVVAProperty() macro is used for Verification, Validation,
2451 ** and Accreditation only. It works like ExprSetProperty() during VVA
2452 ** processes but is a no-op for delivery.
2455 # define ExprSetVVAProperty(E,P) (E)->flags|=(P)
2457 # define ExprSetVVAProperty(E,P)
2461 ** Macros to determine the number of bytes required by a normal Expr
2462 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
2463 ** and an Expr struct with the EP_TokenOnly flag set.
2465 #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
2466 #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
2467 #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
2470 ** Flags passed to the sqlite3ExprDup() function. See the header comment
2471 ** above sqlite3ExprDup() for details.
2473 #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
2476 ** A list of expressions. Each expression may optionally have a
2477 ** name. An expr/name combination can be used in several ways, such
2478 ** as the list of "expr AS ID" fields following a "SELECT" or in the
2479 ** list of "ID = expr" items in an UPDATE. A list of expressions can
2480 ** also be used as the argument to a function, in which case the a.zName
2481 ** field is not used.
2483 ** By default the Expr.zSpan field holds a human-readable description of
2484 ** the expression that is used in the generation of error messages and
2485 ** column labels. In this case, Expr.zSpan is typically the text of a
2486 ** column expression as it exists in a SELECT statement. However, if
2487 ** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
2488 ** of the result column in the form: DATABASE.TABLE.COLUMN. This later
2489 ** form is used for name resolution with nested FROM clauses.
2492 int nExpr
; /* Number of expressions on the list */
2493 struct ExprList_item
{ /* For each expression in the list */
2494 Expr
*pExpr
; /* The parse tree for this expression */
2495 char *zName
; /* Token associated with this expression */
2496 char *zSpan
; /* Original text of the expression */
2497 u8 sortOrder
; /* 1 for DESC or 0 for ASC */
2498 unsigned done
:1; /* A flag to indicate when processing is finished */
2499 unsigned bSpanIsTab
:1; /* zSpan holds DB.TABLE.COLUMN */
2500 unsigned reusable
:1; /* Constant expression is reusable */
2503 u16 iOrderByCol
; /* For ORDER BY, column number in result set */
2504 u16 iAlias
; /* Index into Parse.aAlias[] for zName */
2506 int iConstExprReg
; /* Register in which Expr value is cached */
2508 } a
[1]; /* One slot for each expression in the list */
2512 ** An instance of this structure can hold a simple list of identifiers,
2513 ** such as the list "a,b,c" in the following statements:
2515 ** INSERT INTO t(a,b,c) VALUES ...;
2516 ** CREATE INDEX idx ON t(a,b,c);
2517 ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
2519 ** The IdList.a.idx field is used when the IdList represents the list of
2520 ** column names after a table name in an INSERT statement. In the statement
2522 ** INSERT INTO t(a,b,c) ...
2524 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
2527 struct IdList_item
{
2528 char *zName
; /* Name of the identifier */
2529 int idx
; /* Index in some Table.aCol[] of a column named zName */
2531 int nId
; /* Number of identifiers on the list */
2535 ** The bitmask datatype defined below is used for various optimizations.
2537 ** Changing this from a 64-bit to a 32-bit type limits the number of
2538 ** tables in a join to 32 instead of 64. But it also reduces the size
2539 ** of the library by 738 bytes on ix86.
2541 #ifdef SQLITE_BITMASK_TYPE
2542 typedef SQLITE_BITMASK_TYPE Bitmask
;
2544 typedef u64 Bitmask
;
2548 ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
2550 #define BMS ((int)(sizeof(Bitmask)*8))
2553 ** A bit in a Bitmask
2555 #define MASKBIT(n) (((Bitmask)1)<<(n))
2556 #define MASKBIT32(n) (((unsigned int)1)<<(n))
2557 #define ALLBITS ((Bitmask)-1)
2560 ** The following structure describes the FROM clause of a SELECT statement.
2561 ** Each table or subquery in the FROM clause is a separate element of
2562 ** the SrcList.a[] array.
2564 ** With the addition of multiple database support, the following structure
2565 ** can also be used to describe a particular table such as the table that
2566 ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
2567 ** such a table must be a simple name: ID. But in SQLite, the table can
2568 ** now be identified by a database name, a dot, then the table name: ID.ID.
2570 ** The jointype starts out showing the join type between the current table
2571 ** and the next table on the list. The parser builds the list this way.
2572 ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
2573 ** jointype expresses the join between the table and the previous table.
2575 ** In the colUsed field, the high-order bit (bit 63) is set if the table
2576 ** contains more than 63 columns and the 64-th or later column is used.
2579 int nSrc
; /* Number of tables or subqueries in the FROM clause */
2580 u32 nAlloc
; /* Number of entries allocated in a[] below */
2581 struct SrcList_item
{
2582 Schema
*pSchema
; /* Schema to which this item is fixed */
2583 char *zDatabase
; /* Name of database holding this table */
2584 char *zName
; /* Name of the table */
2585 char *zAlias
; /* The "B" part of a "A AS B" phrase. zName is the "A" */
2586 Table
*pTab
; /* An SQL table corresponding to zName */
2587 Select
*pSelect
; /* A SELECT statement used in place of a table name */
2588 int addrFillSub
; /* Address of subroutine to manifest a subquery */
2589 int regReturn
; /* Register holding return address of addrFillSub */
2590 int regResult
; /* Registers holding results of a co-routine */
2592 u8 jointype
; /* Type of join between this table and the previous */
2593 unsigned notIndexed
:1; /* True if there is a NOT INDEXED clause */
2594 unsigned isIndexedBy
:1; /* True if there is an INDEXED BY clause */
2595 unsigned isTabFunc
:1; /* True if table-valued-function syntax */
2596 unsigned isCorrelated
:1; /* True if sub-query is correlated */
2597 unsigned viaCoroutine
:1; /* Implemented as a co-routine */
2598 unsigned isRecursive
:1; /* True for recursive reference in WITH */
2600 #ifndef SQLITE_OMIT_EXPLAIN
2601 u8 iSelectId
; /* If pSelect!=0, the id of the sub-select in EQP */
2603 int iCursor
; /* The VDBE cursor number used to access this table */
2604 Expr
*pOn
; /* The ON clause of a join */
2605 IdList
*pUsing
; /* The USING clause of a join */
2606 Bitmask colUsed
; /* Bit N (1<<N) set if column N of pTab is used */
2608 char *zIndexedBy
; /* Identifier from "INDEXED BY <zIndex>" clause */
2609 ExprList
*pFuncArg
; /* Arguments to table-valued-function */
2611 Index
*pIBIndex
; /* Index structure corresponding to u1.zIndexedBy */
2612 } a
[1]; /* One entry for each identifier on the list */
2616 ** Permitted values of the SrcList.a.jointype field
2618 #define JT_INNER 0x0001 /* Any kind of inner or cross join */
2619 #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
2620 #define JT_NATURAL 0x0004 /* True for a "natural" join */
2621 #define JT_LEFT 0x0008 /* Left outer join */
2622 #define JT_RIGHT 0x0010 /* Right outer join */
2623 #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
2624 #define JT_ERROR 0x0040 /* unknown or unsupported join type */
2628 ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
2629 ** and the WhereInfo.wctrlFlags member.
2631 ** Value constraints (enforced via assert()):
2632 ** WHERE_USE_LIMIT == SF_FixedLimit
2634 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
2635 #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
2636 #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
2637 #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
2638 #define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
2639 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
2640 #define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
2641 ** the OR optimization */
2642 #define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */
2643 #define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */
2644 #define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */
2645 #define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
2646 #define WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */
2647 #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
2648 #define WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */
2649 /* 0x2000 not currently used */
2650 #define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
2651 /* 0x8000 not currently used */
2653 /* Allowed return values from sqlite3WhereIsDistinct()
2655 #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
2656 #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */
2657 #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */
2658 #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */
2661 ** A NameContext defines a context in which to resolve table and column
2662 ** names. The context consists of a list of tables (the pSrcList) field and
2663 ** a list of named expression (pEList). The named expression list may
2664 ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
2665 ** to the table being operated on by INSERT, UPDATE, or DELETE. The
2666 ** pEList corresponds to the result set of a SELECT and is NULL for
2667 ** other statements.
2669 ** NameContexts can be nested. When resolving names, the inner-most
2670 ** context is searched first. If no match is found, the next outer
2671 ** context is checked. If there is still no match, the next context
2672 ** is checked. This process continues until either a match is found
2673 ** or all contexts are check. When a match is found, the nRef member of
2674 ** the context containing the match is incremented.
2676 ** Each subquery gets a new NameContext. The pNext field points to the
2677 ** NameContext in the parent query. Thus the process of scanning the
2678 ** NameContext list corresponds to searching through successively outer
2679 ** subqueries looking for a match.
2681 struct NameContext
{
2682 Parse
*pParse
; /* The parser */
2683 SrcList
*pSrcList
; /* One or more tables used to resolve names */
2684 ExprList
*pEList
; /* Optional list of result-set columns */
2685 AggInfo
*pAggInfo
; /* Information about aggregates at this level */
2686 NameContext
*pNext
; /* Next outer name context. NULL for outermost */
2687 int nRef
; /* Number of names resolved by this context */
2688 int nErr
; /* Number of errors encountered while resolving names */
2689 u16 ncFlags
; /* Zero or more NC_* flags defined below */
2693 ** Allowed values for the NameContext, ncFlags field.
2695 ** Value constraints (all checked via assert()):
2696 ** NC_HasAgg == SF_HasAgg
2697 ** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
2700 #define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */
2701 #define NC_PartIdx 0x0002 /* True if resolving a partial index WHERE */
2702 #define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */
2703 #define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */
2704 #define NC_HasAgg 0x0010 /* One or more aggregate functions seen */
2705 #define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */
2706 #define NC_VarSelect 0x0040 /* A correlated subquery has been seen */
2707 #define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */
2708 #define NC_Complex 0x2000 /* True if a function or subquery seen */
2711 ** An instance of the following structure contains all information
2712 ** needed to generate code for a single SELECT statement.
2714 ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
2715 ** If there is a LIMIT clause, the parser sets nLimit to the value of the
2716 ** limit and nOffset to the value of the offset (or 0 if there is not
2717 ** offset). But later on, nLimit and nOffset become the memory locations
2718 ** in the VDBE that record the limit and offset counters.
2720 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
2721 ** These addresses must be stored so that we can go back and fill in
2722 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
2723 ** the number of columns in P2 can be computed at the same time
2724 ** as the OP_OpenEphm instruction is coded because not
2725 ** enough information about the compound query is known at that point.
2726 ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
2727 ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
2728 ** sequences for the ORDER BY clause.
2731 ExprList
*pEList
; /* The fields of the result */
2732 u8 op
; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
2733 LogEst nSelectRow
; /* Estimated number of result rows */
2734 u32 selFlags
; /* Various SF_* values */
2735 int iLimit
, iOffset
; /* Memory registers holding LIMIT & OFFSET counters */
2736 #if SELECTTRACE_ENABLED
2737 char zSelName
[12]; /* Symbolic name of this SELECT use for debugging */
2739 int addrOpenEphm
[2]; /* OP_OpenEphem opcodes related to this select */
2740 SrcList
*pSrc
; /* The FROM clause */
2741 Expr
*pWhere
; /* The WHERE clause */
2742 ExprList
*pGroupBy
; /* The GROUP BY clause */
2743 Expr
*pHaving
; /* The HAVING clause */
2744 ExprList
*pOrderBy
; /* The ORDER BY clause */
2745 Select
*pPrior
; /* Prior select in a compound select statement */
2746 Select
*pNext
; /* Next select to the left in a compound */
2747 Expr
*pLimit
; /* LIMIT expression. NULL means not used. */
2748 With
*pWith
; /* WITH clause attached to this select. Or NULL. */
2752 ** Allowed values for Select.selFlags. The "SF" prefix stands for
2755 ** Value constraints (all checked via assert())
2756 ** SF_HasAgg == NC_HasAgg
2757 ** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX
2758 ** SF_FixedLimit == WHERE_USE_LIMIT
2760 #define SF_Distinct 0x00001 /* Output should be DISTINCT */
2761 #define SF_All 0x00002 /* Includes the ALL keyword */
2762 #define SF_Resolved 0x00004 /* Identifiers have been resolved */
2763 #define SF_Aggregate 0x00008 /* Contains agg functions or a GROUP BY */
2764 #define SF_HasAgg 0x00010 /* Contains aggregate functions */
2765 #define SF_UsesEphemeral 0x00020 /* Uses the OpenEphemeral opcode */
2766 #define SF_Expanded 0x00040 /* sqlite3SelectExpand() called on this */
2767 #define SF_HasTypeInfo 0x00080 /* FROM subqueries have Table metadata */
2768 #define SF_Compound 0x00100 /* Part of a compound query */
2769 #define SF_Values 0x00200 /* Synthesized from VALUES clause */
2770 #define SF_MultiValue 0x00400 /* Single VALUES term with multiple rows */
2771 #define SF_NestedFrom 0x00800 /* Part of a parenthesized FROM clause */
2772 #define SF_MinMaxAgg 0x01000 /* Aggregate containing min() or max() */
2773 #define SF_Recursive 0x02000 /* The recursive part of a recursive CTE */
2774 #define SF_FixedLimit 0x04000 /* nSelectRow set by a constant LIMIT */
2775 #define SF_MaybeConvert 0x08000 /* Need convertCompoundSelectToSubquery() */
2776 #define SF_Converted 0x10000 /* By convertCompoundSelectToSubquery() */
2777 #define SF_IncludeHidden 0x20000 /* Include hidden columns in output */
2778 #define SF_ComplexResult 0x40000 /* Result set contains subquery or function */
2782 ** The results of a SELECT can be distributed in several ways, as defined
2783 ** by one of the following macros. The "SRT" prefix means "SELECT Result
2786 ** SRT_Union Store results as a key in a temporary index
2787 ** identified by pDest->iSDParm.
2789 ** SRT_Except Remove results from the temporary index pDest->iSDParm.
2791 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
2792 ** set is not empty.
2794 ** SRT_Discard Throw the results away. This is used by SELECT
2795 ** statements within triggers whose only purpose is
2796 ** the side-effects of functions.
2798 ** All of the above are free to ignore their ORDER BY clause. Those that
2799 ** follow must honor the ORDER BY clause.
2801 ** SRT_Output Generate a row of output (using the OP_ResultRow
2802 ** opcode) for each row in the result set.
2804 ** SRT_Mem Only valid if the result is a single column.
2805 ** Store the first column of the first result row
2806 ** in register pDest->iSDParm then abandon the rest
2807 ** of the query. This destination implies "LIMIT 1".
2809 ** SRT_Set The result must be a single column. Store each
2810 ** row of result as the key in table pDest->iSDParm.
2811 ** Apply the affinity pDest->affSdst before storing
2812 ** results. Used to implement "IN (SELECT ...)".
2814 ** SRT_EphemTab Create an temporary table pDest->iSDParm and store
2815 ** the result there. The cursor is left open after
2816 ** returning. This is like SRT_Table except that
2817 ** this destination uses OP_OpenEphemeral to create
2820 ** SRT_Coroutine Generate a co-routine that returns a new row of
2821 ** results each time it is invoked. The entry point
2822 ** of the co-routine is stored in register pDest->iSDParm
2823 ** and the result row is stored in pDest->nDest registers
2824 ** starting with pDest->iSdst.
2826 ** SRT_Table Store results in temporary table pDest->iSDParm.
2827 ** SRT_Fifo This is like SRT_EphemTab except that the table
2828 ** is assumed to already be open. SRT_Fifo has
2829 ** the additional property of being able to ignore
2830 ** the ORDER BY clause.
2832 ** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
2833 ** But also use temporary table pDest->iSDParm+1 as
2834 ** a record of all prior results and ignore any duplicate
2835 ** rows. Name means: "Distinct Fifo".
2837 ** SRT_Queue Store results in priority queue pDest->iSDParm (really
2838 ** an index). Append a sequence number so that all entries
2841 ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
2842 ** the same record has never been stored before. The
2843 ** index at pDest->iSDParm+1 hold all prior stores.
2845 #define SRT_Union 1 /* Store result as keys in an index */
2846 #define SRT_Except 2 /* Remove result from a UNION index */
2847 #define SRT_Exists 3 /* Store 1 if the result is not empty */
2848 #define SRT_Discard 4 /* Do not save the results anywhere */
2849 #define SRT_Fifo 5 /* Store result as data with an automatic rowid */
2850 #define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */
2851 #define SRT_Queue 7 /* Store result in an queue */
2852 #define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */
2854 /* The ORDER BY clause is ignored for all of the above */
2855 #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)
2857 #define SRT_Output 9 /* Output each row of result */
2858 #define SRT_Mem 10 /* Store result in a memory cell */
2859 #define SRT_Set 11 /* Store results as keys in an index */
2860 #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */
2861 #define SRT_Coroutine 13 /* Generate a single row of result */
2862 #define SRT_Table 14 /* Store result as data with an automatic rowid */
2865 ** An instance of this object describes where to put of the results of
2866 ** a SELECT statement.
2869 u8 eDest
; /* How to dispose of the results. On of SRT_* above. */
2870 int iSDParm
; /* A parameter used by the eDest disposal method */
2871 int iSdst
; /* Base register where results are written */
2872 int nSdst
; /* Number of registers allocated */
2873 char *zAffSdst
; /* Affinity used when eDest==SRT_Set */
2874 ExprList
*pOrderBy
; /* Key columns for SRT_Queue and SRT_DistQueue */
2878 ** During code generation of statements that do inserts into AUTOINCREMENT
2879 ** tables, the following information is attached to the Table.u.autoInc.p
2880 ** pointer of each autoincrement table to record some side information that
2881 ** the code generator needs. We have to keep per-table autoincrement
2882 ** information in case inserts are done within triggers. Triggers do not
2883 ** normally coordinate their activities, but we do need to coordinate the
2884 ** loading and saving of autoincrement information.
2886 struct AutoincInfo
{
2887 AutoincInfo
*pNext
; /* Next info block in a list of them all */
2888 Table
*pTab
; /* Table this info block refers to */
2889 int iDb
; /* Index in sqlite3.aDb[] of database holding pTab */
2890 int regCtr
; /* Memory register holding the rowid counter */
2894 ** Size of the column cache
2896 #ifndef SQLITE_N_COLCACHE
2897 # define SQLITE_N_COLCACHE 10
2901 ** At least one instance of the following structure is created for each
2902 ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
2903 ** statement. All such objects are stored in the linked list headed at
2904 ** Parse.pTriggerPrg and deleted once statement compilation has been
2907 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
2908 ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
2909 ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
2910 ** The Parse.pTriggerPrg list never contains two entries with the same
2911 ** values for both pTrigger and orconf.
2913 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
2914 ** accessed (or set to 0 for triggers fired as a result of INSERT
2915 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
2916 ** a mask of new.* columns used by the program.
2919 Trigger
*pTrigger
; /* Trigger this program was coded from */
2920 TriggerPrg
*pNext
; /* Next entry in Parse.pTriggerPrg list */
2921 SubProgram
*pProgram
; /* Program implementing pTrigger/orconf */
2922 int orconf
; /* Default ON CONFLICT policy */
2923 u32 aColmask
[2]; /* Masks of old.*, new.* columns accessed */
2927 ** The yDbMask datatype for the bitmask of all attached databases.
2929 #if SQLITE_MAX_ATTACHED>30
2930 typedef unsigned char yDbMask
[(SQLITE_MAX_ATTACHED
+9)/8];
2931 # define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0)
2932 # define DbMaskZero(M) memset((M),0,sizeof(M))
2933 # define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7))
2934 # define DbMaskAllZero(M) sqlite3DbMaskAllZero(M)
2935 # define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0)
2937 typedef unsigned int yDbMask
;
2938 # define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0)
2939 # define DbMaskZero(M) (M)=0
2940 # define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I))
2941 # define DbMaskAllZero(M) (M)==0
2942 # define DbMaskNonZero(M) (M)!=0
2946 ** An SQL parser context. A copy of this structure is passed through
2947 ** the parser and down into all the parser action routine in order to
2948 ** carry around information that is global to the entire parse.
2950 ** The structure is divided into two parts. When the parser and code
2951 ** generate call themselves recursively, the first part of the structure
2952 ** is constant but the second part is reset at the beginning and end of
2955 ** The nTableLock and aTableLock variables are only used if the shared-cache
2956 ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
2957 ** used to store the set of table-locks required by the statement being
2958 ** compiled. Function sqlite3TableLock() is used to add entries to the
2962 sqlite3
*db
; /* The main database structure */
2963 char *zErrMsg
; /* An error message */
2964 Vdbe
*pVdbe
; /* An engine for executing database bytecode */
2965 int rc
; /* Return code from execution */
2966 u8 colNamesSet
; /* TRUE after OP_ColumnName has been issued to pVdbe */
2967 u8 checkSchema
; /* Causes schema cookie check after an error */
2968 u8 nested
; /* Number of nested calls to the parser/code generator */
2969 u8 nTempReg
; /* Number of temporary registers in aTempReg[] */
2970 u8 isMultiWrite
; /* True if statement may modify/insert multiple rows */
2971 u8 mayAbort
; /* True if statement may throw an ABORT exception */
2972 u8 hasCompound
; /* Need to invoke convertCompoundSelectToSubquery() */
2973 u8 okConstFactor
; /* OK to factor out constants */
2974 u8 disableLookaside
; /* Number of times lookaside has been disabled */
2975 u8 nColCache
; /* Number of entries in aColCache[] */
2976 int nRangeReg
; /* Size of the temporary register block */
2977 int iRangeReg
; /* First register in temporary register block */
2978 int nErr
; /* Number of errors seen */
2979 int nTab
; /* Number of previously allocated VDBE cursors */
2980 int nMem
; /* Number of memory cells used so far */
2981 int nOpAlloc
; /* Number of slots allocated for Vdbe.aOp[] */
2982 int szOpAlloc
; /* Bytes of memory space allocated for Vdbe.aOp[] */
2983 int iSelfTab
; /* Table associated with an index on expr, or negative
2984 ** of the base register during check-constraint eval */
2985 int iCacheLevel
; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
2986 int iCacheCnt
; /* Counter used to generate aColCache[].lru values */
2987 int nLabel
; /* Number of labels used */
2988 int *aLabel
; /* Space to hold the labels */
2989 ExprList
*pConstExpr
;/* Constant expressions */
2990 Token constraintName
;/* Name of the constraint currently being parsed */
2991 yDbMask writeMask
; /* Start a write transaction on these databases */
2992 yDbMask cookieMask
; /* Bitmask of schema verified databases */
2993 int regRowid
; /* Register holding rowid of CREATE TABLE entry */
2994 int regRoot
; /* Register holding root page number for new objects */
2995 int nMaxArg
; /* Max args passed to user function by sub-program */
2996 #if SELECTTRACE_ENABLED
2997 int nSelect
; /* Number of SELECT statements seen */
2999 #ifndef SQLITE_OMIT_SHARED_CACHE
3000 int nTableLock
; /* Number of locks in aTableLock */
3001 TableLock
*aTableLock
; /* Required table locks for shared-cache mode */
3003 AutoincInfo
*pAinc
; /* Information about AUTOINCREMENT counters */
3004 Parse
*pToplevel
; /* Parse structure for main program (or NULL) */
3005 Table
*pTriggerTab
; /* Table triggers are being coded for */
3006 int addrCrTab
; /* Address of OP_CreateBtree opcode on CREATE TABLE */
3007 u32 nQueryLoop
; /* Est number of iterations of a query (10*log2(N)) */
3008 u32 oldmask
; /* Mask of old.* columns referenced */
3009 u32 newmask
; /* Mask of new.* columns referenced */
3010 u8 eTriggerOp
; /* TK_UPDATE, TK_INSERT or TK_DELETE */
3011 u8 eOrconf
; /* Default ON CONFLICT policy for trigger steps */
3012 u8 disableTriggers
; /* True to disable triggers */
3014 /**************************************************************************
3015 ** Fields above must be initialized to zero. The fields that follow,
3016 ** down to the beginning of the recursive section, do not need to be
3017 ** initialized as they will be set before being used. The boundary is
3018 ** determined by offsetof(Parse,aColCache).
3019 **************************************************************************/
3022 int iTable
; /* Table cursor number */
3023 i16 iColumn
; /* Table column number */
3024 u8 tempReg
; /* iReg is a temp register that needs to be freed */
3025 int iLevel
; /* Nesting level */
3026 int iReg
; /* Reg with value of this column. 0 means none. */
3027 int lru
; /* Least recently used entry has the smallest value */
3028 } aColCache
[SQLITE_N_COLCACHE
]; /* One for each column cache entry */
3029 int aTempReg
[8]; /* Holding area for temporary registers */
3030 Token sNameToken
; /* Token with unqualified schema object name */
3032 /************************************************************************
3033 ** Above is constant between recursions. Below is reset before and after
3034 ** each recursion. The boundary between these two regions is determined
3035 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
3036 ** first field in the recursive region.
3037 ************************************************************************/
3039 Token sLastToken
; /* The last token parsed */
3040 ynVar nVar
; /* Number of '?' variables seen in the SQL so far */
3041 u8 iPkSortOrder
; /* ASC or DESC for INTEGER PRIMARY KEY */
3042 u8 explain
; /* True if the EXPLAIN flag is found on the query */
3043 #ifndef SQLITE_OMIT_VIRTUALTABLE
3044 u8 declareVtab
; /* True if inside sqlite3_declare_vtab() */
3045 int nVtabLock
; /* Number of virtual tables to lock */
3047 int nHeight
; /* Expression tree height of current sub-select */
3048 #ifndef SQLITE_OMIT_EXPLAIN
3049 int iSelectId
; /* ID of current select for EXPLAIN output */
3050 int iNextSelectId
; /* Next available select ID for EXPLAIN output */
3052 VList
*pVList
; /* Mapping between variable names and numbers */
3053 Vdbe
*pReprepare
; /* VM being reprepared (sqlite3Reprepare()) */
3054 const char *zTail
; /* All SQL text past the last semicolon parsed */
3055 Table
*pNewTable
; /* A table being constructed by CREATE TABLE */
3056 Trigger
*pNewTrigger
; /* Trigger under construct by a CREATE TRIGGER */
3057 const char *zAuthContext
; /* The 6th parameter to db->xAuth callbacks */
3058 #ifndef SQLITE_OMIT_VIRTUALTABLE
3059 Token sArg
; /* Complete text of a module argument */
3060 Table
**apVtabLock
; /* Pointer to virtual tables needing locking */
3062 Table
*pZombieTab
; /* List of Table objects to delete after code gen */
3063 TriggerPrg
*pTriggerPrg
; /* Linked list of coded triggers */
3064 With
*pWith
; /* Current WITH clause, or NULL */
3065 With
*pWithToFree
; /* Free this WITH object at the end of the parse */
3069 ** Sizes and pointers of various parts of the Parse object.
3071 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
3072 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
3073 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
3074 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
3077 ** Return true if currently inside an sqlite3_declare_vtab() call.
3079 #ifdef SQLITE_OMIT_VIRTUALTABLE
3080 #define IN_DECLARE_VTAB 0
3082 #define IN_DECLARE_VTAB (pParse->declareVtab)
3086 ** An instance of the following structure can be declared on a stack and used
3087 ** to save the Parse.zAuthContext value so that it can be restored later.
3089 struct AuthContext
{
3090 const char *zAuthContext
; /* Put saved Parse.zAuthContext here */
3091 Parse
*pParse
; /* The Parse structure */
3095 ** Bitfield flags for P5 value in various opcodes.
3097 ** Value constraints (enforced via assert()):
3098 ** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH
3099 ** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF
3100 ** OPFLAG_BULKCSR == BTREE_BULKLOAD
3101 ** OPFLAG_SEEKEQ == BTREE_SEEK_EQ
3102 ** OPFLAG_FORDELETE == BTREE_FORDELETE
3103 ** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
3104 ** OPFLAG_AUXDELETE == BTREE_AUXDELETE
3106 #define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
3107 /* Also used in P2 (not P5) of OP_Delete */
3108 #define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
3109 #define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
3110 #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
3111 #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
3112 #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
3113 #define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
3114 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
3115 #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
3116 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
3117 #define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
3118 #define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
3119 #define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
3120 #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
3121 #define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */
3122 #define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */
3123 #define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */
3126 * Each trigger present in the database schema is stored as an instance of
3129 * Pointers to instances of struct Trigger are stored in two ways.
3130 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
3131 * database). This allows Trigger structures to be retrieved by name.
3132 * 2. All triggers associated with a single table form a linked list, using the
3133 * pNext member of struct Trigger. A pointer to the first element of the
3134 * linked list is stored as the "pTrigger" member of the associated
3137 * The "step_list" member points to the first element of a linked list
3138 * containing the SQL statements specified as the trigger program.
3141 char *zName
; /* The name of the trigger */
3142 char *table
; /* The table or view to which the trigger applies */
3143 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
3144 u8 tr_tm
; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
3145 Expr
*pWhen
; /* The WHEN clause of the expression (may be NULL) */
3146 IdList
*pColumns
; /* If this is an UPDATE OF <column-list> trigger,
3147 the <column-list> is stored here */
3148 Schema
*pSchema
; /* Schema containing the trigger */
3149 Schema
*pTabSchema
; /* Schema containing the table */
3150 TriggerStep
*step_list
; /* Link list of trigger program steps */
3151 Trigger
*pNext
; /* Next trigger associated with the table */
3155 ** A trigger is either a BEFORE or an AFTER trigger. The following constants
3158 ** If there are multiple triggers, you might of some BEFORE and some AFTER.
3159 ** In that cases, the constants below can be ORed together.
3161 #define TRIGGER_BEFORE 1
3162 #define TRIGGER_AFTER 2
3165 * An instance of struct TriggerStep is used to store a single SQL statement
3166 * that is a part of a trigger-program.
3168 * Instances of struct TriggerStep are stored in a singly linked list (linked
3169 * using the "pNext" member) referenced by the "step_list" member of the
3170 * associated struct Trigger instance. The first element of the linked list is
3171 * the first step of the trigger-program.
3173 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
3174 * "SELECT" statement. The meanings of the other members is determined by the
3175 * value of "op" as follows:
3178 * orconf -> stores the ON CONFLICT algorithm
3179 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
3180 * this stores a pointer to the SELECT statement. Otherwise NULL.
3181 * zTarget -> Dequoted name of the table to insert into.
3182 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
3183 * this stores values to be inserted. Otherwise NULL.
3184 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
3185 * statement, then this stores the column-names to be
3189 * zTarget -> Dequoted name of the table to delete from.
3190 * pWhere -> The WHERE clause of the DELETE statement if one is specified.
3194 * zTarget -> Dequoted name of the table to update.
3195 * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
3197 * pExprList -> A list of the columns to update and the expressions to update
3198 * them to. See sqlite3Update() documentation of "pChanges"
3202 struct TriggerStep
{
3203 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
3204 u8 orconf
; /* OE_Rollback etc. */
3205 Trigger
*pTrig
; /* The trigger that this step is a part of */
3206 Select
*pSelect
; /* SELECT statement or RHS of INSERT INTO SELECT ... */
3207 char *zTarget
; /* Target table for DELETE, UPDATE, INSERT */
3208 Expr
*pWhere
; /* The WHERE clause for DELETE or UPDATE steps */
3209 ExprList
*pExprList
; /* SET clause for UPDATE. */
3210 IdList
*pIdList
; /* Column names for INSERT */
3211 char *zSpan
; /* Original SQL text of this command */
3212 TriggerStep
*pNext
; /* Next in the link-list */
3213 TriggerStep
*pLast
; /* Last element in link-list. Valid for 1st elem only */
3217 ** The following structure contains information used by the sqliteFix...
3218 ** routines as they walk the parse tree to make database references
3221 typedef struct DbFixer DbFixer
;
3223 Parse
*pParse
; /* The parsing context. Error messages written here */
3224 Schema
*pSchema
; /* Fix items to this schema */
3225 int bVarOnly
; /* Check for variable references only */
3226 const char *zDb
; /* Make sure all objects are contained in this database */
3227 const char *zType
; /* Type of the container - used for error messages */
3228 const Token
*pName
; /* Name of the container - used for error messages */
3232 ** An objected used to accumulate the text of a string where we
3233 ** do not necessarily know how big the string will be in the end.
3236 sqlite3
*db
; /* Optional database for lookaside. Can be NULL */
3237 char *zText
; /* The string collected so far */
3238 u32 nAlloc
; /* Amount of space allocated in zText */
3239 u32 mxAlloc
; /* Maximum allowed allocation. 0 for no malloc usage */
3240 u32 nChar
; /* Length of the string so far */
3241 u8 accError
; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
3242 u8 printfFlags
; /* SQLITE_PRINTF flags below */
3244 #define STRACCUM_NOMEM 1
3245 #define STRACCUM_TOOBIG 2
3246 #define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
3247 #define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */
3248 #define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */
3250 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
3254 ** A pointer to this structure is used to communicate information
3255 ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
3258 sqlite3
*db
; /* The database being initialized */
3259 char **pzErrMsg
; /* Error message stored here */
3260 int iDb
; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
3261 int rc
; /* Result code stored here */
3265 ** Structure containing global configuration data for the SQLite library.
3267 ** This structure also contains some state information.
3269 struct Sqlite3Config
{
3270 int bMemstat
; /* True to enable memory status */
3271 int bCoreMutex
; /* True to enable core mutexing */
3272 int bFullMutex
; /* True to enable full mutexing */
3273 int bOpenUri
; /* True to interpret filenames as URIs */
3274 int bUseCis
; /* Use covering indices for full-scans */
3275 int bSmallMalloc
; /* Avoid large memory allocations if true */
3276 int mxStrlen
; /* Maximum string length */
3277 int neverCorrupt
; /* Database is always well-formed */
3278 int szLookaside
; /* Default lookaside buffer size */
3279 int nLookaside
; /* Default lookaside buffer count */
3280 int nStmtSpill
; /* Stmt-journal spill-to-disk threshold */
3281 sqlite3_mem_methods m
; /* Low-level memory allocation interface */
3282 sqlite3_mutex_methods mutex
; /* Low-level mutex interface */
3283 sqlite3_pcache_methods2 pcache2
; /* Low-level page-cache interface */
3284 void *pHeap
; /* Heap storage space */
3285 int nHeap
; /* Size of pHeap[] */
3286 int mnReq
, mxReq
; /* Min and max heap requests sizes */
3287 sqlite3_int64 szMmap
; /* mmap() space per open file */
3288 sqlite3_int64 mxMmap
; /* Maximum value for szMmap */
3289 void *pPage
; /* Page cache memory */
3290 int szPage
; /* Size of each page in pPage[] */
3291 int nPage
; /* Number of pages in pPage[] */
3292 int mxParserStack
; /* maximum depth of the parser stack */
3293 int sharedCacheEnabled
; /* true if shared-cache mode enabled */
3294 u32 szPma
; /* Maximum Sorter PMA size */
3295 /* The above might be initialized to non-zero. The following need to always
3296 ** initially be zero, however. */
3297 int isInit
; /* True after initialization has finished */
3298 int inProgress
; /* True while initialization in progress */
3299 int isMutexInit
; /* True after mutexes are initialized */
3300 int isMallocInit
; /* True after malloc is initialized */
3301 int isPCacheInit
; /* True after malloc is initialized */
3302 int nRefInitMutex
; /* Number of users of pInitMutex */
3303 sqlite3_mutex
*pInitMutex
; /* Mutex used by sqlite3_initialize() */
3304 void (*xLog
)(void*,int,const char*); /* Function for logging */
3305 void *pLogArg
; /* First argument to xLog() */
3306 #ifdef SQLITE_ENABLE_SQLLOG
3307 void(*xSqllog
)(void*,sqlite3
*,const char*, int);
3310 #ifdef SQLITE_VDBE_COVERAGE
3311 /* The following callback (if not NULL) is invoked on every VDBE branch
3312 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
3314 void (*xVdbeBranch
)(void*,int iSrcLine
,u8 eThis
,u8 eMx
); /* Callback */
3315 void *pVdbeBranchArg
; /* 1st argument */
3317 #ifndef SQLITE_UNTESTABLE
3318 int (*xTestCallback
)(int); /* Invoked by sqlite3FaultSim() */
3320 int bLocaltimeFault
; /* True to fail localtime() calls */
3321 int iOnceResetThreshold
; /* When to reset OP_Once counters */
3325 ** This macro is used inside of assert() statements to indicate that
3326 ** the assert is only valid on a well-formed database. Instead of:
3332 ** assert( X || CORRUPT_DB );
3334 ** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate
3335 ** that the database is definitely corrupt, only that it might be corrupt.
3336 ** For most test cases, CORRUPT_DB is set to false using a special
3337 ** sqlite3_test_control(). This enables assert() statements to prove
3338 ** things that are always true for well-formed databases.
3340 #define CORRUPT_DB (sqlite3Config.neverCorrupt==0)
3343 ** Context pointer passed down through the tree-walk.
3346 Parse
*pParse
; /* Parser context. */
3347 int (*xExprCallback
)(Walker
*, Expr
*); /* Callback for expressions */
3348 int (*xSelectCallback
)(Walker
*,Select
*); /* Callback for SELECTs */
3349 void (*xSelectCallback2
)(Walker
*,Select
*);/* Second callback for SELECTs */
3350 int walkerDepth
; /* Number of subqueries */
3351 u8 eCode
; /* A small processing code */
3352 union { /* Extra data for callback */
3353 NameContext
*pNC
; /* Naming context */
3354 int n
; /* A counter */
3355 int iCur
; /* A cursor number */
3356 SrcList
*pSrcList
; /* FROM clause */
3357 struct SrcCount
*pSrcCount
; /* Counting column references */
3358 struct CCurHint
*pCCurHint
; /* Used by codeCursorHint() */
3359 int *aiCol
; /* array of column indexes */
3360 struct IdxCover
*pIdxCover
; /* Check for index coverage */
3361 struct IdxExprTrans
*pIdxTrans
; /* Convert idxed expr to column */
3362 ExprList
*pGroupBy
; /* GROUP BY clause */
3363 Select
*pSelect
; /* HAVING to WHERE clause ctx */
3367 /* Forward declarations */
3368 int sqlite3WalkExpr(Walker
*, Expr
*);
3369 int sqlite3WalkExprList(Walker
*, ExprList
*);
3370 int sqlite3WalkSelect(Walker
*, Select
*);
3371 int sqlite3WalkSelectExpr(Walker
*, Select
*);
3372 int sqlite3WalkSelectFrom(Walker
*, Select
*);
3373 int sqlite3ExprWalkNoop(Walker
*, Expr
*);
3374 int sqlite3SelectWalkNoop(Walker
*, Select
*);
3375 int sqlite3SelectWalkFail(Walker
*, Select
*);
3377 void sqlite3SelectWalkAssert2(Walker
*, Select
*);
3381 ** Return code from the parse-tree walking primitives and their
3384 #define WRC_Continue 0 /* Continue down into children */
3385 #define WRC_Prune 1 /* Omit children but continue walking siblings */
3386 #define WRC_Abort 2 /* Abandon the tree walk */
3389 ** An instance of this structure represents a set of one or more CTEs
3390 ** (common table expressions) created by a single WITH clause.
3393 int nCte
; /* Number of CTEs in the WITH clause */
3394 With
*pOuter
; /* Containing WITH clause, or NULL */
3395 struct Cte
{ /* For each CTE in the WITH clause.... */
3396 char *zName
; /* Name of this CTE */
3397 ExprList
*pCols
; /* List of explicit column names, or NULL */
3398 Select
*pSelect
; /* The definition of this CTE */
3399 const char *zCteErr
; /* Error message for circular references */
3405 ** An instance of the TreeView object is used for printing the content of
3406 ** data structures on sqlite3DebugPrintf() using a tree-like view.
3409 int iLevel
; /* Which level of the tree we are on */
3410 u8 bLine
[100]; /* Draw vertical in column i if bLine[i] is true */
3412 #endif /* SQLITE_DEBUG */
3415 ** Assuming zIn points to the first byte of a UTF-8 character,
3416 ** advance zIn to point to the first byte of the next UTF-8 character.
3418 #define SQLITE_SKIP_UTF8(zIn) { \
3419 if( (*(zIn++))>=0xc0 ){ \
3420 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
3425 ** The SQLITE_*_BKPT macros are substitutes for the error codes with
3426 ** the same name but without the _BKPT suffix. These macros invoke
3427 ** routines that report the line-number on which the error originated
3428 ** using sqlite3_log(). The routines also provide a convenient place
3429 ** to set a debugger breakpoint.
3431 int sqlite3ReportError(int iErr
, int lineno
, const char *zType
);
3432 int sqlite3CorruptError(int);
3433 int sqlite3MisuseError(int);
3434 int sqlite3CantopenError(int);
3435 #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
3436 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
3437 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
3439 int sqlite3NomemError(int);
3440 int sqlite3IoerrnomemError(int);
3441 int sqlite3CorruptPgnoError(int,Pgno
);
3442 # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
3443 # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
3444 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P))
3446 # define SQLITE_NOMEM_BKPT SQLITE_NOMEM
3447 # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
3448 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__)
3452 ** FTS3 and FTS4 both require virtual table support
3454 #if defined(SQLITE_OMIT_VIRTUALTABLE)
3455 # undef SQLITE_ENABLE_FTS3
3456 # undef SQLITE_ENABLE_FTS4
3460 ** FTS4 is really an extension for FTS3. It is enabled using the
3461 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call
3462 ** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
3464 #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
3465 # define SQLITE_ENABLE_FTS3 1
3469 ** The ctype.h header is needed for non-ASCII systems. It is also
3470 ** needed by FTS3 when FTS3 is included in the amalgamation.
3472 #if !defined(SQLITE_ASCII) || \
3473 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
3478 ** The following macros mimic the standard library functions toupper(),
3479 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
3480 ** sqlite versions only work for ASCII characters, regardless of locale.
3483 # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
3484 # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
3485 # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
3486 # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
3487 # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
3488 # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
3489 # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
3490 # define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
3492 # define sqlite3Toupper(x) toupper((unsigned char)(x))
3493 # define sqlite3Isspace(x) isspace((unsigned char)(x))
3494 # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
3495 # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
3496 # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
3497 # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
3498 # define sqlite3Tolower(x) tolower((unsigned char)(x))
3499 # define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
3501 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
3502 int sqlite3IsIdChar(u8
);
3506 ** Internal function prototypes
3508 int sqlite3StrICmp(const char*,const char*);
3509 int sqlite3Strlen30(const char*);
3510 char *sqlite3ColumnType(Column
*,char*);
3511 #define sqlite3StrNICmp sqlite3_strnicmp
3513 int sqlite3MallocInit(void);
3514 void sqlite3MallocEnd(void);
3515 void *sqlite3Malloc(u64
);
3516 void *sqlite3MallocZero(u64
);
3517 void *sqlite3DbMallocZero(sqlite3
*, u64
);
3518 void *sqlite3DbMallocRaw(sqlite3
*, u64
);
3519 void *sqlite3DbMallocRawNN(sqlite3
*, u64
);
3520 char *sqlite3DbStrDup(sqlite3
*,const char*);
3521 char *sqlite3DbStrNDup(sqlite3
*,const char*, u64
);
3522 char *sqlite3DbSpanDup(sqlite3
*,const char*,const char*);
3523 void *sqlite3Realloc(void*, u64
);
3524 void *sqlite3DbReallocOrFree(sqlite3
*, void *, u64
);
3525 void *sqlite3DbRealloc(sqlite3
*, void *, u64
);
3526 void sqlite3DbFree(sqlite3
*, void*);
3527 void sqlite3DbFreeNN(sqlite3
*, void*);
3528 int sqlite3MallocSize(void*);
3529 int sqlite3DbMallocSize(sqlite3
*, void*);
3530 void *sqlite3PageMalloc(int);
3531 void sqlite3PageFree(void*);
3532 void sqlite3MemSetDefault(void);
3533 #ifndef SQLITE_UNTESTABLE
3534 void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
3536 int sqlite3HeapNearlyFull(void);
3539 ** On systems with ample stack space and that support alloca(), make
3540 ** use of alloca() to obtain space for large automatic objects. By default,
3541 ** obtain space from malloc().
3543 ** The alloca() routine never returns NULL. This will cause code paths
3544 ** that deal with sqlite3StackAlloc() failures to be unreachable.
3546 #ifdef SQLITE_USE_ALLOCA
3547 # define sqlite3StackAllocRaw(D,N) alloca(N)
3548 # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
3549 # define sqlite3StackFree(D,P)
3551 # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
3552 # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
3553 # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
3556 /* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they
3557 ** are, disable MEMSYS3
3559 #ifdef SQLITE_ENABLE_MEMSYS5
3560 const sqlite3_mem_methods
*sqlite3MemGetMemsys5(void);
3561 #undef SQLITE_ENABLE_MEMSYS3
3563 #ifdef SQLITE_ENABLE_MEMSYS3
3564 const sqlite3_mem_methods
*sqlite3MemGetMemsys3(void);
3568 #ifndef SQLITE_MUTEX_OMIT
3569 sqlite3_mutex_methods
const *sqlite3DefaultMutex(void);
3570 sqlite3_mutex_methods
const *sqlite3NoopMutex(void);
3571 sqlite3_mutex
*sqlite3MutexAlloc(int);
3572 int sqlite3MutexInit(void);
3573 int sqlite3MutexEnd(void);
3575 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
3576 void sqlite3MemoryBarrier(void);
3578 # define sqlite3MemoryBarrier()
3581 sqlite3_int64
sqlite3StatusValue(int);
3582 void sqlite3StatusUp(int, int);
3583 void sqlite3StatusDown(int, int);
3584 void sqlite3StatusHighwater(int, int);
3585 int sqlite3LookasideUsed(sqlite3
*,int*);
3587 /* Access to mutexes used by sqlite3_status() */
3588 sqlite3_mutex
*sqlite3Pcache1Mutex(void);
3589 sqlite3_mutex
*sqlite3MallocMutex(void);
3591 #if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT)
3592 void sqlite3MutexWarnOnContention(sqlite3_mutex
*);
3594 # define sqlite3MutexWarnOnContention(x)
3597 #ifndef SQLITE_OMIT_FLOATING_POINT
3598 int sqlite3IsNaN(double);
3600 # define sqlite3IsNaN(X) 0
3604 ** An instance of the following structure holds information about SQL
3605 ** functions arguments that are the parameters to the printf() function.
3607 struct PrintfArguments
{
3608 int nArg
; /* Total number of arguments */
3609 int nUsed
; /* Number of arguments used so far */
3610 sqlite3_value
**apArg
; /* The argument values */
3613 void sqlite3VXPrintf(StrAccum
*, const char*, va_list);
3614 void sqlite3XPrintf(StrAccum
*, const char*, ...);
3615 char *sqlite3MPrintf(sqlite3
*,const char*, ...);
3616 char *sqlite3VMPrintf(sqlite3
*,const char*, va_list);
3617 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
3618 void sqlite3DebugPrintf(const char*, ...);
3620 #if defined(SQLITE_TEST)
3621 void *sqlite3TestTextToPtr(const char*);
3624 #if defined(SQLITE_DEBUG)
3625 void sqlite3TreeViewExpr(TreeView
*, const Expr
*, u8
);
3626 void sqlite3TreeViewBareExprList(TreeView
*, const ExprList
*, const char*);
3627 void sqlite3TreeViewExprList(TreeView
*, const ExprList
*, u8
, const char*);
3628 void sqlite3TreeViewSelect(TreeView
*, const Select
*, u8
);
3629 void sqlite3TreeViewWith(TreeView
*, const With
*, u8
);
3633 void sqlite3SetString(char **, sqlite3
*, const char*);
3634 void sqlite3ErrorMsg(Parse
*, const char*, ...);
3635 void sqlite3Dequote(char*);
3636 void sqlite3TokenInit(Token
*,char*);
3637 int sqlite3KeywordCode(const unsigned char*, int);
3638 int sqlite3RunParser(Parse
*, const char*, char **);
3639 void sqlite3FinishCoding(Parse
*);
3640 int sqlite3GetTempReg(Parse
*);
3641 void sqlite3ReleaseTempReg(Parse
*,int);
3642 int sqlite3GetTempRange(Parse
*,int);
3643 void sqlite3ReleaseTempRange(Parse
*,int,int);
3644 void sqlite3ClearTempRegCache(Parse
*);
3646 int sqlite3NoTempsInRange(Parse
*,int,int);
3648 Expr
*sqlite3ExprAlloc(sqlite3
*,int,const Token
*,int);
3649 Expr
*sqlite3Expr(sqlite3
*,int,const char*);
3650 void sqlite3ExprAttachSubtrees(sqlite3
*,Expr
*,Expr
*,Expr
*);
3651 Expr
*sqlite3PExpr(Parse
*, int, Expr
*, Expr
*);
3652 void sqlite3PExprAddSelect(Parse
*, Expr
*, Select
*);
3653 Expr
*sqlite3ExprAnd(sqlite3
*,Expr
*, Expr
*);
3654 Expr
*sqlite3ExprFunction(Parse
*,ExprList
*, Token
*);
3655 void sqlite3ExprAssignVarNumber(Parse
*, Expr
*, u32
);
3656 void sqlite3ExprDelete(sqlite3
*, Expr
*);
3657 ExprList
*sqlite3ExprListAppend(Parse
*,ExprList
*,Expr
*);
3658 ExprList
*sqlite3ExprListAppendVector(Parse
*,ExprList
*,IdList
*,Expr
*);
3659 void sqlite3ExprListSetSortOrder(ExprList
*,int);
3660 void sqlite3ExprListSetName(Parse
*,ExprList
*,Token
*,int);
3661 void sqlite3ExprListSetSpan(Parse
*,ExprList
*,const char*,const char*);
3662 void sqlite3ExprListDelete(sqlite3
*, ExprList
*);
3663 u32
sqlite3ExprListFlags(const ExprList
*);
3664 int sqlite3Init(sqlite3
*, char**);
3665 int sqlite3InitCallback(void*, int, char**, char**);
3666 void sqlite3Pragma(Parse
*,Token
*,Token
*,Token
*,int);
3667 #ifndef SQLITE_OMIT_VIRTUALTABLE
3668 Module
*sqlite3PragmaVtabRegister(sqlite3
*,const char *zName
);
3670 void sqlite3ResetAllSchemasOfConnection(sqlite3
*);
3671 void sqlite3ResetOneSchema(sqlite3
*,int);
3672 void sqlite3CollapseDatabaseArray(sqlite3
*);
3673 void sqlite3CommitInternalChanges(sqlite3
*);
3674 void sqlite3DeleteColumnNames(sqlite3
*,Table
*);
3675 int sqlite3ColumnsFromExprList(Parse
*,ExprList
*,i16
*,Column
**);
3676 void sqlite3SelectAddColumnTypeAndCollation(Parse
*,Table
*,Select
*);
3677 Table
*sqlite3ResultSetOfSelect(Parse
*,Select
*);
3678 void sqlite3OpenMasterTable(Parse
*, int);
3679 Index
*sqlite3PrimaryKeyIndex(Table
*);
3680 i16
sqlite3ColumnOfIndex(Index
*, i16
);
3681 void sqlite3StartTable(Parse
*,Token
*,Token
*,int,int,int,int);
3682 #if SQLITE_ENABLE_HIDDEN_COLUMNS
3683 void sqlite3ColumnPropertiesFromName(Table
*, Column
*);
3685 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
3687 void sqlite3AddColumn(Parse
*,Token
*,Token
*);
3688 void sqlite3AddNotNull(Parse
*, int);
3689 void sqlite3AddPrimaryKey(Parse
*, ExprList
*, int, int, int);
3690 void sqlite3AddCheckConstraint(Parse
*, Expr
*);
3691 void sqlite3AddDefaultValue(Parse
*,Expr
*,const char*,const char*);
3692 void sqlite3AddCollateType(Parse
*, Token
*);
3693 void sqlite3EndTable(Parse
*,Token
*,Token
*,u8
,Select
*);
3694 int sqlite3ParseUri(const char*,const char*,unsigned int*,
3695 sqlite3_vfs
**,char**,char **);
3696 Btree
*sqlite3DbNameToBtree(sqlite3
*,const char*);
3698 #ifdef SQLITE_UNTESTABLE
3699 # define sqlite3FaultSim(X) SQLITE_OK
3701 int sqlite3FaultSim(int);
3704 Bitvec
*sqlite3BitvecCreate(u32
);
3705 int sqlite3BitvecTest(Bitvec
*, u32
);
3706 int sqlite3BitvecTestNotNull(Bitvec
*, u32
);
3707 int sqlite3BitvecSet(Bitvec
*, u32
);
3708 void sqlite3BitvecClear(Bitvec
*, u32
, void*);
3709 void sqlite3BitvecDestroy(Bitvec
*);
3710 u32
sqlite3BitvecSize(Bitvec
*);
3711 #ifndef SQLITE_UNTESTABLE
3712 int sqlite3BitvecBuiltinTest(int,int*);
3715 RowSet
*sqlite3RowSetInit(sqlite3
*, void*, unsigned int);
3716 void sqlite3RowSetClear(RowSet
*);
3717 void sqlite3RowSetInsert(RowSet
*, i64
);
3718 int sqlite3RowSetTest(RowSet
*, int iBatch
, i64
);
3719 int sqlite3RowSetNext(RowSet
*, i64
*);
3721 void sqlite3CreateView(Parse
*,Token
*,Token
*,Token
*,ExprList
*,Select
*,int,int);
3723 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3724 int sqlite3ViewGetColumnNames(Parse
*,Table
*);
3726 # define sqlite3ViewGetColumnNames(A,B) 0
3729 #if SQLITE_MAX_ATTACHED>30
3730 int sqlite3DbMaskAllZero(yDbMask
);
3732 void sqlite3DropTable(Parse
*, SrcList
*, int, int);
3733 void sqlite3CodeDropTable(Parse
*, Table
*, int, int);
3734 void sqlite3DeleteTable(sqlite3
*, Table
*);
3735 #ifndef SQLITE_OMIT_AUTOINCREMENT
3736 void sqlite3AutoincrementBegin(Parse
*pParse
);
3737 void sqlite3AutoincrementEnd(Parse
*pParse
);
3739 # define sqlite3AutoincrementBegin(X)
3740 # define sqlite3AutoincrementEnd(X)
3742 void sqlite3Insert(Parse
*, SrcList
*, Select
*, IdList
*, int);
3743 void *sqlite3ArrayAllocate(sqlite3
*,void*,int,int*,int*);
3744 IdList
*sqlite3IdListAppend(sqlite3
*, IdList
*, Token
*);
3745 int sqlite3IdListIndex(IdList
*,const char*);
3746 SrcList
*sqlite3SrcListEnlarge(sqlite3
*, SrcList
*, int, int);
3747 SrcList
*sqlite3SrcListAppend(sqlite3
*, SrcList
*, Token
*, Token
*);
3748 SrcList
*sqlite3SrcListAppendFromTerm(Parse
*, SrcList
*, Token
*, Token
*,
3749 Token
*, Select
*, Expr
*, IdList
*);
3750 void sqlite3SrcListIndexedBy(Parse
*, SrcList
*, Token
*);
3751 void sqlite3SrcListFuncArgs(Parse
*, SrcList
*, ExprList
*);
3752 int sqlite3IndexedByLookup(Parse
*, struct SrcList_item
*);
3753 void sqlite3SrcListShiftJoinType(SrcList
*);
3754 void sqlite3SrcListAssignCursors(Parse
*, SrcList
*);
3755 void sqlite3IdListDelete(sqlite3
*, IdList
*);
3756 void sqlite3SrcListDelete(sqlite3
*, SrcList
*);
3757 Index
*sqlite3AllocateIndexObject(sqlite3
*,i16
,int,char**);
3758 void sqlite3CreateIndex(Parse
*,Token
*,Token
*,SrcList
*,ExprList
*,int,Token
*,
3759 Expr
*, int, int, u8
);
3760 void sqlite3DropIndex(Parse
*, SrcList
*, int);
3761 int sqlite3Select(Parse
*, Select
*, SelectDest
*);
3762 Select
*sqlite3SelectNew(Parse
*,ExprList
*,SrcList
*,Expr
*,ExprList
*,
3763 Expr
*,ExprList
*,u32
,Expr
*);
3764 void sqlite3SelectDelete(sqlite3
*, Select
*);
3765 Table
*sqlite3SrcListLookup(Parse
*, SrcList
*);
3766 int sqlite3IsReadOnly(Parse
*, Table
*, int);
3767 void sqlite3OpenTable(Parse
*, int iCur
, int iDb
, Table
*, int);
3768 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
3769 Expr
*sqlite3LimitWhere(Parse
*,SrcList
*,Expr
*,ExprList
*,Expr
*,char*);
3771 void sqlite3DeleteFrom(Parse
*, SrcList
*, Expr
*, ExprList
*, Expr
*);
3772 void sqlite3Update(Parse
*, SrcList
*, ExprList
*,Expr
*,int,ExprList
*,Expr
*);
3773 WhereInfo
*sqlite3WhereBegin(Parse
*,SrcList
*,Expr
*,ExprList
*,ExprList
*,u16
,int);
3774 void sqlite3WhereEnd(WhereInfo
*);
3775 LogEst
sqlite3WhereOutputRowCount(WhereInfo
*);
3776 int sqlite3WhereIsDistinct(WhereInfo
*);
3777 int sqlite3WhereIsOrdered(WhereInfo
*);
3778 int sqlite3WhereOrderedInnerLoop(WhereInfo
*);
3779 int sqlite3WhereIsSorted(WhereInfo
*);
3780 int sqlite3WhereContinueLabel(WhereInfo
*);
3781 int sqlite3WhereBreakLabel(WhereInfo
*);
3782 int sqlite3WhereOkOnePass(WhereInfo
*, int*);
3783 #define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */
3784 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
3785 #define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */
3786 void sqlite3ExprCodeLoadIndexColumn(Parse
*, Index
*, int, int, int);
3787 int sqlite3ExprCodeGetColumn(Parse
*, Table
*, int, int, int, u8
);
3788 void sqlite3ExprCodeGetColumnToReg(Parse
*, Table
*, int, int, int);
3789 void sqlite3ExprCodeGetColumnOfTable(Vdbe
*, Table
*, int, int, int);
3790 void sqlite3ExprCodeMove(Parse
*, int, int, int);
3791 void sqlite3ExprCacheStore(Parse
*, int, int, int);
3792 void sqlite3ExprCachePush(Parse
*);
3793 void sqlite3ExprCachePop(Parse
*);
3794 void sqlite3ExprCacheRemove(Parse
*, int, int);
3795 void sqlite3ExprCacheClear(Parse
*);
3796 void sqlite3ExprCacheAffinityChange(Parse
*, int, int);
3797 void sqlite3ExprCode(Parse
*, Expr
*, int);
3798 void sqlite3ExprCodeCopy(Parse
*, Expr
*, int);
3799 void sqlite3ExprCodeFactorable(Parse
*, Expr
*, int);
3800 int sqlite3ExprCodeAtInit(Parse
*, Expr
*, int);
3801 int sqlite3ExprCodeTemp(Parse
*, Expr
*, int*);
3802 int sqlite3ExprCodeTarget(Parse
*, Expr
*, int);
3803 void sqlite3ExprCodeAndCache(Parse
*, Expr
*, int);
3804 int sqlite3ExprCodeExprList(Parse
*, ExprList
*, int, int, u8
);
3805 #define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
3806 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
3807 #define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */
3808 #define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */
3809 void sqlite3ExprIfTrue(Parse
*, Expr
*, int, int);
3810 void sqlite3ExprIfFalse(Parse
*, Expr
*, int, int);
3811 void sqlite3ExprIfFalseDup(Parse
*, Expr
*, int, int);
3812 Table
*sqlite3FindTable(sqlite3
*,const char*, const char*);
3813 #define LOCATE_VIEW 0x01
3814 #define LOCATE_NOERR 0x02
3815 Table
*sqlite3LocateTable(Parse
*,u32 flags
,const char*, const char*);
3816 Table
*sqlite3LocateTableItem(Parse
*,u32 flags
,struct SrcList_item
*);
3817 Index
*sqlite3FindIndex(sqlite3
*,const char*, const char*);
3818 void sqlite3UnlinkAndDeleteTable(sqlite3
*,int,const char*);
3819 void sqlite3UnlinkAndDeleteIndex(sqlite3
*,int,const char*);
3820 void sqlite3Vacuum(Parse
*,Token
*);
3821 int sqlite3RunVacuum(char**, sqlite3
*, int);
3822 char *sqlite3NameFromToken(sqlite3
*, Token
*);
3823 int sqlite3ExprCompare(Parse
*,Expr
*, Expr
*, int);
3824 int sqlite3ExprCompareSkip(Expr
*, Expr
*, int);
3825 int sqlite3ExprListCompare(ExprList
*, ExprList
*, int);
3826 int sqlite3ExprImpliesExpr(Parse
*,Expr
*, Expr
*, int);
3827 int sqlite3ExprImpliesNonNullRow(Expr
*,int);
3828 void sqlite3ExprAnalyzeAggregates(NameContext
*, Expr
*);
3829 void sqlite3ExprAnalyzeAggList(NameContext
*,ExprList
*);
3830 int sqlite3ExprCoveredByIndex(Expr
*, int iCur
, Index
*pIdx
);
3831 int sqlite3FunctionUsesThisSrc(Expr
*, SrcList
*);
3832 Vdbe
*sqlite3GetVdbe(Parse
*);
3833 #ifndef SQLITE_UNTESTABLE
3834 void sqlite3PrngSaveState(void);
3835 void sqlite3PrngRestoreState(void);
3837 void sqlite3RollbackAll(sqlite3
*,int);
3838 void sqlite3CodeVerifySchema(Parse
*, int);
3839 void sqlite3CodeVerifyNamedSchema(Parse
*, const char *zDb
);
3840 void sqlite3BeginTransaction(Parse
*, int);
3841 void sqlite3EndTransaction(Parse
*,int);
3842 void sqlite3Savepoint(Parse
*, int, Token
*);
3843 void sqlite3CloseSavepoints(sqlite3
*);
3844 void sqlite3LeaveMutexAndCloseZombie(sqlite3
*);
3845 int sqlite3ExprIdToTrueFalse(Expr
*);
3846 int sqlite3ExprTruthValue(const Expr
*);
3847 int sqlite3ExprIsConstant(Expr
*);
3848 int sqlite3ExprIsConstantNotJoin(Expr
*);
3849 int sqlite3ExprIsConstantOrFunction(Expr
*, u8
);
3850 int sqlite3ExprIsConstantOrGroupBy(Parse
*, Expr
*, ExprList
*);
3851 int sqlite3ExprIsTableConstant(Expr
*,int);
3852 #ifdef SQLITE_ENABLE_CURSOR_HINTS
3853 int sqlite3ExprContainsSubquery(Expr
*);
3855 int sqlite3ExprIsInteger(Expr
*, int*);
3856 int sqlite3ExprCanBeNull(const Expr
*);
3857 int sqlite3ExprNeedsNoAffinityChange(const Expr
*, char);
3858 int sqlite3IsRowid(const char*);
3859 void sqlite3GenerateRowDelete(
3860 Parse
*,Table
*,Trigger
*,int,int,int,i16
,u8
,u8
,u8
,int);
3861 void sqlite3GenerateRowIndexDelete(Parse
*, Table
*, int, int, int*, int);
3862 int sqlite3GenerateIndexKey(Parse
*, Index
*, int, int, int, int*,Index
*,int);
3863 void sqlite3ResolvePartIdxLabel(Parse
*,int);
3864 void sqlite3GenerateConstraintChecks(Parse
*,Table
*,int*,int,int,int,int,
3865 u8
,u8
,int,int*,int*);
3866 #ifdef SQLITE_ENABLE_NULL_TRIM
3867 void sqlite3SetMakeRecordP5(Vdbe
*,Table
*);
3869 # define sqlite3SetMakeRecordP5(A,B)
3871 void sqlite3CompleteInsertion(Parse
*,Table
*,int,int,int,int*,int,int,int);
3872 int sqlite3OpenTableAndIndices(Parse
*, Table
*, int, u8
, int, u8
*, int*, int*);
3873 void sqlite3BeginWriteOperation(Parse
*, int, int);
3874 void sqlite3MultiWrite(Parse
*);
3875 void sqlite3MayAbort(Parse
*);
3876 void sqlite3HaltConstraint(Parse
*, int, int, char*, i8
, u8
);
3877 void sqlite3UniqueConstraint(Parse
*, int, Index
*);
3878 void sqlite3RowidConstraint(Parse
*, int, Table
*);
3879 Expr
*sqlite3ExprDup(sqlite3
*,Expr
*,int);
3880 ExprList
*sqlite3ExprListDup(sqlite3
*,ExprList
*,int);
3881 SrcList
*sqlite3SrcListDup(sqlite3
*,SrcList
*,int);
3882 IdList
*sqlite3IdListDup(sqlite3
*,IdList
*);
3883 Select
*sqlite3SelectDup(sqlite3
*,Select
*,int);
3884 #if SELECTTRACE_ENABLED
3885 void sqlite3SelectSetName(Select
*,const char*);
3887 # define sqlite3SelectSetName(A,B)
3889 void sqlite3InsertBuiltinFuncs(FuncDef
*,int);
3890 FuncDef
*sqlite3FindFunction(sqlite3
*,const char*,int,u8
,u8
);
3891 void sqlite3RegisterBuiltinFunctions(void);
3892 void sqlite3RegisterDateTimeFunctions(void);
3893 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3
*);
3894 int sqlite3SafetyCheckOk(sqlite3
*);
3895 int sqlite3SafetyCheckSickOrOk(sqlite3
*);
3896 void sqlite3ChangeCookie(Parse
*, int);
3898 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
3899 void sqlite3MaterializeView(Parse
*, Table
*, Expr
*, ExprList
*,Expr
*,int);
3902 #ifndef SQLITE_OMIT_TRIGGER
3903 void sqlite3BeginTrigger(Parse
*, Token
*,Token
*,int,int,IdList
*,SrcList
*,
3905 void sqlite3FinishTrigger(Parse
*, TriggerStep
*, Token
*);
3906 void sqlite3DropTrigger(Parse
*, SrcList
*, int);
3907 void sqlite3DropTriggerPtr(Parse
*, Trigger
*);
3908 Trigger
*sqlite3TriggersExist(Parse
*, Table
*, int, ExprList
*, int *pMask
);
3909 Trigger
*sqlite3TriggerList(Parse
*, Table
*);
3910 void sqlite3CodeRowTrigger(Parse
*, Trigger
*, int, ExprList
*, int, Table
*,
3912 void sqlite3CodeRowTriggerDirect(Parse
*, Trigger
*, Table
*, int, int, int);
3913 void sqliteViewTriggers(Parse
*, Table
*, Expr
*, int, ExprList
*);
3914 void sqlite3DeleteTriggerStep(sqlite3
*, TriggerStep
*);
3915 TriggerStep
*sqlite3TriggerSelectStep(sqlite3
*,Select
*,
3916 const char*,const char*);
3917 TriggerStep
*sqlite3TriggerInsertStep(sqlite3
*,Token
*, IdList
*,
3918 Select
*,u8
,const char*,const char*);
3919 TriggerStep
*sqlite3TriggerUpdateStep(sqlite3
*,Token
*,ExprList
*, Expr
*, u8
,
3920 const char*,const char*);
3921 TriggerStep
*sqlite3TriggerDeleteStep(sqlite3
*,Token
*, Expr
*,
3922 const char*,const char*);
3923 void sqlite3DeleteTrigger(sqlite3
*, Trigger
*);
3924 void sqlite3UnlinkAndDeleteTrigger(sqlite3
*,int,const char*);
3925 u32
sqlite3TriggerColmask(Parse
*,Trigger
*,ExprList
*,int,int,Table
*,int);
3926 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
3927 # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
3929 # define sqlite3TriggersExist(B,C,D,E,F) 0
3930 # define sqlite3DeleteTrigger(A,B)
3931 # define sqlite3DropTriggerPtr(A,B)
3932 # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
3933 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
3934 # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
3935 # define sqlite3TriggerList(X, Y) 0
3936 # define sqlite3ParseToplevel(p) p
3937 # define sqlite3IsToplevel(p) 1
3938 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
3941 int sqlite3JoinType(Parse
*, Token
*, Token
*, Token
*);
3942 void sqlite3CreateForeignKey(Parse
*, ExprList
*, Token
*, ExprList
*, int);
3943 void sqlite3DeferForeignKey(Parse
*, int);
3944 #ifndef SQLITE_OMIT_AUTHORIZATION
3945 void sqlite3AuthRead(Parse
*,Expr
*,Schema
*,SrcList
*);
3946 int sqlite3AuthCheck(Parse
*,int, const char*, const char*, const char*);
3947 void sqlite3AuthContextPush(Parse
*, AuthContext
*, const char*);
3948 void sqlite3AuthContextPop(AuthContext
*);
3949 int sqlite3AuthReadCol(Parse
*, const char *, const char *, int);
3951 # define sqlite3AuthRead(a,b,c,d)
3952 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
3953 # define sqlite3AuthContextPush(a,b,c)
3954 # define sqlite3AuthContextPop(a) ((void)(a))
3956 void sqlite3Attach(Parse
*, Expr
*, Expr
*, Expr
*);
3957 void sqlite3Detach(Parse
*, Expr
*);
3958 void sqlite3FixInit(DbFixer
*, Parse
*, int, const char*, const Token
*);
3959 int sqlite3FixSrcList(DbFixer
*, SrcList
*);
3960 int sqlite3FixSelect(DbFixer
*, Select
*);
3961 int sqlite3FixExpr(DbFixer
*, Expr
*);
3962 int sqlite3FixExprList(DbFixer
*, ExprList
*);
3963 int sqlite3FixTriggerStep(DbFixer
*, TriggerStep
*);
3964 int sqlite3AtoF(const char *z
, double*, int, u8
);
3965 int sqlite3GetInt32(const char *, int*);
3966 int sqlite3Atoi(const char*);
3967 #ifndef SQLITE_OMIT_UTF16
3968 int sqlite3Utf16ByteLen(const void *pData
, int nChar
);
3970 int sqlite3Utf8CharLen(const char *pData
, int nByte
);
3971 u32
sqlite3Utf8Read(const u8
**);
3972 LogEst
sqlite3LogEst(u64
);
3973 LogEst
sqlite3LogEstAdd(LogEst
,LogEst
);
3974 #ifndef SQLITE_OMIT_VIRTUALTABLE
3975 LogEst
sqlite3LogEstFromDouble(double);
3977 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
3978 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
3979 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
3980 u64
sqlite3LogEstToInt(LogEst
);
3982 VList
*sqlite3VListAdd(sqlite3
*,VList
*,const char*,int,int);
3983 const char *sqlite3VListNumToName(VList
*,int);
3984 int sqlite3VListNameToNum(VList
*,const char*,int);
3987 ** Routines to read and write variable-length integers. These used to
3988 ** be defined locally, but now we use the varint routines in the util.c
3991 int sqlite3PutVarint(unsigned char*, u64
);
3992 u8
sqlite3GetVarint(const unsigned char *, u64
*);
3993 u8
sqlite3GetVarint32(const unsigned char *, u32
*);
3994 int sqlite3VarintLen(u64 v
);
3997 ** The common case is for a varint to be a single byte. They following
3998 ** macros handle the common case without a procedure call, but then call
3999 ** the procedure for larger varints.
4001 #define getVarint32(A,B) \
4002 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
4003 #define putVarint32(A,B) \
4004 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
4005 sqlite3PutVarint((A),(B)))
4006 #define getVarint sqlite3GetVarint
4007 #define putVarint sqlite3PutVarint
4010 const char *sqlite3IndexAffinityStr(sqlite3
*, Index
*);
4011 void sqlite3TableAffinity(Vdbe
*, Table
*, int);
4012 char sqlite3CompareAffinity(Expr
*pExpr
, char aff2
);
4013 int sqlite3IndexAffinityOk(Expr
*pExpr
, char idx_affinity
);
4014 char sqlite3TableColumnAffinity(Table
*,int);
4015 char sqlite3ExprAffinity(Expr
*pExpr
);
4016 int sqlite3Atoi64(const char*, i64
*, int, u8
);
4017 int sqlite3DecOrHexToI64(const char*, i64
*);
4018 void sqlite3ErrorWithMsg(sqlite3
*, int, const char*,...);
4019 void sqlite3Error(sqlite3
*,int);
4020 void sqlite3SystemError(sqlite3
*,int);
4021 void *sqlite3HexToBlob(sqlite3
*, const char *z
, int n
);
4022 u8
sqlite3HexToInt(int h
);
4023 int sqlite3TwoPartName(Parse
*, Token
*, Token
*, Token
**);
4025 #if defined(SQLITE_NEED_ERR_NAME)
4026 const char *sqlite3ErrName(int);
4029 #ifdef SQLITE_ENABLE_DESERIALIZE
4030 int sqlite3MemdbInit(void);
4033 const char *sqlite3ErrStr(int);
4034 int sqlite3ReadSchema(Parse
*pParse
);
4035 CollSeq
*sqlite3FindCollSeq(sqlite3
*,u8 enc
, const char*,int);
4036 CollSeq
*sqlite3LocateCollSeq(Parse
*pParse
, const char*zName
);
4037 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, Expr
*pExpr
);
4038 CollSeq
*sqlite3ExprNNCollSeq(Parse
*pParse
, Expr
*pExpr
);
4039 int sqlite3ExprCollSeqMatch(Parse
*,Expr
*,Expr
*);
4040 Expr
*sqlite3ExprAddCollateToken(Parse
*pParse
, Expr
*, const Token
*, int);
4041 Expr
*sqlite3ExprAddCollateString(Parse
*,Expr
*,const char*);
4042 Expr
*sqlite3ExprSkipCollate(Expr
*);
4043 int sqlite3CheckCollSeq(Parse
*, CollSeq
*);
4044 int sqlite3CheckObjectName(Parse
*, const char *);
4045 void sqlite3VdbeSetChanges(sqlite3
*, int);
4046 int sqlite3AddInt64(i64
*,i64
);
4047 int sqlite3SubInt64(i64
*,i64
);
4048 int sqlite3MulInt64(i64
*,i64
);
4049 int sqlite3AbsInt32(int);
4050 #ifdef SQLITE_ENABLE_8_3_NAMES
4051 void sqlite3FileSuffix3(const char*, char*);
4053 # define sqlite3FileSuffix3(X,Y)
4055 u8
sqlite3GetBoolean(const char *z
,u8
);
4057 const void *sqlite3ValueText(sqlite3_value
*, u8
);
4058 int sqlite3ValueBytes(sqlite3_value
*, u8
);
4059 void sqlite3ValueSetStr(sqlite3_value
*, int, const void *,u8
,
4061 void sqlite3ValueSetNull(sqlite3_value
*);
4062 void sqlite3ValueFree(sqlite3_value
*);
4063 sqlite3_value
*sqlite3ValueNew(sqlite3
*);
4064 #ifndef SQLITE_OMIT_UTF16
4065 char *sqlite3Utf16to8(sqlite3
*, const void*, int, u8
);
4067 int sqlite3ValueFromExpr(sqlite3
*, Expr
*, u8
, u8
, sqlite3_value
**);
4068 void sqlite3ValueApplyAffinity(sqlite3_value
*, u8
, u8
);
4069 #ifndef SQLITE_AMALGAMATION
4070 extern const unsigned char sqlite3OpcodeProperty
[];
4071 extern const char sqlite3StrBINARY
[];
4072 extern const unsigned char sqlite3UpperToLower
[];
4073 extern const unsigned char sqlite3CtypeMap
[];
4074 extern const Token sqlite3IntTokens
[];
4075 extern SQLITE_WSD
struct Sqlite3Config sqlite3Config
;
4076 extern FuncDefHash sqlite3BuiltinFunctions
;
4077 #ifndef SQLITE_OMIT_WSD
4078 extern int sqlite3PendingByte
;
4082 extern sqlite3_uint64 sqlite3NProfileCnt
;
4084 void sqlite3RootPageMoved(sqlite3
*, int, int, int);
4085 void sqlite3Reindex(Parse
*, Token
*, Token
*);
4086 void sqlite3AlterFunctions(void);
4087 void sqlite3AlterRenameTable(Parse
*, SrcList
*, Token
*);
4088 int sqlite3GetToken(const unsigned char *, int *);
4089 void sqlite3NestedParse(Parse
*, const char*, ...);
4090 void sqlite3ExpirePreparedStatements(sqlite3
*);
4091 int sqlite3CodeSubselect(Parse
*, Expr
*, int, int);
4092 void sqlite3SelectPrep(Parse
*, Select
*, NameContext
*);
4093 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
);
4094 int sqlite3MatchSpanName(const char*, const char*, const char*, const char*);
4095 int sqlite3ResolveExprNames(NameContext
*, Expr
*);
4096 int sqlite3ResolveExprListNames(NameContext
*, ExprList
*);
4097 void sqlite3ResolveSelectNames(Parse
*, Select
*, NameContext
*);
4098 void sqlite3ResolveSelfReference(Parse
*,Table
*,int,Expr
*,ExprList
*);
4099 int sqlite3ResolveOrderGroupBy(Parse
*, Select
*, ExprList
*, const char*);
4100 void sqlite3ColumnDefault(Vdbe
*, Table
*, int, int);
4101 void sqlite3AlterFinishAddColumn(Parse
*, Token
*);
4102 void sqlite3AlterBeginAddColumn(Parse
*, SrcList
*);
4103 CollSeq
*sqlite3GetCollSeq(Parse
*, u8
, CollSeq
*, const char*);
4104 char sqlite3AffinityType(const char*, u8
*);
4105 void sqlite3Analyze(Parse
*, Token
*, Token
*);
4106 int sqlite3InvokeBusyHandler(BusyHandler
*);
4107 int sqlite3FindDb(sqlite3
*, Token
*);
4108 int sqlite3FindDbName(sqlite3
*, const char *);
4109 int sqlite3AnalysisLoad(sqlite3
*,int iDB
);
4110 void sqlite3DeleteIndexSamples(sqlite3
*,Index
*);
4111 void sqlite3DefaultRowEst(Index
*);
4112 void sqlite3RegisterLikeFunctions(sqlite3
*, int);
4113 int sqlite3IsLikeFunction(sqlite3
*,Expr
*,int*,char*);
4114 void sqlite3SchemaClear(void *);
4115 Schema
*sqlite3SchemaGet(sqlite3
*, Btree
*);
4116 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*);
4117 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*,int,int);
4118 void sqlite3KeyInfoUnref(KeyInfo
*);
4119 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*);
4120 KeyInfo
*sqlite3KeyInfoOfIndex(Parse
*, Index
*);
4122 int sqlite3KeyInfoIsWriteable(KeyInfo
*);
4124 int sqlite3CreateFunc(sqlite3
*, const char *, int, int, void *,
4125 void (*)(sqlite3_context
*,int,sqlite3_value
**),
4126 void (*)(sqlite3_context
*,int,sqlite3_value
**), void (*)(sqlite3_context
*),
4127 FuncDestructor
*pDestructor
4129 void sqlite3OomFault(sqlite3
*);
4130 void sqlite3OomClear(sqlite3
*);
4131 int sqlite3ApiExit(sqlite3
*db
, int);
4132 int sqlite3OpenTempDatabase(Parse
*);
4134 void sqlite3StrAccumInit(StrAccum
*, sqlite3
*, char*, int, int);
4135 void sqlite3StrAccumAppend(StrAccum
*,const char*,int);
4136 void sqlite3StrAccumAppendAll(StrAccum
*,const char*);
4137 void sqlite3AppendChar(StrAccum
*,int,char);
4138 char *sqlite3StrAccumFinish(StrAccum
*);
4139 void sqlite3StrAccumReset(StrAccum
*);
4140 void sqlite3SelectDestInit(SelectDest
*,int,int);
4141 Expr
*sqlite3CreateColumnExpr(sqlite3
*, SrcList
*, int, int);
4143 void sqlite3BackupRestart(sqlite3_backup
*);
4144 void sqlite3BackupUpdate(sqlite3_backup
*, Pgno
, const u8
*);
4146 #ifndef SQLITE_OMIT_SUBQUERY
4147 int sqlite3ExprCheckIN(Parse
*, Expr
*);
4149 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
4152 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
4153 void sqlite3AnalyzeFunctions(void);
4154 int sqlite3Stat4ProbeSetValue(
4155 Parse
*,Index
*,UnpackedRecord
**,Expr
*,int,int,int*);
4156 int sqlite3Stat4ValueFromExpr(Parse
*, Expr
*, u8
, sqlite3_value
**);
4157 void sqlite3Stat4ProbeFree(UnpackedRecord
*);
4158 int sqlite3Stat4Column(sqlite3
*, const void*, int, int, sqlite3_value
**);
4159 char sqlite3IndexColumnAffinity(sqlite3
*, Index
*, int);
4163 ** The interface to the LEMON-generated parser
4165 #ifndef SQLITE_AMALGAMATION
4166 void *sqlite3ParserAlloc(void*(*)(u64
));
4167 void sqlite3ParserFree(void*, void(*)(void*));
4169 void sqlite3Parser(void*, int, Token
, Parse
*);
4170 #ifdef YYTRACKMAXSTACKDEPTH
4171 int sqlite3ParserStackPeak(void*);
4174 void sqlite3AutoLoadExtensions(sqlite3
*);
4175 #ifndef SQLITE_OMIT_LOAD_EXTENSION
4176 void sqlite3CloseExtensions(sqlite3
*);
4178 # define sqlite3CloseExtensions(X)
4181 #ifndef SQLITE_OMIT_SHARED_CACHE
4182 void sqlite3TableLock(Parse
*, int, int, u8
, const char *);
4184 #define sqlite3TableLock(v,w,x,y,z)
4188 int sqlite3Utf8To8(unsigned char*);
4191 #ifdef SQLITE_OMIT_VIRTUALTABLE
4192 # define sqlite3VtabClear(Y)
4193 # define sqlite3VtabSync(X,Y) SQLITE_OK
4194 # define sqlite3VtabRollback(X)
4195 # define sqlite3VtabCommit(X)
4196 # define sqlite3VtabInSync(db) 0
4197 # define sqlite3VtabLock(X)
4198 # define sqlite3VtabUnlock(X)
4199 # define sqlite3VtabUnlockList(X)
4200 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
4201 # define sqlite3GetVTable(X,Y) ((VTable*)0)
4203 void sqlite3VtabClear(sqlite3
*db
, Table
*);
4204 void sqlite3VtabDisconnect(sqlite3
*db
, Table
*p
);
4205 int sqlite3VtabSync(sqlite3
*db
, Vdbe
*);
4206 int sqlite3VtabRollback(sqlite3
*db
);
4207 int sqlite3VtabCommit(sqlite3
*db
);
4208 void sqlite3VtabLock(VTable
*);
4209 void sqlite3VtabUnlock(VTable
*);
4210 void sqlite3VtabUnlockList(sqlite3
*);
4211 int sqlite3VtabSavepoint(sqlite3
*, int, int);
4212 void sqlite3VtabImportErrmsg(Vdbe
*, sqlite3_vtab
*);
4213 VTable
*sqlite3GetVTable(sqlite3
*, Table
*);
4214 Module
*sqlite3VtabCreateModule(
4217 const sqlite3_module
*,
4221 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
4223 int sqlite3VtabEponymousTableInit(Parse
*,Module
*);
4224 void sqlite3VtabEponymousTableClear(sqlite3
*,Module
*);
4225 void sqlite3VtabMakeWritable(Parse
*,Table
*);
4226 void sqlite3VtabBeginParse(Parse
*, Token
*, Token
*, Token
*, int);
4227 void sqlite3VtabFinishParse(Parse
*, Token
*);
4228 void sqlite3VtabArgInit(Parse
*);
4229 void sqlite3VtabArgExtend(Parse
*, Token
*);
4230 int sqlite3VtabCallCreate(sqlite3
*, int, const char *, char **);
4231 int sqlite3VtabCallConnect(Parse
*, Table
*);
4232 int sqlite3VtabCallDestroy(sqlite3
*, int, const char *);
4233 int sqlite3VtabBegin(sqlite3
*, VTable
*);
4234 FuncDef
*sqlite3VtabOverloadFunction(sqlite3
*,FuncDef
*, int nArg
, Expr
*);
4235 void sqlite3InvalidFunction(sqlite3_context
*,int,sqlite3_value
**);
4236 sqlite3_int64
sqlite3StmtCurrentTime(sqlite3_context
*);
4237 int sqlite3VdbeParameterIndex(Vdbe
*, const char*, int);
4238 int sqlite3TransferBindings(sqlite3_stmt
*, sqlite3_stmt
*);
4239 void sqlite3ParserReset(Parse
*);
4240 int sqlite3Reprepare(Vdbe
*);
4241 void sqlite3ExprListCheckLength(Parse
*, ExprList
*, const char*);
4242 CollSeq
*sqlite3BinaryCompareCollSeq(Parse
*, Expr
*, Expr
*);
4243 int sqlite3TempInMemory(const sqlite3
*);
4244 const char *sqlite3JournalModename(int);
4245 #ifndef SQLITE_OMIT_WAL
4246 int sqlite3Checkpoint(sqlite3
*, int, int, int*, int*);
4247 int sqlite3WalDefaultHook(void*,sqlite3
*,const char*,int);
4249 #ifndef SQLITE_OMIT_CTE
4250 With
*sqlite3WithAdd(Parse
*,With
*,Token
*,ExprList
*,Select
*);
4251 void sqlite3WithDelete(sqlite3
*,With
*);
4252 void sqlite3WithPush(Parse
*, With
*, u8
);
4254 #define sqlite3WithPush(x,y,z)
4255 #define sqlite3WithDelete(x,y)
4258 /* Declarations for functions in fkey.c. All of these are replaced by
4259 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
4260 ** key functionality is available. If OMIT_TRIGGER is defined but
4261 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
4262 ** this case foreign keys are parsed, but no other functionality is
4263 ** provided (enforcement of FK constraints requires the triggers sub-system).
4265 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
4266 void sqlite3FkCheck(Parse
*, Table
*, int, int, int*, int);
4267 void sqlite3FkDropTable(Parse
*, SrcList
*, Table
*);
4268 void sqlite3FkActions(Parse
*, Table
*, ExprList
*, int, int*, int);
4269 int sqlite3FkRequired(Parse
*, Table
*, int*, int);
4270 u32
sqlite3FkOldmask(Parse
*, Table
*);
4271 FKey
*sqlite3FkReferences(Table
*);
4273 #define sqlite3FkActions(a,b,c,d,e,f)
4274 #define sqlite3FkCheck(a,b,c,d,e,f)
4275 #define sqlite3FkDropTable(a,b,c)
4276 #define sqlite3FkOldmask(a,b) 0
4277 #define sqlite3FkRequired(a,b,c,d) 0
4278 #define sqlite3FkReferences(a) 0
4280 #ifndef SQLITE_OMIT_FOREIGN_KEY
4281 void sqlite3FkDelete(sqlite3
*, Table
*);
4282 int sqlite3FkLocateIndex(Parse
*,Table
*,FKey
*,Index
**,int**);
4284 #define sqlite3FkDelete(a,b)
4285 #define sqlite3FkLocateIndex(a,b,c,d,e)
4290 ** Available fault injectors. Should be numbered beginning with 0.
4292 #define SQLITE_FAULTINJECTOR_MALLOC 0
4293 #define SQLITE_FAULTINJECTOR_COUNT 1
4296 ** The interface to the code in fault.c used for identifying "benign"
4297 ** malloc failures. This is only present if SQLITE_UNTESTABLE
4300 #ifndef SQLITE_UNTESTABLE
4301 void sqlite3BeginBenignMalloc(void);
4302 void sqlite3EndBenignMalloc(void);
4304 #define sqlite3BeginBenignMalloc()
4305 #define sqlite3EndBenignMalloc()
4309 ** Allowed return values from sqlite3FindInIndex()
4311 #define IN_INDEX_ROWID 1 /* Search the rowid of the table */
4312 #define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
4313 #define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */
4314 #define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */
4315 #define IN_INDEX_NOOP 5 /* No table available. Use comparisons */
4317 ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
4319 #define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
4320 #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
4321 #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
4322 int sqlite3FindInIndex(Parse
*, Expr
*, u32
, int*, int*);
4324 int sqlite3JournalOpen(sqlite3_vfs
*, const char *, sqlite3_file
*, int, int);
4325 int sqlite3JournalSize(sqlite3_vfs
*);
4326 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
4327 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
4328 int sqlite3JournalCreate(sqlite3_file
*);
4331 int sqlite3JournalIsInMemory(sqlite3_file
*p
);
4332 void sqlite3MemJournalOpen(sqlite3_file
*);
4334 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
);
4335 #if SQLITE_MAX_EXPR_DEPTH>0
4336 int sqlite3SelectExprHeight(Select
*);
4337 int sqlite3ExprCheckHeight(Parse
*, int);
4339 #define sqlite3SelectExprHeight(x) 0
4340 #define sqlite3ExprCheckHeight(x,y)
4343 u32
sqlite3Get4byte(const u8
*);
4344 void sqlite3Put4byte(u8
*, u32
);
4346 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
4347 void sqlite3ConnectionBlocked(sqlite3
*, sqlite3
*);
4348 void sqlite3ConnectionUnlocked(sqlite3
*db
);
4349 void sqlite3ConnectionClosed(sqlite3
*db
);
4351 #define sqlite3ConnectionBlocked(x,y)
4352 #define sqlite3ConnectionUnlocked(x)
4353 #define sqlite3ConnectionClosed(x)
4357 void sqlite3ParserTrace(FILE*, char *);
4359 #if defined(YYCOVERAGE)
4360 int sqlite3ParserCoverage(FILE*);
4364 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
4365 ** sqlite3IoTrace is a pointer to a printf-like routine used to
4366 ** print I/O tracing messages.
4368 #ifdef SQLITE_ENABLE_IOTRACE
4369 # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
4370 void sqlite3VdbeIOTraceSql(Vdbe
*);
4371 SQLITE_API SQLITE_EXTERN
void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*,...);
4374 # define sqlite3VdbeIOTraceSql(X)
4378 ** These routines are available for the mem2.c debugging memory allocator
4379 ** only. They are used to verify that different "types" of memory
4380 ** allocations are properly tracked by the system.
4382 ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
4383 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
4384 ** a single bit set.
4386 ** sqlite3MemdebugHasType() returns true if any of the bits in its second
4387 ** argument match the type set by the previous sqlite3MemdebugSetType().
4388 ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
4390 ** sqlite3MemdebugNoType() returns true if none of the bits in its second
4391 ** argument match the type set by the previous sqlite3MemdebugSetType().
4393 ** Perhaps the most important point is the difference between MEMTYPE_HEAP
4394 ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
4395 ** it might have been allocated by lookaside, except the allocation was
4396 ** too large or lookaside was already full. It is important to verify
4397 ** that allocations that might have been satisfied by lookaside are not
4398 ** passed back to non-lookaside free() routines. Asserts such as the
4399 ** example above are placed on the non-lookaside free() routines to verify
4402 ** All of this is no-op for a production build. It only comes into
4403 ** play when the SQLITE_MEMDEBUG compile-time option is used.
4405 #ifdef SQLITE_MEMDEBUG
4406 void sqlite3MemdebugSetType(void*,u8
);
4407 int sqlite3MemdebugHasType(void*,u8
);
4408 int sqlite3MemdebugNoType(void*,u8
);
4410 # define sqlite3MemdebugSetType(X,Y) /* no-op */
4411 # define sqlite3MemdebugHasType(X,Y) 1
4412 # define sqlite3MemdebugNoType(X,Y) 1
4414 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
4415 #define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */
4416 #define MEMTYPE_PCACHE 0x04 /* Page cache allocations */
4419 ** Threading interface
4421 #if SQLITE_MAX_WORKER_THREADS>0
4422 int sqlite3ThreadCreate(SQLiteThread
**,void*(*)(void*),void*);
4423 int sqlite3ThreadJoin(SQLiteThread
*, void**);
4426 #if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)
4427 int sqlite3DbpageRegister(sqlite3
*);
4429 #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
4430 int sqlite3DbstatRegister(sqlite3
*);
4433 int sqlite3ExprVectorSize(Expr
*pExpr
);
4434 int sqlite3ExprIsVector(Expr
*pExpr
);
4435 Expr
*sqlite3VectorFieldSubexpr(Expr
*, int);
4436 Expr
*sqlite3ExprForVectorField(Parse
*,Expr
*,int);
4437 void sqlite3VectorErrorMsg(Parse
*, Expr
*);
4439 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
4440 const char **sqlite3CompileOptions(int *pnOpt
);
4443 #endif /* SQLITEINT_H */