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 ** Make sure that rand_s() is available on Windows systems with MSVC 2005
57 #if defined(_MSC_VER) && _MSC_VER>=1400
62 ** Include the header file used to customize the compiler options for MSVC.
63 ** This should be done first so that it can successfully prevent spurious
64 ** compiler warnings due to subsequent content in this file and other files
65 ** that are included by this file.
70 ** Special setup for VxWorks
75 ** These #defines should enable >2GB file support on POSIX if the
76 ** underlying operating system supports it. If the OS lacks
77 ** large file support, or if the OS is windows, these should be no-ops.
79 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
80 ** system #includes. Hence, this block of code must be the very first
81 ** code in all source files.
83 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
84 ** on the compiler command line. This is necessary if you are compiling
85 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
86 ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
87 ** without this option, LFS is enable. But LFS does not exist in the kernel
88 ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
89 ** portability you should omit LFS.
91 ** The previous paragraph was written in 2005. (This paragraph is written
92 ** on 2008-11-28.) These days, all Linux kernels support large files, so
93 ** you should probably leave LFS enabled. But some embedded platforms might
94 ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
96 ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
98 #ifndef SQLITE_DISABLE_LFS
99 # define _LARGE_FILE 1
100 # ifndef _FILE_OFFSET_BITS
101 # define _FILE_OFFSET_BITS 64
103 # define _LARGEFILE_SOURCE 1
106 /* What version of GCC is being used. 0 means GCC is not being used */
108 # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
110 # define GCC_VERSION 0
113 /* What version of CLANG is being used. 0 means CLANG is not being used */
114 #if defined(__clang__) && !defined(_WIN32)
115 # define CLANG_VERSION \
116 (__clang_major__*1000000+__clang_minor__*1000+__clang_patchlevel__)
118 # define CLANG_VERSION 0
121 /* Needed for various definitions... */
122 #if defined(__GNUC__) && !defined(_GNU_SOURCE)
126 #if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
131 ** For MinGW, check to see if we can include the header file containing its
132 ** version information, among other things. Normally, this internal MinGW
133 ** header file would [only] be included automatically by other MinGW header
134 ** files; however, the contained version information is now required by this
135 ** header file to work around binary compatibility issues (see below) and
136 ** this is the only known way to reliably obtain it. This entire #if block
137 ** would be completely unnecessary if there was any other way of detecting
138 ** MinGW via their preprocessor (e.g. if they customized their GCC to define
139 ** some MinGW-specific macros). When compiling for MinGW, either the
140 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
141 ** defined; otherwise, detection of conditions specific to MinGW will be
144 #if defined(_HAVE_MINGW_H)
146 #elif defined(_HAVE__MINGW_H)
151 ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
152 ** define is required to maintain binary compatibility with the MSVC runtime
153 ** library in use (e.g. for Windows XP).
155 #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
156 defined(_WIN32) && !defined(_WIN64) && \
157 defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
159 # define _USE_32BIT_TIME_T
162 /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
163 ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
169 ** Include the configuration header output by 'configure' if we're using the
170 ** autoconf-based build
172 #ifdef _HAVE_SQLITE_CONFIG_H
176 #include "sqliteLimit.h"
178 /* Disable nuisance warnings on Borland compilers */
179 #if defined(__BORLANDC__)
180 #pragma warn -rch /* unreachable code */
181 #pragma warn -ccc /* Condition is always true or false */
182 #pragma warn -aus /* Assigned value is never used */
183 #pragma warn -csu /* Comparing signed and unsigned */
184 #pragma warn -spa /* Suspicious pointer arithmetic */
188 ** Include standard header files as necessary
193 #ifdef HAVE_INTTYPES_H
194 #include <inttypes.h>
198 ** The following macros are used to cast pointers to integers and
199 ** integers to pointers. The way you do this varies from one compiler
200 ** to the next, so we have developed the following set of #if statements
201 ** to generate appropriate macros for a wide range of compilers.
203 ** The correct "ANSI" way to do this is to use the intptr_t type.
204 ** Unfortunately, that typedef is not available on all compilers, or
205 ** if it is available, it requires an #include of specific headers
206 ** that vary from one machine to the next.
208 ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
209 ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
210 ** So we have to define the macros in different ways depending on the
213 #if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
214 # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
215 # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
216 #elif !defined(__GNUC__) /* Works for compilers other than LLVM */
217 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
218 # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
219 #elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
220 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
221 # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
222 #else /* Generates a warning - but it always works */
223 # define SQLITE_INT_TO_PTR(X) ((void*)(X))
224 # define SQLITE_PTR_TO_INT(X) ((int)(X))
228 ** A macro to hint to the compiler that a function should not be
231 #if defined(__GNUC__)
232 # define SQLITE_NOINLINE __attribute__((noinline))
233 #elif defined(_MSC_VER) && _MSC_VER>=1310
234 # define SQLITE_NOINLINE __declspec(noinline)
236 # define SQLITE_NOINLINE
240 ** Make sure that the compiler intrinsics we desire are enabled when
241 ** compiling with an appropriate version of MSVC unless prevented by
242 ** the SQLITE_DISABLE_INTRINSIC define.
244 #if !defined(SQLITE_DISABLE_INTRINSIC)
245 # if defined(_MSC_VER) && _MSC_VER>=1400
246 # if !defined(_WIN32_WCE)
248 # pragma intrinsic(_byteswap_ushort)
249 # pragma intrinsic(_byteswap_ulong)
250 # pragma intrinsic(_ReadWriteBarrier)
252 # include <cmnintrin.h>
258 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
259 ** 0 means mutexes are permanently disable and the library is never
260 ** threadsafe. 1 means the library is serialized which is the highest
261 ** level of threadsafety. 2 means the library is multithreaded - multiple
262 ** threads can use SQLite as long as no two threads try to use the same
263 ** database connection at the same time.
265 ** Older versions of SQLite used an optional THREADSAFE macro.
266 ** We support that for legacy.
268 #if !defined(SQLITE_THREADSAFE)
269 # if defined(THREADSAFE)
270 # define SQLITE_THREADSAFE THREADSAFE
272 # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
277 ** Powersafe overwrite is on by default. But can be turned off using
278 ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
280 #ifndef SQLITE_POWERSAFE_OVERWRITE
281 # define SQLITE_POWERSAFE_OVERWRITE 1
285 ** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
286 ** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in
287 ** which case memory allocation statistics are disabled by default.
289 #if !defined(SQLITE_DEFAULT_MEMSTATUS)
290 # define SQLITE_DEFAULT_MEMSTATUS 1
294 ** Exactly one of the following macros must be defined in order to
295 ** specify which memory allocation subsystem to use.
297 ** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
298 ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
299 ** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails
300 ** SQLITE_MEMDEBUG // Debugging version of system malloc()
302 ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
303 ** assert() macro is enabled, each call into the Win32 native heap subsystem
304 ** will cause HeapValidate to be called. If heap validation should fail, an
305 ** assertion will be triggered.
307 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
310 #if defined(SQLITE_SYSTEM_MALLOC) \
311 + defined(SQLITE_WIN32_MALLOC) \
312 + defined(SQLITE_ZERO_MALLOC) \
313 + defined(SQLITE_MEMDEBUG)>1
314 # error "Two or more of the following compile-time configuration options\
315 are defined but at most one is allowed:\
316 SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\
319 #if defined(SQLITE_SYSTEM_MALLOC) \
320 + defined(SQLITE_WIN32_MALLOC) \
321 + defined(SQLITE_ZERO_MALLOC) \
322 + defined(SQLITE_MEMDEBUG)==0
323 # define SQLITE_SYSTEM_MALLOC 1
327 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
328 ** sizes of memory allocations below this value where possible.
330 #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
331 # define SQLITE_MALLOC_SOFT_LIMIT 1024
335 ** We need to define _XOPEN_SOURCE as follows in order to enable
336 ** recursive mutexes on most Unix systems and fchmod() on OpenBSD.
337 ** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
340 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
341 # define _XOPEN_SOURCE 600
345 ** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that
346 ** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,
347 ** make it true by defining or undefining NDEBUG.
349 ** Setting NDEBUG makes the code smaller and faster by disabling the
350 ** assert() statements in the code. So we want the default action
351 ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
352 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
355 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
358 #if defined(NDEBUG) && defined(SQLITE_DEBUG)
363 ** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
365 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
366 # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
370 ** The testcase() macro is used to aid in coverage testing. When
371 ** doing coverage testing, the condition inside the argument to
372 ** testcase() must be evaluated both true and false in order to
373 ** get full branch coverage. The testcase() macro is inserted
374 ** to help ensure adequate test coverage in places where simple
375 ** condition/decision coverage is inadequate. For example, testcase()
376 ** can be used to make sure boundary values are tested. For
377 ** bitmask tests, testcase() can be used to make sure each bit
378 ** is significant and used at least once. On switch statements
379 ** where multiple cases go to the same block of code, testcase()
380 ** can insure that all cases are evaluated.
383 #ifdef SQLITE_COVERAGE_TEST
384 void sqlite3Coverage(int);
385 # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
391 ** The TESTONLY macro is used to enclose variable declarations or
392 ** other bits of code that are needed to support the arguments
393 ** within testcase() and assert() macros.
395 #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
396 # define TESTONLY(X) X
402 ** Sometimes we need a small amount of code such as a variable initialization
403 ** to setup for a later assert() statement. We do not want this code to
404 ** appear when assert() is disabled. The following macro is therefore
405 ** used to contain that setup code. The "VVA" acronym stands for
406 ** "Verification, Validation, and Accreditation". In other words, the
407 ** code within VVA_ONLY() will only run during verification processes.
410 # define VVA_ONLY(X) X
416 ** The ALWAYS and NEVER macros surround boolean expressions which
417 ** are intended to always be true or false, respectively. Such
418 ** expressions could be omitted from the code completely. But they
419 ** are included in a few cases in order to enhance the resilience
420 ** of SQLite to unexpected behavior - to make the code "self-healing"
421 ** or "ductile" rather than being "brittle" and crashing at the first
422 ** hint of unplanned behavior.
424 ** In other words, ALWAYS and NEVER are added for defensive code.
426 ** When doing coverage testing ALWAYS and NEVER are hard-coded to
427 ** be true and false so that the unreachable code they specify will
428 ** not be counted as untested code.
430 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
431 # define ALWAYS(X) (1)
432 # define NEVER(X) (0)
433 #elif !defined(NDEBUG)
434 # define ALWAYS(X) ((X)?1:(assert(0),0))
435 # define NEVER(X) ((X)?(assert(0),1):0)
437 # define ALWAYS(X) (X)
438 # define NEVER(X) (X)
442 ** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
443 ** defined. We need to defend against those failures when testing with
444 ** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
445 ** during a normal build. The following macro can be used to disable tests
446 ** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
448 #if defined(SQLITE_TEST_REALLOC_STRESS)
449 # define ONLY_IF_REALLOC_STRESS(X) (X)
450 #elif !defined(NDEBUG)
451 # define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)
453 # define ONLY_IF_REALLOC_STRESS(X) (0)
457 ** Declarations used for tracing the operating system interfaces.
459 #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \
460 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
461 extern int sqlite3OSTrace
;
462 # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
463 # define SQLITE_HAVE_OS_TRACE
466 # undef SQLITE_HAVE_OS_TRACE
470 ** Is the sqlite3ErrName() function needed in the build? Currently,
471 ** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when
472 ** OSTRACE is enabled), and by several "test*.c" files (which are
473 ** compiled using SQLITE_TEST).
475 #if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \
476 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
477 # define SQLITE_NEED_ERR_NAME
479 # undef SQLITE_NEED_ERR_NAME
483 ** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN
485 #ifdef SQLITE_OMIT_EXPLAIN
486 # undef SQLITE_ENABLE_EXPLAIN_COMMENTS
490 ** Return true (non-zero) if the input is an integer that is too large
491 ** to fit in 32-bits. This macro is used inside of various testcase()
492 ** macros to verify that we have tested SQLite for large-file support.
494 #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
497 ** The macro unlikely() is a hint that surrounds a boolean
498 ** expression that is usually false. Macro likely() surrounds
499 ** a boolean expression that is usually true. These hints could,
500 ** in theory, be used by the compiler to generate better code, but
501 ** currently they are just comments for human readers.
503 #define likely(X) (X)
504 #define unlikely(X) (X)
515 ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
516 ** This allows better measurements of where memcpy() is used when running
517 ** cachegrind. But this macro version of memcpy() is very slow so it
518 ** should not be used in production. This is a performance measurement
521 #ifdef SQLITE_INLINE_MEMCPY
522 # define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
523 int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
527 ** If compiling for a processor that lacks floating point support,
528 ** substitute integer for floating-point
530 #ifdef SQLITE_OMIT_FLOATING_POINT
531 # define double sqlite_int64
532 # define float sqlite_int64
533 # define LONGDOUBLE_TYPE sqlite_int64
534 # ifndef SQLITE_BIG_DBL
535 # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
537 # define SQLITE_OMIT_DATETIME_FUNCS 1
538 # define SQLITE_OMIT_TRACE 1
539 # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
540 # undef SQLITE_HAVE_ISNAN
542 #ifndef SQLITE_BIG_DBL
543 # define SQLITE_BIG_DBL (1e99)
547 ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
548 ** afterward. Having this macro allows us to cause the C compiler
549 ** to omit code used by TEMP tables without messy #ifndef statements.
551 #ifdef SQLITE_OMIT_TEMPDB
552 #define OMIT_TEMPDB 1
554 #define OMIT_TEMPDB 0
558 ** The "file format" number is an integer that is incremented whenever
559 ** the VDBE-level file format changes. The following macros define the
560 ** the default file format for new databases and the maximum file format
561 ** that the library can read.
563 #define SQLITE_MAX_FILE_FORMAT 4
564 #ifndef SQLITE_DEFAULT_FILE_FORMAT
565 # define SQLITE_DEFAULT_FILE_FORMAT 4
569 ** Determine whether triggers are recursive by default. This can be
570 ** changed at run-time using a pragma.
572 #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
573 # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
577 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
578 ** on the command-line
580 #ifndef SQLITE_TEMP_STORE
581 # define SQLITE_TEMP_STORE 1
582 # define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */
586 ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
587 ** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
590 #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
591 # undef SQLITE_MAX_WORKER_THREADS
592 # define SQLITE_MAX_WORKER_THREADS 0
594 #ifndef SQLITE_MAX_WORKER_THREADS
595 # define SQLITE_MAX_WORKER_THREADS 8
597 #ifndef SQLITE_DEFAULT_WORKER_THREADS
598 # define SQLITE_DEFAULT_WORKER_THREADS 0
600 #if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS
601 # undef SQLITE_MAX_WORKER_THREADS
602 # define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS
606 ** The default initial allocation for the pagecache when using separate
607 ** pagecaches for each database connection. A positive number is the
608 ** number of pages. A negative number N translations means that a buffer
609 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
611 ** The default value of "20" was choosen to minimize the run-time of the
612 ** speedtest1 test program with options: --shrink-memory --reprepare
614 #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
615 # define SQLITE_DEFAULT_PCACHE_INITSZ 20
619 ** GCC does not define the offsetof() macro so we'll have to do it
623 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
627 ** Macros to compute minimum and maximum of two numbers.
630 # define MIN(A,B) ((A)<(B)?(A):(B))
633 # define MAX(A,B) ((A)>(B)?(A):(B))
637 ** Swap two objects of type TYPE.
639 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
642 ** Check to see if this machine uses EBCDIC. (Yes, believe it or
643 ** not, there are still machines out there that use EBCDIC.)
646 # define SQLITE_EBCDIC 1
648 # define SQLITE_ASCII 1
652 ** Integers of known sizes. These typedefs might change for architectures
653 ** where the sizes very. Preprocessor macros are available so that the
654 ** types can be conveniently redefined at compile-type. Like this:
656 ** cc '-DUINTPTR_TYPE=long long int' ...
659 # ifdef HAVE_UINT32_T
660 # define UINT32_TYPE uint32_t
662 # define UINT32_TYPE unsigned int
666 # ifdef HAVE_UINT16_T
667 # define UINT16_TYPE uint16_t
669 # define UINT16_TYPE unsigned short int
674 # define INT16_TYPE int16_t
676 # define INT16_TYPE short int
681 # define UINT8_TYPE uint8_t
683 # define UINT8_TYPE unsigned char
688 # define INT8_TYPE int8_t
690 # define INT8_TYPE signed char
693 #ifndef LONGDOUBLE_TYPE
694 # define LONGDOUBLE_TYPE long double
696 typedef sqlite_int64 i64
; /* 8-byte signed integer */
697 typedef sqlite_uint64 u64
; /* 8-byte unsigned integer */
698 typedef UINT32_TYPE u32
; /* 4-byte unsigned integer */
699 typedef UINT16_TYPE u16
; /* 2-byte unsigned integer */
700 typedef INT16_TYPE i16
; /* 2-byte signed integer */
701 typedef UINT8_TYPE u8
; /* 1-byte unsigned integer */
702 typedef INT8_TYPE i8
; /* 1-byte signed integer */
705 ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
706 ** that can be stored in a u32 without loss of data. The value
707 ** is 0x00000000ffffffff. But because of quirks of some compilers, we
708 ** have to specify the value in the less intuitive manner shown:
710 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
713 ** The datatype used to store estimates of the number of rows in a
714 ** table or index. This is an unsigned integer type. For 99.9% of
715 ** the world, a 32-bit integer is sufficient. But a 64-bit integer
716 ** can be used at compile-time if desired.
718 #ifdef SQLITE_64BIT_STATS
719 typedef u64 tRowcnt
; /* 64-bit only if requested at compile-time */
721 typedef u32 tRowcnt
; /* 32-bit is the default */
725 ** Estimated quantities used for query planning are stored as 16-bit
726 ** logarithms. For quantity X, the value stored is 10*log2(X). This
727 ** gives a possible range of values of approximately 1.0e986 to 1e-986.
728 ** But the allowed values are "grainy". Not every value is representable.
729 ** For example, quantities 16 and 17 are both represented by a LogEst
730 ** of 40. However, since LogEst quantities are suppose to be estimates,
731 ** not exact values, this imprecision is not a problem.
733 ** "LogEst" is short for "Logarithmic Estimate".
736 ** 1 -> 0 20 -> 43 10000 -> 132
737 ** 2 -> 10 25 -> 46 25000 -> 146
738 ** 3 -> 16 100 -> 66 1000000 -> 199
739 ** 4 -> 20 1000 -> 99 1048576 -> 200
740 ** 10 -> 33 1024 -> 100 4294967296 -> 320
742 ** The LogEst can be negative to indicate fractional values.
745 ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
747 typedef INT16_TYPE LogEst
;
750 ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
752 #ifndef SQLITE_PTRSIZE
753 # if defined(__SIZEOF_POINTER__)
754 # define SQLITE_PTRSIZE __SIZEOF_POINTER__
755 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
756 defined(_M_ARM) || defined(__arm__) || defined(__x86)
757 # define SQLITE_PTRSIZE 4
759 # define SQLITE_PTRSIZE 8
763 /* The uptr type is an unsigned integer large enough to hold a pointer
765 #if defined(HAVE_STDINT_H)
766 typedef uintptr_t uptr
;
767 #elif SQLITE_PTRSIZE==4
774 ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
775 ** something between S (inclusive) and E (exclusive).
777 ** In other words, S is a buffer and E is a pointer to the first byte after
778 ** the end of buffer S. This macro returns true if P points to something
779 ** contained within the buffer S.
781 #define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
785 ** Macros to determine whether the machine is big or little endian,
786 ** and whether or not that determination is run-time or compile-time.
788 ** For best performance, an attempt is made to guess at the byte-order
789 ** using C-preprocessor macros. If that is unsuccessful, or if
790 ** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
793 #if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \
794 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
795 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
796 defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)
797 # define SQLITE_BYTEORDER 1234
798 # define SQLITE_BIGENDIAN 0
799 # define SQLITE_LITTLEENDIAN 1
800 # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
802 #if (defined(sparc) || defined(__ppc__)) \
803 && !defined(SQLITE_RUNTIME_BYTEORDER)
804 # define SQLITE_BYTEORDER 4321
805 # define SQLITE_BIGENDIAN 1
806 # define SQLITE_LITTLEENDIAN 0
807 # define SQLITE_UTF16NATIVE SQLITE_UTF16BE
809 #if !defined(SQLITE_BYTEORDER)
810 # ifdef SQLITE_AMALGAMATION
811 const int sqlite3one
= 1;
813 extern const int sqlite3one
;
815 # define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */
816 # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
817 # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
818 # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
822 ** Constants for the largest and smallest possible 64-bit signed integers.
823 ** These macros are designed to work correctly on both 32-bit and 64-bit
826 #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
827 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
830 ** Round up a number to the next larger multiple of 8. This is used
831 ** to force 8-byte alignment on 64-bit architectures.
833 #define ROUND8(x) (((x)+7)&~7)
836 ** Round down to the nearest multiple of 8
838 #define ROUNDDOWN8(x) ((x)&~7)
841 ** Assert that the pointer X is aligned to an 8-byte boundary. This
842 ** macro is used only within assert() to verify that the code gets
843 ** all alignment restrictions correct.
845 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
846 ** underlying malloc() implementation might return us 4-byte aligned
847 ** pointers. In that case, only verify 4-byte alignment.
849 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
850 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
852 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
856 ** Disable MMAP on platforms where it is known to not work
858 #if defined(__OpenBSD__) || defined(__QNXNTO__)
859 # undef SQLITE_MAX_MMAP_SIZE
860 # define SQLITE_MAX_MMAP_SIZE 0
864 ** Default maximum size of memory used by memory-mapped I/O in the VFS
867 # include <TargetConditionals.h>
869 #ifndef SQLITE_MAX_MMAP_SIZE
870 # if defined(__linux__) \
872 || (defined(__APPLE__) && defined(__MACH__)) \
874 || defined(__FreeBSD__) \
875 || defined(__DragonFly__)
876 # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */
878 # define SQLITE_MAX_MMAP_SIZE 0
880 # define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */
884 ** The default MMAP_SIZE is zero on all platforms. Or, even if a larger
885 ** default MMAP_SIZE is specified at compile-time, make sure that it does
886 ** not exceed the maximum mmap size.
888 #ifndef SQLITE_DEFAULT_MMAP_SIZE
889 # define SQLITE_DEFAULT_MMAP_SIZE 0
890 # define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */
892 #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
893 # undef SQLITE_DEFAULT_MMAP_SIZE
894 # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
898 ** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.
899 ** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also
900 ** define SQLITE_ENABLE_STAT3_OR_STAT4
902 #ifdef SQLITE_ENABLE_STAT4
903 # undef SQLITE_ENABLE_STAT3
904 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
905 #elif SQLITE_ENABLE_STAT3
906 # define SQLITE_ENABLE_STAT3_OR_STAT4 1
907 #elif SQLITE_ENABLE_STAT3_OR_STAT4
908 # undef SQLITE_ENABLE_STAT3_OR_STAT4
912 ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
913 ** the Select query generator tracing logic is turned on.
915 #if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE)
916 # define SELECTTRACE_ENABLED 1
918 # define SELECTTRACE_ENABLED 0
922 ** An instance of the following structure is used to store the busy-handler
923 ** callback for a given sqlite handle.
925 ** The sqlite.busyHandler member of the sqlite struct contains the busy
926 ** callback for the database handle. Each pager opened via the sqlite
927 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
928 ** callback is currently invoked only from within pager.c.
930 typedef struct BusyHandler BusyHandler
;
932 int (*xFunc
)(void *,int); /* The busy callback */
933 void *pArg
; /* First arg to busy callback */
934 int nBusy
; /* Incremented with each busy call */
938 ** Name of the master database table. The master database table
939 ** is a special table that holds the names and attributes of all
940 ** user tables and indices.
942 #define MASTER_NAME "sqlite_master"
943 #define TEMP_MASTER_NAME "sqlite_temp_master"
946 ** The root-page of the master database table.
948 #define MASTER_ROOT 1
951 ** The name of the schema table.
953 #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
956 ** A convenience macro that returns the number of elements in
959 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
962 ** Determine if the argument is a power of two
964 #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
967 ** The following value as a destructor means to use sqlite3DbFree().
968 ** The sqlite3DbFree() routine requires two parameters instead of the
969 ** one parameter that destructors normally want. So we have to introduce
970 ** this magic value that the code knows to handle differently. Any
971 ** pointer will work here as long as it is distinct from SQLITE_STATIC
972 ** and SQLITE_TRANSIENT.
974 #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)
977 ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
978 ** not support Writable Static Data (WSD) such as global and static variables.
979 ** All variables must either be on the stack or dynamically allocated from
980 ** the heap. When WSD is unsupported, the variable declarations scattered
981 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
982 ** macro is used for this purpose. And instead of referencing the variable
983 ** directly, we use its constant as a key to lookup the run-time allocated
984 ** buffer that holds real variable. The constant is also the initializer
985 ** for the run-time allocated buffer.
987 ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
988 ** macros become no-ops and have zero performance impact.
990 #ifdef SQLITE_OMIT_WSD
991 #define SQLITE_WSD const
992 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
993 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
994 int sqlite3_wsd_init(int N
, int J
);
995 void *sqlite3_wsd_find(void *K
, int L
);
998 #define GLOBAL(t,v) v
999 #define sqlite3GlobalConfig sqlite3Config
1003 ** The following macros are used to suppress compiler warnings and to
1004 ** make it clear to human readers when a function parameter is deliberately
1005 ** left unused within the body of a function. This usually happens when
1006 ** a function is called via a function pointer. For example the
1007 ** implementation of an SQL aggregate step callback may not use the
1008 ** parameter indicating the number of arguments passed to the aggregate,
1009 ** if it knows that this is enforced elsewhere.
1011 ** When a function parameter is not used at all within the body of a function,
1012 ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
1013 ** However, these macros may also be used to suppress warnings related to
1014 ** parameters that may or may not be used depending on compilation options.
1015 ** For example those parameters only used in assert() statements. In these
1016 ** cases the parameters are named as per the usual conventions.
1018 #define UNUSED_PARAMETER(x) (void)(x)
1019 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
1022 ** Forward references to structures
1024 typedef struct AggInfo AggInfo
;
1025 typedef struct AuthContext AuthContext
;
1026 typedef struct AutoincInfo AutoincInfo
;
1027 typedef struct Bitvec Bitvec
;
1028 typedef struct CollSeq CollSeq
;
1029 typedef struct Column Column
;
1030 typedef struct Db Db
;
1031 typedef struct Schema Schema
;
1032 typedef struct Expr Expr
;
1033 typedef struct ExprList ExprList
;
1034 typedef struct ExprSpan ExprSpan
;
1035 typedef struct FKey FKey
;
1036 typedef struct FuncDestructor FuncDestructor
;
1037 typedef struct FuncDef FuncDef
;
1038 typedef struct FuncDefHash FuncDefHash
;
1039 typedef struct IdList IdList
;
1040 typedef struct Index Index
;
1041 typedef struct IndexSample IndexSample
;
1042 typedef struct KeyClass KeyClass
;
1043 typedef struct KeyInfo KeyInfo
;
1044 typedef struct Lookaside Lookaside
;
1045 typedef struct LookasideSlot LookasideSlot
;
1046 typedef struct Module Module
;
1047 typedef struct NameContext NameContext
;
1048 typedef struct Parse Parse
;
1049 typedef struct PreUpdate PreUpdate
;
1050 typedef struct PrintfArguments PrintfArguments
;
1051 typedef struct RowSet RowSet
;
1052 typedef struct Savepoint Savepoint
;
1053 typedef struct Select Select
;
1054 typedef struct SQLiteThread SQLiteThread
;
1055 typedef struct SelectDest SelectDest
;
1056 typedef struct SrcList SrcList
;
1057 typedef struct StrAccum StrAccum
;
1058 typedef struct Table Table
;
1059 typedef struct TableLock TableLock
;
1060 typedef struct Token Token
;
1061 typedef struct TreeView TreeView
;
1062 typedef struct Trigger Trigger
;
1063 typedef struct TriggerPrg TriggerPrg
;
1064 typedef struct TriggerStep TriggerStep
;
1065 typedef struct UnpackedRecord UnpackedRecord
;
1066 typedef struct VTable VTable
;
1067 typedef struct VtabCtx VtabCtx
;
1068 typedef struct Walker Walker
;
1069 typedef struct WhereInfo WhereInfo
;
1070 typedef struct With With
;
1072 /* A VList object records a mapping between parameters/variables/wildcards
1073 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
1074 ** variable number associated with that parameter. See the format description
1075 ** on the sqlite3VListAdd() routine for more information. A VList is really
1076 ** just an array of integers.
1081 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
1082 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
1083 ** pointer types (i.e. FuncDef) defined above.
1092 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
1093 ** synchronous setting to EXTRA. It is no longer supported.
1095 #ifdef SQLITE_EXTRA_DURABLE
1096 # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
1097 # define SQLITE_DEFAULT_SYNCHRONOUS 3
1101 ** Default synchronous levels.
1103 ** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ
1104 ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
1106 ** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS
1112 ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
1113 ** In other words, the zero-based numbers are used for all external interfaces
1114 ** and the one-based values are used internally.
1116 #ifndef SQLITE_DEFAULT_SYNCHRONOUS
1117 # define SQLITE_DEFAULT_SYNCHRONOUS (PAGER_SYNCHRONOUS_FULL-1)
1119 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
1120 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
1124 ** Each database file to be accessed by the system is an instance
1125 ** of the following structure. There are normally two of these structures
1126 ** in the sqlite.aDb[] array. aDb[0] is the main database file and
1127 ** aDb[1] is the database file used to hold temporary tables. Additional
1128 ** databases may be attached.
1131 char *zDbSName
; /* Name of this database. (schema name, not filename) */
1132 Btree
*pBt
; /* The B*Tree structure for this database file */
1133 u8 safety_level
; /* How aggressive at syncing data to disk */
1134 u8 bSyncSet
; /* True if "PRAGMA synchronous=N" has been run */
1135 Schema
*pSchema
; /* Pointer to database schema (possibly shared) */
1139 ** An instance of the following structure stores a database schema.
1141 ** Most Schema objects are associated with a Btree. The exception is
1142 ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
1143 ** In shared cache mode, a single Schema object can be shared by multiple
1144 ** Btrees that refer to the same underlying BtShared object.
1146 ** Schema objects are automatically deallocated when the last Btree that
1147 ** references them is destroyed. The TEMP Schema is manually freed by
1150 ** A thread must be holding a mutex on the corresponding Btree in order
1151 ** to access Schema content. This implies that the thread must also be
1152 ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
1153 ** For a TEMP Schema, only the connection mutex is required.
1156 int schema_cookie
; /* Database schema version number for this file */
1157 int iGeneration
; /* Generation counter. Incremented with each change */
1158 Hash tblHash
; /* All tables indexed by name */
1159 Hash idxHash
; /* All (named) indices indexed by name */
1160 Hash trigHash
; /* All triggers indexed by name */
1161 Hash fkeyHash
; /* All foreign keys by referenced table name */
1162 Table
*pSeqTab
; /* The sqlite_sequence table used by AUTOINCREMENT */
1163 u8 file_format
; /* Schema format version for this file */
1164 u8 enc
; /* Text encoding used by this database */
1165 u16 schemaFlags
; /* Flags associated with this schema */
1166 int cache_size
; /* Number of pages to use in the cache */
1170 ** These macros can be used to test, set, or clear bits in the
1171 ** Db.pSchema->flags field.
1173 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
1174 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
1175 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
1176 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
1179 ** Allowed values for the DB.pSchema->flags field.
1181 ** The DB_SchemaLoaded flag is set after the database schema has been
1182 ** read into internal hash tables.
1184 ** DB_UnresetViews means that one or more views have column names that
1185 ** have been filled out. If the schema changes, these column names might
1186 ** changes and so the view will need to be reset.
1188 #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
1189 #define DB_UnresetViews 0x0002 /* Some views have defined column names */
1190 #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
1193 ** The number of different kinds of things that can be limited
1194 ** using the sqlite3_limit() interface.
1196 #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
1199 ** Lookaside malloc is a set of fixed-size buffers that can be used
1200 ** to satisfy small transient memory allocation requests for objects
1201 ** associated with a particular database connection. The use of
1202 ** lookaside malloc provides a significant performance enhancement
1203 ** (approx 10%) by avoiding numerous malloc/free requests while parsing
1206 ** The Lookaside structure holds configuration information about the
1207 ** lookaside malloc subsystem. Each available memory allocation in
1208 ** the lookaside subsystem is stored on a linked list of LookasideSlot
1211 ** Lookaside allocations are only allowed for objects that are associated
1212 ** with a particular database connection. Hence, schema information cannot
1213 ** be stored in lookaside because in shared cache mode the schema information
1214 ** is shared by multiple database connections. Therefore, while parsing
1215 ** schema information, the Lookaside.bEnabled flag is cleared so that
1216 ** lookaside allocations are not used to construct the schema objects.
1219 u32 bDisable
; /* Only operate the lookaside when zero */
1220 u16 sz
; /* Size of each buffer in bytes */
1221 u8 bMalloced
; /* True if pStart obtained from sqlite3_malloc() */
1222 int nOut
; /* Number of buffers currently checked out */
1223 int mxOut
; /* Highwater mark for nOut */
1224 int anStat
[3]; /* 0: hits. 1: size misses. 2: full misses */
1225 LookasideSlot
*pFree
; /* List of available buffers */
1226 void *pStart
; /* First byte of available memory space */
1227 void *pEnd
; /* First byte past end of available space */
1229 struct LookasideSlot
{
1230 LookasideSlot
*pNext
; /* Next buffer in the list of free buffers */
1234 ** A hash table for built-in function definitions. (Application-defined
1235 ** functions use a regular table table from hash.h.)
1237 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
1238 ** Collisions are on the FuncDef.u.pHash chain.
1240 #define SQLITE_FUNC_HASH_SZ 23
1241 struct FuncDefHash
{
1242 FuncDef
*a
[SQLITE_FUNC_HASH_SZ
]; /* Hash table for functions */
1245 #ifdef SQLITE_USER_AUTHENTICATION
1247 ** Information held in the "sqlite3" database connection object and used
1248 ** to manage user authentication.
1250 typedef struct sqlite3_userauth sqlite3_userauth
;
1251 struct sqlite3_userauth
{
1252 u8 authLevel
; /* Current authentication level */
1253 int nAuthPW
; /* Size of the zAuthPW in bytes */
1254 char *zAuthPW
; /* Password used to authenticate */
1255 char *zAuthUser
; /* User name used to authenticate */
1258 /* Allowed values for sqlite3_userauth.authLevel */
1259 #define UAUTH_Unknown 0 /* Authentication not yet checked */
1260 #define UAUTH_Fail 1 /* User authentication failed */
1261 #define UAUTH_User 2 /* Authenticated as a normal user */
1262 #define UAUTH_Admin 3 /* Authenticated as an administrator */
1264 /* Functions used only by user authorization logic */
1265 int sqlite3UserAuthTable(const char*);
1266 int sqlite3UserAuthCheckLogin(sqlite3
*,const char*,u8
*);
1267 void sqlite3UserAuthInit(sqlite3
*);
1268 void sqlite3CryptFunc(sqlite3_context
*,int,sqlite3_value
**);
1270 #endif /* SQLITE_USER_AUTHENTICATION */
1273 ** typedef for the authorization callback function.
1275 #ifdef SQLITE_USER_AUTHENTICATION
1276 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1277 const char*, const char*);
1279 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1283 #ifndef SQLITE_OMIT_DEPRECATED
1284 /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
1285 ** in the style of sqlite3_trace()
1287 #define SQLITE_TRACE_LEGACY 0x80
1289 #define SQLITE_TRACE_LEGACY 0
1290 #endif /* SQLITE_OMIT_DEPRECATED */
1294 ** Each database connection is an instance of the following structure.
1297 sqlite3_vfs
*pVfs
; /* OS Interface */
1298 struct Vdbe
*pVdbe
; /* List of active virtual machines */
1299 CollSeq
*pDfltColl
; /* The default collating sequence (BINARY) */
1300 sqlite3_mutex
*mutex
; /* Connection mutex */
1301 Db
*aDb
; /* All backends */
1302 int nDb
; /* Number of backends currently in use */
1303 int flags
; /* Miscellaneous flags. See below */
1304 i64 lastRowid
; /* ROWID of most recent insert (see above) */
1305 i64 szMmap
; /* Default mmap_size setting */
1306 unsigned int openFlags
; /* Flags passed to sqlite3_vfs.xOpen() */
1307 int errCode
; /* Most recent error code (SQLITE_*) */
1308 int errMask
; /* & result codes with this before returning */
1309 int iSysErrno
; /* Errno value from last system error */
1310 u16 dbOptFlags
; /* Flags to enable/disable optimizations */
1311 u8 enc
; /* Text encoding */
1312 u8 autoCommit
; /* The auto-commit flag. */
1313 u8 temp_store
; /* 1: file 2: memory 0: default */
1314 u8 mallocFailed
; /* True if we have seen a malloc failure */
1315 u8 bBenignMalloc
; /* Do not require OOMs if true */
1316 u8 dfltLockMode
; /* Default locking-mode for attached dbs */
1317 signed char nextAutovac
; /* Autovac setting after VACUUM if >=0 */
1318 u8 suppressErr
; /* Do not issue error messages if true */
1319 u8 vtabOnConflict
; /* Value to return for s3_vtab_on_conflict() */
1320 u8 isTransactionSavepoint
; /* True if the outermost savepoint is a TS */
1321 u8 mTrace
; /* zero or more SQLITE_TRACE flags */
1322 u8 skipBtreeMutex
; /* True if no shared-cache backends */
1323 int nextPagesize
; /* Pagesize after VACUUM if >0 */
1324 u32 magic
; /* Magic number for detect library misuse */
1325 int nChange
; /* Value returned by sqlite3_changes() */
1326 int nTotalChange
; /* Value returned by sqlite3_total_changes() */
1327 int aLimit
[SQLITE_N_LIMIT
]; /* Limits */
1328 int nMaxSorterMmap
; /* Maximum size of regions mapped by sorter */
1329 struct sqlite3InitInfo
{ /* Information used during initialization */
1330 int newTnum
; /* Rootpage of table being initialized */
1331 u8 iDb
; /* Which db file is being initialized */
1332 u8 busy
; /* TRUE if currently initializing */
1333 u8 orphanTrigger
; /* Last statement is orphaned TEMP trigger */
1334 u8 imposterTable
; /* Building an imposter table */
1336 int nVdbeActive
; /* Number of VDBEs currently running */
1337 int nVdbeRead
; /* Number of active VDBEs that read or write */
1338 int nVdbeWrite
; /* Number of active VDBEs that read and write */
1339 int nVdbeExec
; /* Number of nested calls to VdbeExec() */
1340 int nVDestroy
; /* Number of active OP_VDestroy operations */
1341 int nExtension
; /* Number of loaded extensions */
1342 void **aExtension
; /* Array of shared library handles */
1343 int (*xTrace
)(u32
,void*,void*,void*); /* Trace function */
1344 void *pTraceArg
; /* Argument to the trace function */
1345 void (*xProfile
)(void*,const char*,u64
); /* Profiling function */
1346 void *pProfileArg
; /* Argument to profile function */
1347 void *pCommitArg
; /* Argument to xCommitCallback() */
1348 int (*xCommitCallback
)(void*); /* Invoked at every commit. */
1349 void *pRollbackArg
; /* Argument to xRollbackCallback() */
1350 void (*xRollbackCallback
)(void*); /* Invoked at every commit. */
1352 void (*xUpdateCallback
)(void*,int, const char*,const char*,sqlite_int64
);
1353 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1354 void *pPreUpdateArg
; /* First argument to xPreUpdateCallback */
1355 void (*xPreUpdateCallback
)( /* Registered using sqlite3_preupdate_hook() */
1356 void*,sqlite3
*,int,char const*,char const*,sqlite3_int64
,sqlite3_int64
1358 PreUpdate
*pPreUpdate
; /* Context for active pre-update callback */
1359 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
1360 #ifndef SQLITE_OMIT_WAL
1361 int (*xWalCallback
)(void *, sqlite3
*, const char *, int);
1364 void(*xCollNeeded
)(void*,sqlite3
*,int eTextRep
,const char*);
1365 void(*xCollNeeded16
)(void*,sqlite3
*,int eTextRep
,const void*);
1366 void *pCollNeededArg
;
1367 sqlite3_value
*pErr
; /* Most recent error message */
1369 volatile int isInterrupted
; /* True if sqlite3_interrupt has been called */
1370 double notUsed1
; /* Spacer */
1372 Lookaside lookaside
; /* Lookaside malloc configuration */
1373 #ifndef SQLITE_OMIT_AUTHORIZATION
1374 sqlite3_xauth xAuth
; /* Access authorization function */
1375 void *pAuthArg
; /* 1st argument to the access auth function */
1377 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1378 int (*xProgress
)(void *); /* The progress callback */
1379 void *pProgressArg
; /* Argument to the progress callback */
1380 unsigned nProgressOps
; /* Number of opcodes for progress callback */
1382 #ifndef SQLITE_OMIT_VIRTUALTABLE
1383 int nVTrans
; /* Allocated size of aVTrans */
1384 Hash aModule
; /* populated by sqlite3_create_module() */
1385 VtabCtx
*pVtabCtx
; /* Context for active vtab connect/create */
1386 VTable
**aVTrans
; /* Virtual tables with open transactions */
1387 VTable
*pDisconnect
; /* Disconnect these in next sqlite3_prepare() */
1389 Hash aFunc
; /* Hash table of connection functions */
1390 Hash aCollSeq
; /* All collating sequences */
1391 BusyHandler busyHandler
; /* Busy callback */
1392 Db aDbStatic
[2]; /* Static space for the 2 default backends */
1393 Savepoint
*pSavepoint
; /* List of active savepoints */
1394 int busyTimeout
; /* Busy handler timeout, in msec */
1395 int nSavepoint
; /* Number of non-transaction savepoints */
1396 int nStatement
; /* Number of nested statement-transactions */
1397 i64 nDeferredCons
; /* Net deferred constraints this transaction. */
1398 i64 nDeferredImmCons
; /* Net deferred immediate constraints */
1399 int *pnBytesFreed
; /* If not NULL, increment this in DbFree() */
1400 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
1401 /* The following variables are all protected by the STATIC_MASTER
1402 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
1404 ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
1405 ** unlock so that it can proceed.
1407 ** When X.pBlockingConnection==Y, that means that something that X tried
1408 ** tried to do recently failed with an SQLITE_LOCKED error due to locks
1411 sqlite3
*pBlockingConnection
; /* Connection that caused SQLITE_LOCKED */
1412 sqlite3
*pUnlockConnection
; /* Connection to watch for unlock */
1413 void *pUnlockArg
; /* Argument to xUnlockNotify */
1414 void (*xUnlockNotify
)(void **, int); /* Unlock notify callback */
1415 sqlite3
*pNextBlocked
; /* Next in list of all blocked connections */
1417 #ifdef SQLITE_USER_AUTHENTICATION
1418 sqlite3_userauth auth
; /* User authentication information */
1423 ** A macro to discover the encoding of a database.
1425 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
1426 #define ENC(db) ((db)->enc)
1429 ** Possible values for the sqlite3.flags.
1431 ** Value constraints (enforced via assert()):
1432 ** SQLITE_FullFSync == PAGER_FULLFSYNC
1433 ** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
1434 ** SQLITE_CacheSpill == PAGER_CACHE_SPILL
1436 #define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */
1437 #define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */
1438 #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
1439 #define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */
1440 #define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */
1441 #define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */
1442 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
1443 #define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */
1444 /* DELETE, or UPDATE and return */
1445 /* the count using a callback. */
1446 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
1447 /* result set is empty */
1448 #define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */
1449 #define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */
1450 #define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */
1451 #define SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */
1452 #define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */
1453 #define SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */
1454 #define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */
1455 #define SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */
1456 #define SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */
1457 #define SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */
1458 #define SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */
1459 #define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */
1460 #define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */
1461 #define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */
1462 #define SQLITE_LoadExtFunc 0x00800000 /* Enable load_extension() SQL func */
1463 #define SQLITE_EnableTrigger 0x01000000 /* True to enable triggers */
1464 #define SQLITE_DeferFKs 0x02000000 /* Defer all FK constraints */
1465 #define SQLITE_QueryOnly 0x04000000 /* Disable database changes */
1466 #define SQLITE_VdbeEQP 0x08000000 /* Debug EXPLAIN QUERY PLAN */
1467 #define SQLITE_Vacuum 0x10000000 /* Currently in a VACUUM */
1468 #define SQLITE_CellSizeCk 0x20000000 /* Check btree cell sizes on load */
1469 #define SQLITE_Fts3Tokenizer 0x40000000 /* Enable fts3_tokenizer(2) */
1470 #define SQLITE_NoCkptOnClose 0x80000000 /* No checkpoint on close()/DETACH */
1474 ** Bits of the sqlite3.dbOptFlags field that are used by the
1475 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
1476 ** selectively disable various optimizations.
1478 #define SQLITE_QueryFlattener 0x0001 /* Query flattening */
1479 #define SQLITE_ColumnCache 0x0002 /* Column cache */
1480 #define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */
1481 #define SQLITE_FactorOutConst 0x0008 /* Constant factoring */
1482 /* not used 0x0010 // Was: SQLITE_IdxRealAsInt */
1483 #define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */
1484 #define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
1485 #define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
1486 #define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
1487 #define SQLITE_Transitive 0x0200 /* Transitive constraints */
1488 #define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */
1489 #define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */
1490 #define SQLITE_CursorHints 0x2000 /* Add OP_CursorHint opcodes */
1491 #define SQLITE_AllOpts 0xffff /* All optimizations */
1494 ** Macros for testing whether or not optimizations are enabled or disabled.
1496 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
1497 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
1500 ** Return true if it OK to factor constant expressions into the initialization
1501 ** code. The argument is a Parse object for the code generator.
1503 #define ConstFactorOk(P) ((P)->okConstFactor)
1506 ** Possible values for the sqlite.magic field.
1507 ** The numbers are obtained at random and have no special meaning, other
1508 ** than being distinct from one another.
1510 #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
1511 #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
1512 #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
1513 #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
1514 #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
1515 #define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */
1518 ** Each SQL function is defined by an instance of the following
1519 ** structure. For global built-in functions (ex: substr(), max(), count())
1520 ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
1521 ** For per-connection application-defined functions, a pointer to this
1522 ** structure is held in the db->aHash hash table.
1524 ** The u.pHash field is used by the global built-ins. The u.pDestructor
1525 ** field is used by per-connection app-def functions.
1528 i8 nArg
; /* Number of arguments. -1 means unlimited */
1529 u16 funcFlags
; /* Some combination of SQLITE_FUNC_* */
1530 void *pUserData
; /* User data parameter */
1531 FuncDef
*pNext
; /* Next function with same name */
1532 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**); /* func or agg-step */
1533 void (*xFinalize
)(sqlite3_context
*); /* Agg finalizer */
1534 const char *zName
; /* SQL name of the function. */
1536 FuncDef
*pHash
; /* Next with a different name but the same hash */
1537 FuncDestructor
*pDestructor
; /* Reference counted destructor function */
1542 ** This structure encapsulates a user-function destructor callback (as
1543 ** configured using create_function_v2()) and a reference counter. When
1544 ** create_function_v2() is called to create a function with a destructor,
1545 ** a single object of this type is allocated. FuncDestructor.nRef is set to
1546 ** the number of FuncDef objects created (either 1 or 3, depending on whether
1547 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
1548 ** member of each of the new FuncDef objects is set to point to the allocated
1551 ** Thereafter, when one of the FuncDef objects is deleted, the reference
1552 ** count on this object is decremented. When it reaches 0, the destructor
1553 ** is invoked and the FuncDestructor structure freed.
1555 struct FuncDestructor
{
1557 void (*xDestroy
)(void *);
1562 ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
1563 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
1564 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
1565 ** are assert() statements in the code to verify this.
1567 ** Value constraints (enforced via assert()):
1568 ** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
1569 ** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
1570 ** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
1571 ** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
1572 ** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
1574 #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
1575 #define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */
1576 #define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
1577 #define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
1578 #define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
1579 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
1580 #define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
1581 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
1582 #define SQLITE_FUNC_COALESCE 0x0200 /* Built-in coalesce() or ifnull() */
1583 #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
1584 #define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
1585 #define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
1586 #define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
1587 ** single query - might change over time */
1588 #define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
1591 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
1592 ** used to create the initializers for the FuncDef structures.
1594 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
1595 ** Used to create a scalar function definition of a function zName
1596 ** implemented by C function xFunc that accepts nArg arguments. The
1597 ** value passed as iArg is cast to a (void*) and made available
1598 ** as the user-data (sqlite3_user_data()) for the function. If
1599 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
1601 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
1602 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
1604 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
1605 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
1606 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
1607 ** and functions like sqlite_version() that can change, but not during
1610 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
1611 ** Used to create an aggregate function definition implemented by
1612 ** the C functions xStep and xFinal. The first four parameters
1613 ** are interpreted in the same way as the first 4 parameters to
1616 ** LIKEFUNC(zName, nArg, pArg, flags)
1617 ** Used to create a scalar function definition of a function zName
1618 ** that accepts nArg arguments and is implemented by a call to C
1619 ** function likeFunc. Argument pArg is cast to a (void *) and made
1620 ** available as the function user-data (sqlite3_user_data()). The
1621 ** FuncDef.flags variable is set to the value passed as the flags
1624 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
1625 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1626 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1627 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1628 {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1629 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1630 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
1631 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1632 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1633 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
1634 {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
1635 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
1636 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
1637 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1638 pArg, 0, xFunc, 0, #zName, }
1639 #define LIKEFUNC(zName, nArg, arg, flags) \
1640 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
1641 (void *)arg, 0, likeFunc, 0, #zName, {0} }
1642 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
1643 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
1644 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1645 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
1646 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
1647 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
1650 ** All current savepoints are stored in a linked list starting at
1651 ** sqlite3.pSavepoint. The first element in the list is the most recently
1652 ** opened savepoint. Savepoints are added to the list by the vdbe
1653 ** OP_Savepoint instruction.
1656 char *zName
; /* Savepoint name (nul-terminated) */
1657 i64 nDeferredCons
; /* Number of deferred fk violations */
1658 i64 nDeferredImmCons
; /* Number of deferred imm fk. */
1659 Savepoint
*pNext
; /* Parent savepoint (if any) */
1663 ** The following are used as the second parameter to sqlite3Savepoint(),
1664 ** and as the P1 argument to the OP_Savepoint instruction.
1666 #define SAVEPOINT_BEGIN 0
1667 #define SAVEPOINT_RELEASE 1
1668 #define SAVEPOINT_ROLLBACK 2
1672 ** Each SQLite module (virtual table definition) is defined by an
1673 ** instance of the following structure, stored in the sqlite3.aModule
1677 const sqlite3_module
*pModule
; /* Callback pointers */
1678 const char *zName
; /* Name passed to create_module() */
1679 void *pAux
; /* pAux passed to create_module() */
1680 void (*xDestroy
)(void *); /* Module destructor function */
1681 Table
*pEpoTab
; /* Eponymous table for this module */
1685 ** information about each column of an SQL table is held in an instance
1686 ** of this structure.
1689 char *zName
; /* Name of this column, \000, then the type */
1690 Expr
*pDflt
; /* Default value of this column */
1691 char *zColl
; /* Collating sequence. If NULL, use the default */
1692 u8 notNull
; /* An OE_ code for handling a NOT NULL constraint */
1693 char affinity
; /* One of the SQLITE_AFF_... values */
1694 u8 szEst
; /* Estimated size of value in this column. sizeof(INT)==1 */
1695 u8 colFlags
; /* Boolean properties. See COLFLAG_ defines below */
1698 /* Allowed values for Column.colFlags:
1700 #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
1701 #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
1702 #define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
1705 ** A "Collating Sequence" is defined by an instance of the following
1706 ** structure. Conceptually, a collating sequence consists of a name and
1707 ** a comparison routine that defines the order of that sequence.
1709 ** If CollSeq.xCmp is NULL, it means that the
1710 ** collating sequence is undefined. Indices built on an undefined
1711 ** collating sequence may not be read or written.
1714 char *zName
; /* Name of the collating sequence, UTF-8 encoded */
1715 u8 enc
; /* Text encoding handled by xCmp() */
1716 void *pUser
; /* First argument to xCmp() */
1717 int (*xCmp
)(void*,int, const void*, int, const void*);
1718 void (*xDel
)(void*); /* Destructor for pUser */
1722 ** A sort order can be either ASC or DESC.
1724 #define SQLITE_SO_ASC 0 /* Sort in ascending order */
1725 #define SQLITE_SO_DESC 1 /* Sort in ascending order */
1726 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
1729 ** Column affinity types.
1731 ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
1732 ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
1733 ** the speed a little by numbering the values consecutively.
1735 ** But rather than start with 0 or 1, we begin with 'A'. That way,
1736 ** when multiple affinity types are concatenated into a string and
1737 ** used as the P4 operand, they will be more readable.
1739 ** Note also that the numeric types are grouped together so that testing
1740 ** for a numeric type is a single comparison. And the BLOB type is first.
1742 #define SQLITE_AFF_BLOB 'A'
1743 #define SQLITE_AFF_TEXT 'B'
1744 #define SQLITE_AFF_NUMERIC 'C'
1745 #define SQLITE_AFF_INTEGER 'D'
1746 #define SQLITE_AFF_REAL 'E'
1748 #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
1751 ** The SQLITE_AFF_MASK values masks off the significant bits of an
1754 #define SQLITE_AFF_MASK 0x47
1757 ** Additional bit values that can be ORed with an affinity without
1758 ** changing the affinity.
1760 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
1761 ** It causes an assert() to fire if either operand to a comparison
1762 ** operator is NULL. It is added to certain comparison operators to
1763 ** prove that the operands are always NOT NULL.
1765 #define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */
1766 #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
1767 #define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */
1768 #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
1769 #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */
1772 ** An object of this type is created for each virtual table present in
1773 ** the database schema.
1775 ** If the database schema is shared, then there is one instance of this
1776 ** structure for each database connection (sqlite3*) that uses the shared
1777 ** schema. This is because each database connection requires its own unique
1778 ** instance of the sqlite3_vtab* handle used to access the virtual table
1779 ** implementation. sqlite3_vtab* handles can not be shared between
1780 ** database connections, even when the rest of the in-memory database
1781 ** schema is shared, as the implementation often stores the database
1782 ** connection handle passed to it via the xConnect() or xCreate() method
1783 ** during initialization internally. This database connection handle may
1784 ** then be used by the virtual table implementation to access real tables
1785 ** within the database. So that they appear as part of the callers
1786 ** transaction, these accesses need to be made via the same database
1787 ** connection as that used to execute SQL operations on the virtual table.
1789 ** All VTable objects that correspond to a single table in a shared
1790 ** database schema are initially stored in a linked-list pointed to by
1791 ** the Table.pVTable member variable of the corresponding Table object.
1792 ** When an sqlite3_prepare() operation is required to access the virtual
1793 ** table, it searches the list for the VTable that corresponds to the
1794 ** database connection doing the preparing so as to use the correct
1795 ** sqlite3_vtab* handle in the compiled query.
1797 ** When an in-memory Table object is deleted (for example when the
1798 ** schema is being reloaded for some reason), the VTable objects are not
1799 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
1800 ** immediately. Instead, they are moved from the Table.pVTable list to
1801 ** another linked list headed by the sqlite3.pDisconnect member of the
1802 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
1803 ** next time a statement is prepared using said sqlite3*. This is done
1804 ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
1805 ** Refer to comments above function sqlite3VtabUnlockList() for an
1806 ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
1807 ** list without holding the corresponding sqlite3.mutex mutex.
1809 ** The memory for objects of this type is always allocated by
1810 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
1811 ** the first argument.
1814 sqlite3
*db
; /* Database connection associated with this table */
1815 Module
*pMod
; /* Pointer to module implementation */
1816 sqlite3_vtab
*pVtab
; /* Pointer to vtab instance */
1817 int nRef
; /* Number of pointers to this structure */
1818 u8 bConstraint
; /* True if constraints are supported */
1819 int iSavepoint
; /* Depth of the SAVEPOINT stack */
1820 VTable
*pNext
; /* Next in linked list (see above) */
1824 ** The schema for each SQL table and view is represented in memory
1825 ** by an instance of the following structure.
1828 char *zName
; /* Name of the table or view */
1829 Column
*aCol
; /* Information about each column */
1830 Index
*pIndex
; /* List of SQL indexes on this table. */
1831 Select
*pSelect
; /* NULL for tables. Points to definition if a view. */
1832 FKey
*pFKey
; /* Linked list of all foreign keys in this table */
1833 char *zColAff
; /* String defining the affinity of each column */
1834 ExprList
*pCheck
; /* All CHECK constraints */
1835 /* ... also used as column name list in a VIEW */
1836 int tnum
; /* Root BTree page for this table */
1837 u32 nTabRef
; /* Number of pointers to this Table */
1838 i16 iPKey
; /* If not negative, use aCol[iPKey] as the rowid */
1839 i16 nCol
; /* Number of columns in this table */
1840 LogEst nRowLogEst
; /* Estimated rows in table - from sqlite_stat1 table */
1841 LogEst szTabRow
; /* Estimated size of each table row in bytes */
1842 #ifdef SQLITE_ENABLE_COSTMULT
1843 LogEst costMult
; /* Cost multiplier for using this table */
1845 u8 tabFlags
; /* Mask of TF_* values */
1846 u8 keyConf
; /* What to do in case of uniqueness conflict on iPKey */
1847 #ifndef SQLITE_OMIT_ALTERTABLE
1848 int addColOffset
; /* Offset in CREATE TABLE stmt to add a new column */
1850 #ifndef SQLITE_OMIT_VIRTUALTABLE
1851 int nModuleArg
; /* Number of arguments to the module */
1852 char **azModuleArg
; /* 0: module 1: schema 2: vtab name 3...: args */
1853 VTable
*pVTable
; /* List of VTable objects. */
1855 Trigger
*pTrigger
; /* List of triggers stored in pSchema */
1856 Schema
*pSchema
; /* Schema that contains this table */
1857 Table
*pNextZombie
; /* Next on the Parse.pZombieTab list */
1861 ** Allowed values for Table.tabFlags.
1863 ** TF_OOOHidden applies to tables or view that have hidden columns that are
1864 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
1865 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
1866 ** the TF_OOOHidden attribute would apply in this case. Such tables require
1867 ** special handling during INSERT processing.
1869 #define TF_Readonly 0x01 /* Read-only system table */
1870 #define TF_Ephemeral 0x02 /* An ephemeral table */
1871 #define TF_HasPrimaryKey 0x04 /* Table has a primary key */
1872 #define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
1873 #define TF_Virtual 0x10 /* Is a virtual table */
1874 #define TF_WithoutRowid 0x20 /* No rowid. PRIMARY KEY is the key */
1875 #define TF_NoVisibleRowid 0x40 /* No user-visible "rowid" column */
1876 #define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */
1880 ** Test to see whether or not a table is a virtual table. This is
1881 ** done as a macro so that it will be optimized out when virtual
1882 ** table support is omitted from the build.
1884 #ifndef SQLITE_OMIT_VIRTUALTABLE
1885 # define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
1887 # define IsVirtual(X) 0
1891 ** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn()
1892 ** only works for non-virtual tables (ordinary tables and views) and is
1893 ** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The
1894 ** IsHiddenColumn() macro is general purpose.
1896 #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS)
1897 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1898 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1899 #elif !defined(SQLITE_OMIT_VIRTUALTABLE)
1900 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
1901 # define IsOrdinaryHiddenColumn(X) 0
1903 # define IsHiddenColumn(X) 0
1904 # define IsOrdinaryHiddenColumn(X) 0
1908 /* Does the table have a rowid */
1909 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
1910 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
1913 ** Each foreign key constraint is an instance of the following structure.
1915 ** A foreign key is associated with two tables. The "from" table is
1916 ** the table that contains the REFERENCES clause that creates the foreign
1917 ** key. The "to" table is the table that is named in the REFERENCES clause.
1918 ** Consider this example:
1920 ** CREATE TABLE ex1(
1921 ** a INTEGER PRIMARY KEY,
1922 ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
1925 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
1926 ** Equivalent names:
1928 ** from-table == child-table
1929 ** to-table == parent-table
1931 ** Each REFERENCES clause generates an instance of the following structure
1932 ** which is attached to the from-table. The to-table need not exist when
1933 ** the from-table is created. The existence of the to-table is not checked.
1935 ** The list of all parents for child Table X is held at X.pFKey.
1937 ** A list of all children for a table named Z (which might not even exist)
1938 ** is held in Schema.fkeyHash with a hash key of Z.
1941 Table
*pFrom
; /* Table containing the REFERENCES clause (aka: Child) */
1942 FKey
*pNextFrom
; /* Next FKey with the same in pFrom. Next parent of pFrom */
1943 char *zTo
; /* Name of table that the key points to (aka: Parent) */
1944 FKey
*pNextTo
; /* Next with the same zTo. Next child of zTo. */
1945 FKey
*pPrevTo
; /* Previous with the same zTo */
1946 int nCol
; /* Number of columns in this key */
1947 /* EV: R-30323-21917 */
1948 u8 isDeferred
; /* True if constraint checking is deferred till COMMIT */
1949 u8 aAction
[2]; /* ON DELETE and ON UPDATE actions, respectively */
1950 Trigger
*apTrigger
[2];/* Triggers for aAction[] actions */
1951 struct sColMap
{ /* Mapping of columns in pFrom to columns in zTo */
1952 int iFrom
; /* Index of column in pFrom */
1953 char *zCol
; /* Name of column in zTo. If NULL use PRIMARY KEY */
1954 } aCol
[1]; /* One entry for each of nCol columns */
1958 ** SQLite supports many different ways to resolve a constraint
1959 ** error. ROLLBACK processing means that a constraint violation
1960 ** causes the operation in process to fail and for the current transaction
1961 ** to be rolled back. ABORT processing means the operation in process
1962 ** fails and any prior changes from that one operation are backed out,
1963 ** but the transaction is not rolled back. FAIL processing means that
1964 ** the operation in progress stops and returns an error code. But prior
1965 ** changes due to the same operation are not backed out and no rollback
1966 ** occurs. IGNORE means that the particular row that caused the constraint
1967 ** error is not inserted or updated. Processing continues and no error
1968 ** is returned. REPLACE means that preexisting database rows that caused
1969 ** a UNIQUE constraint violation are removed so that the new insert or
1970 ** update can proceed. Processing continues and no error is reported.
1972 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
1973 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
1974 ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
1975 ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
1976 ** referenced table row is propagated into the row that holds the
1979 ** The following symbolic values are used to record which type
1980 ** of action to take.
1982 #define OE_None 0 /* There is no constraint to check */
1983 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
1984 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
1985 #define OE_Fail 3 /* Stop the operation but leave all prior changes */
1986 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
1987 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
1989 #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
1990 #define OE_SetNull 7 /* Set the foreign key value to NULL */
1991 #define OE_SetDflt 8 /* Set the foreign key value to its default */
1992 #define OE_Cascade 9 /* Cascade the changes */
1994 #define OE_Default 10 /* Do whatever the default action is */
1998 ** An instance of the following structure is passed as the first
1999 ** argument to sqlite3VdbeKeyCompare and is used to control the
2000 ** comparison of the two index keys.
2002 ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
2003 ** are nField slots for the columns of an index then one extra slot
2004 ** for the rowid at the end.
2007 u32 nRef
; /* Number of references to this KeyInfo object */
2008 u8 enc
; /* Text encoding - one of the SQLITE_UTF* values */
2009 u16 nField
; /* Number of key columns in the index */
2010 u16 nXField
; /* Number of columns beyond the key columns */
2011 sqlite3
*db
; /* The database connection */
2012 u8
*aSortOrder
; /* Sort order for each column. */
2013 CollSeq
*aColl
[1]; /* Collating sequence for each term of the key */
2017 ** This object holds a record which has been parsed out into individual
2018 ** fields, for the purposes of doing a comparison.
2020 ** A record is an object that contains one or more fields of data.
2021 ** Records are used to store the content of a table row and to store
2022 ** the key of an index. A blob encoding of a record is created by
2023 ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
2024 ** OP_Column opcode.
2026 ** An instance of this object serves as a "key" for doing a search on
2027 ** an index b+tree. The goal of the search is to find the entry that
2028 ** is closed to the key described by this object. This object might hold
2029 ** just a prefix of the key. The number of fields is given by
2030 ** pKeyInfo->nField.
2032 ** The r1 and r2 fields are the values to return if this key is less than
2033 ** or greater than a key in the btree, respectively. These are normally
2034 ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
2035 ** is in DESC order.
2037 ** The key comparison functions actually return default_rc when they find
2038 ** an equals comparison. default_rc can be -1, 0, or +1. If there are
2039 ** multiple entries in the b-tree with the same key (when only looking
2040 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
2041 ** cause the search to find the last match, or +1 to cause the search to
2042 ** find the first match.
2044 ** The key comparison functions will set eqSeen to true if they ever
2045 ** get and equal results when comparing this structure to a b-tree record.
2046 ** When default_rc!=0, the search might end up on the record immediately
2047 ** before the first match or immediately after the last match. The
2048 ** eqSeen field will indicate whether or not an exact match exists in the
2051 struct UnpackedRecord
{
2052 KeyInfo
*pKeyInfo
; /* Collation and sort-order information */
2053 Mem
*aMem
; /* Values */
2054 u16 nField
; /* Number of entries in apMem[] */
2055 i8 default_rc
; /* Comparison result if keys are equal */
2056 u8 errCode
; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
2057 i8 r1
; /* Value to return if (lhs > rhs) */
2058 i8 r2
; /* Value to return if (rhs < lhs) */
2059 u8 eqSeen
; /* True if an equality comparison has been seen */
2064 ** Each SQL index is represented in memory by an
2065 ** instance of the following structure.
2067 ** The columns of the table that are to be indexed are described
2068 ** by the aiColumn[] field of this structure. For example, suppose
2069 ** we have the following table and index:
2071 ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
2072 ** CREATE INDEX Ex2 ON Ex1(c3,c1);
2074 ** In the Table structure describing Ex1, nCol==3 because there are
2075 ** three columns in the table. In the Index structure describing
2076 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
2077 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
2078 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
2079 ** The second column to be indexed (c1) has an index of 0 in
2080 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
2082 ** The Index.onError field determines whether or not the indexed columns
2083 ** must be unique and what to do if they are not. When Index.onError=OE_None,
2084 ** it means this is not a unique index. Otherwise it is a unique index
2085 ** and the value of Index.onError indicate the which conflict resolution
2086 ** algorithm to employ whenever an attempt is made to insert a non-unique
2089 ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
2090 ** generate VDBE code (as opposed to parsing one read from an sqlite_master
2091 ** table as part of parsing an existing database schema), transient instances
2092 ** of this structure may be created. In this case the Index.tnum variable is
2093 ** used to store the address of a VDBE instruction, not a database page
2094 ** number (it cannot - the database page is not allocated until the VDBE
2095 ** program is executed). See convertToWithoutRowidTable() for details.
2098 char *zName
; /* Name of this index */
2099 i16
*aiColumn
; /* Which columns are used by this index. 1st is 0 */
2100 LogEst
*aiRowLogEst
; /* From ANALYZE: Est. rows selected by each column */
2101 Table
*pTable
; /* The SQL table being indexed */
2102 char *zColAff
; /* String defining the affinity of each column */
2103 Index
*pNext
; /* The next index associated with the same table */
2104 Schema
*pSchema
; /* Schema containing this index */
2105 u8
*aSortOrder
; /* for each column: True==DESC, False==ASC */
2106 const char **azColl
; /* Array of collation sequence names for index */
2107 Expr
*pPartIdxWhere
; /* WHERE clause for partial indices */
2108 ExprList
*aColExpr
; /* Column expressions */
2109 int tnum
; /* DB Page containing root of this index */
2110 LogEst szIdxRow
; /* Estimated average row size in bytes */
2111 u16 nKeyCol
; /* Number of columns forming the key */
2112 u16 nColumn
; /* Number of columns stored in the index */
2113 u8 onError
; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2114 unsigned idxType
:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
2115 unsigned bUnordered
:1; /* Use this index for == or IN queries only */
2116 unsigned uniqNotNull
:1; /* True if UNIQUE and NOT NULL for all columns */
2117 unsigned isResized
:1; /* True if resizeIndexObject() has been called */
2118 unsigned isCovering
:1; /* True if this is a covering index */
2119 unsigned noSkipScan
:1; /* Do not try to use skip-scan if true */
2120 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
2121 int nSample
; /* Number of elements in aSample[] */
2122 int nSampleCol
; /* Size of IndexSample.anEq[] and so on */
2123 tRowcnt
*aAvgEq
; /* Average nEq values for keys not in aSample */
2124 IndexSample
*aSample
; /* Samples of the left-most key */
2125 tRowcnt
*aiRowEst
; /* Non-logarithmic stat1 data for this index */
2126 tRowcnt nRowEst0
; /* Non-logarithmic number of rows in the index */
2131 ** Allowed values for Index.idxType
2133 #define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
2134 #define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */
2135 #define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */
2137 /* Return true if index X is a PRIMARY KEY index */
2138 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
2140 /* Return true if index X is a UNIQUE index */
2141 #define IsUniqueIndex(X) ((X)->onError!=OE_None)
2143 /* The Index.aiColumn[] values are normally positive integer. But
2144 ** there are some negative values that have special meaning:
2146 #define XN_ROWID (-1) /* Indexed column is the rowid */
2147 #define XN_EXPR (-2) /* Indexed column is an expression */
2150 ** Each sample stored in the sqlite_stat3 table is represented in memory
2151 ** using a structure of this type. See documentation at the top of the
2152 ** analyze.c source file for additional information.
2154 struct IndexSample
{
2155 void *p
; /* Pointer to sampled record */
2156 int n
; /* Size of record in bytes */
2157 tRowcnt
*anEq
; /* Est. number of rows where the key equals this sample */
2158 tRowcnt
*anLt
; /* Est. number of rows where key is less than this sample */
2159 tRowcnt
*anDLt
; /* Est. number of distinct keys less than this sample */
2163 ** Each token coming out of the lexer is an instance of
2164 ** this structure. Tokens are also used as part of an expression.
2166 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
2167 ** may contain random values. Do not make any assumptions about Token.dyn
2168 ** and Token.n when Token.z==0.
2171 const char *z
; /* Text of the token. Not NULL-terminated! */
2172 unsigned int n
; /* Number of characters in this token */
2176 ** An instance of this structure contains information needed to generate
2177 ** code for a SELECT that contains aggregate functions.
2179 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
2180 ** pointer to this structure. The Expr.iColumn field is the index in
2181 ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
2182 ** code for that node.
2184 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
2185 ** original Select structure that describes the SELECT statement. These
2186 ** fields do not need to be freed when deallocating the AggInfo structure.
2189 u8 directMode
; /* Direct rendering mode means take data directly
2190 ** from source tables rather than from accumulators */
2191 u8 useSortingIdx
; /* In direct mode, reference the sorting index rather
2192 ** than the source table */
2193 int sortingIdx
; /* Cursor number of the sorting index */
2194 int sortingIdxPTab
; /* Cursor number of pseudo-table */
2195 int nSortingColumn
; /* Number of columns in the sorting index */
2196 int mnReg
, mxReg
; /* Range of registers allocated for aCol and aFunc */
2197 ExprList
*pGroupBy
; /* The group by clause */
2198 struct AggInfo_col
{ /* For each column used in source tables */
2199 Table
*pTab
; /* Source table */
2200 int iTable
; /* Cursor number of the source table */
2201 int iColumn
; /* Column number within the source table */
2202 int iSorterColumn
; /* Column number in the sorting index */
2203 int iMem
; /* Memory location that acts as accumulator */
2204 Expr
*pExpr
; /* The original expression */
2206 int nColumn
; /* Number of used entries in aCol[] */
2207 int nAccumulator
; /* Number of columns that show through to the output.
2208 ** Additional columns are used only as parameters to
2209 ** aggregate functions */
2210 struct AggInfo_func
{ /* For each aggregate function */
2211 Expr
*pExpr
; /* Expression encoding the function */
2212 FuncDef
*pFunc
; /* The aggregate function implementation */
2213 int iMem
; /* Memory location that acts as accumulator */
2214 int iDistinct
; /* Ephemeral table used to enforce DISTINCT */
2216 int nFunc
; /* Number of entries in aFunc[] */
2220 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
2221 ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
2222 ** than 32767 we have to make it 32-bit. 16-bit is preferred because
2223 ** it uses less memory in the Expr object, which is a big memory user
2224 ** in systems with lots of prepared statements. And few applications
2225 ** need more than about 10 or 20 variables. But some extreme users want
2226 ** to have prepared statements with over 32767 variables, and for them
2227 ** the option is available (at compile-time).
2229 #if SQLITE_MAX_VARIABLE_NUMBER<=32767
2236 ** Each node of an expression in the parse tree is an instance
2237 ** of this structure.
2239 ** Expr.op is the opcode. The integer parser token codes are reused
2240 ** as opcodes here. For example, the parser defines TK_GE to be an integer
2241 ** code representing the ">=" operator. This same integer code is reused
2242 ** to represent the greater-than-or-equal-to operator in the expression
2245 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
2246 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
2247 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
2248 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
2249 ** then Expr.token contains the name of the function.
2251 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
2252 ** binary operator. Either or both may be NULL.
2254 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
2255 ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
2256 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
2257 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
2258 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
2261 ** An expression of the form ID or ID.ID refers to a column in a table.
2262 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
2263 ** the integer cursor number of a VDBE cursor pointing to that table and
2264 ** Expr.iColumn is the column number for the specific column. If the
2265 ** expression is used as a result in an aggregate SELECT, then the
2266 ** value is also stored in the Expr.iAgg column in the aggregate so that
2267 ** it can be accessed after all aggregates are computed.
2269 ** If the expression is an unbound variable marker (a question mark
2270 ** character '?' in the original SQL) then the Expr.iTable holds the index
2271 ** number for that variable.
2273 ** If the expression is a subquery then Expr.iColumn holds an integer
2274 ** register number containing the result of the subquery. If the
2275 ** subquery gives a constant result, then iTable is -1. If the subquery
2276 ** gives a different answer at different times during statement processing
2277 ** then iTable is the address of a subroutine that computes the subquery.
2279 ** If the Expr is of type OP_Column, and the table it is selecting from
2280 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
2281 ** corresponding table definition.
2283 ** ALLOCATION NOTES:
2285 ** Expr objects can use a lot of memory space in database schema. To
2286 ** help reduce memory requirements, sometimes an Expr object will be
2287 ** truncated. And to reduce the number of memory allocations, sometimes
2288 ** two or more Expr objects will be stored in a single memory allocation,
2289 ** together with Expr.zToken strings.
2291 ** If the EP_Reduced and EP_TokenOnly flags are set when
2292 ** an Expr object is truncated. When EP_Reduced is set, then all
2293 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
2294 ** are contained within the same memory allocation. Note, however, that
2295 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
2296 ** allocated, regardless of whether or not EP_Reduced is set.
2299 u8 op
; /* Operation performed by this node */
2300 char affinity
; /* The affinity of the column or 0 if not a column */
2301 u32 flags
; /* Various flags. EP_* See below */
2303 char *zToken
; /* Token value. Zero terminated and dequoted */
2304 int iValue
; /* Non-negative integer value if EP_IntValue */
2307 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
2308 ** space is allocated for the fields below this point. An attempt to
2309 ** access them will result in a segfault or malfunction.
2310 *********************************************************************/
2312 Expr
*pLeft
; /* Left subnode */
2313 Expr
*pRight
; /* Right subnode */
2315 ExprList
*pList
; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
2316 Select
*pSelect
; /* EP_xIsSelect and op = IN, EXISTS, SELECT */
2319 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
2320 ** space is allocated for the fields below this point. An attempt to
2321 ** access them will result in a segfault or malfunction.
2322 *********************************************************************/
2324 #if SQLITE_MAX_EXPR_DEPTH>0
2325 int nHeight
; /* Height of the tree headed by this node */
2327 int iTable
; /* TK_COLUMN: cursor number of table holding column
2328 ** TK_REGISTER: register number
2329 ** TK_TRIGGER: 1 -> new, 0 -> old
2330 ** EP_Unlikely: 134217728 times likelihood
2331 ** TK_SELECT: 1st register of result vector */
2332 ynVar iColumn
; /* TK_COLUMN: column index. -1 for rowid.
2333 ** TK_VARIABLE: variable number (always >= 1).
2334 ** TK_SELECT_COLUMN: column of the result vector */
2335 i16 iAgg
; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
2336 i16 iRightJoinTable
; /* If EP_FromJoin, the right table of the join */
2337 u8 op2
; /* TK_REGISTER: original value of Expr.op
2338 ** TK_COLUMN: the value of p5 for OP_Column
2339 ** TK_AGG_FUNCTION: nesting depth */
2340 AggInfo
*pAggInfo
; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
2341 Table
*pTab
; /* Table for TK_COLUMN expressions. */
2345 ** The following are the meanings of bits in the Expr.flags field.
2347 #define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */
2348 #define EP_Agg 0x000002 /* Contains one or more aggregate functions */
2349 #define EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */
2350 #define EP_Error 0x000008 /* Expression contains one or more errors */
2351 #define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */
2352 #define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */
2353 #define EP_DblQuoted 0x000040 /* token.z was originally in "..." */
2354 #define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */
2355 #define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */
2356 #define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */
2357 #define EP_IntValue 0x000400 /* Integer value contained in u.iValue */
2358 #define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */
2359 #define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */
2360 #define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
2361 #define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
2362 #define EP_Static 0x008000 /* Held in memory not obtained from malloc() */
2363 #define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */
2364 #define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
2365 #define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */
2366 #define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
2367 #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
2368 #define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
2369 #define EP_Alias 0x400000 /* Is an alias for a result set column */
2370 #define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
2373 ** Combinations of two or more EP_* flags
2375 #define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */
2378 ** These macros can be used to test, set, or clear bits in the
2379 ** Expr.flags field.
2381 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
2382 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
2383 #define ExprSetProperty(E,P) (E)->flags|=(P)
2384 #define ExprClearProperty(E,P) (E)->flags&=~(P)
2386 /* The ExprSetVVAProperty() macro is used for Verification, Validation,
2387 ** and Accreditation only. It works like ExprSetProperty() during VVA
2388 ** processes but is a no-op for delivery.
2391 # define ExprSetVVAProperty(E,P) (E)->flags|=(P)
2393 # define ExprSetVVAProperty(E,P)
2397 ** Macros to determine the number of bytes required by a normal Expr
2398 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
2399 ** and an Expr struct with the EP_TokenOnly flag set.
2401 #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
2402 #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
2403 #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
2406 ** Flags passed to the sqlite3ExprDup() function. See the header comment
2407 ** above sqlite3ExprDup() for details.
2409 #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
2412 ** A list of expressions. Each expression may optionally have a
2413 ** name. An expr/name combination can be used in several ways, such
2414 ** as the list of "expr AS ID" fields following a "SELECT" or in the
2415 ** list of "ID = expr" items in an UPDATE. A list of expressions can
2416 ** also be used as the argument to a function, in which case the a.zName
2417 ** field is not used.
2419 ** By default the Expr.zSpan field holds a human-readable description of
2420 ** the expression that is used in the generation of error messages and
2421 ** column labels. In this case, Expr.zSpan is typically the text of a
2422 ** column expression as it exists in a SELECT statement. However, if
2423 ** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
2424 ** of the result column in the form: DATABASE.TABLE.COLUMN. This later
2425 ** form is used for name resolution with nested FROM clauses.
2428 int nExpr
; /* Number of expressions on the list */
2429 struct ExprList_item
{ /* For each expression in the list */
2430 Expr
*pExpr
; /* The list of expressions */
2431 char *zName
; /* Token associated with this expression */
2432 char *zSpan
; /* Original text of the expression */
2433 u8 sortOrder
; /* 1 for DESC or 0 for ASC */
2434 unsigned done
:1; /* A flag to indicate when processing is finished */
2435 unsigned bSpanIsTab
:1; /* zSpan holds DB.TABLE.COLUMN */
2436 unsigned reusable
:1; /* Constant expression is reusable */
2439 u16 iOrderByCol
; /* For ORDER BY, column number in result set */
2440 u16 iAlias
; /* Index into Parse.aAlias[] for zName */
2442 int iConstExprReg
; /* Register in which Expr value is cached */
2444 } *a
; /* Alloc a power of two greater or equal to nExpr */
2448 ** An instance of this structure is used by the parser to record both
2449 ** the parse tree for an expression and the span of input text for an
2453 Expr
*pExpr
; /* The expression parse tree */
2454 const char *zStart
; /* First character of input text */
2455 const char *zEnd
; /* One character past the end of input text */
2459 ** An instance of this structure can hold a simple list of identifiers,
2460 ** such as the list "a,b,c" in the following statements:
2462 ** INSERT INTO t(a,b,c) VALUES ...;
2463 ** CREATE INDEX idx ON t(a,b,c);
2464 ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
2466 ** The IdList.a.idx field is used when the IdList represents the list of
2467 ** column names after a table name in an INSERT statement. In the statement
2469 ** INSERT INTO t(a,b,c) ...
2471 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
2474 struct IdList_item
{
2475 char *zName
; /* Name of the identifier */
2476 int idx
; /* Index in some Table.aCol[] of a column named zName */
2478 int nId
; /* Number of identifiers on the list */
2482 ** The bitmask datatype defined below is used for various optimizations.
2484 ** Changing this from a 64-bit to a 32-bit type limits the number of
2485 ** tables in a join to 32 instead of 64. But it also reduces the size
2486 ** of the library by 738 bytes on ix86.
2488 #ifdef SQLITE_BITMASK_TYPE
2489 typedef SQLITE_BITMASK_TYPE Bitmask
;
2491 typedef u64 Bitmask
;
2495 ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
2497 #define BMS ((int)(sizeof(Bitmask)*8))
2500 ** A bit in a Bitmask
2502 #define MASKBIT(n) (((Bitmask)1)<<(n))
2503 #define MASKBIT32(n) (((unsigned int)1)<<(n))
2504 #define ALLBITS ((Bitmask)-1)
2507 ** The following structure describes the FROM clause of a SELECT statement.
2508 ** Each table or subquery in the FROM clause is a separate element of
2509 ** the SrcList.a[] array.
2511 ** With the addition of multiple database support, the following structure
2512 ** can also be used to describe a particular table such as the table that
2513 ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
2514 ** such a table must be a simple name: ID. But in SQLite, the table can
2515 ** now be identified by a database name, a dot, then the table name: ID.ID.
2517 ** The jointype starts out showing the join type between the current table
2518 ** and the next table on the list. The parser builds the list this way.
2519 ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
2520 ** jointype expresses the join between the table and the previous table.
2522 ** In the colUsed field, the high-order bit (bit 63) is set if the table
2523 ** contains more than 63 columns and the 64-th or later column is used.
2526 int nSrc
; /* Number of tables or subqueries in the FROM clause */
2527 u32 nAlloc
; /* Number of entries allocated in a[] below */
2528 struct SrcList_item
{
2529 Schema
*pSchema
; /* Schema to which this item is fixed */
2530 char *zDatabase
; /* Name of database holding this table */
2531 char *zName
; /* Name of the table */
2532 char *zAlias
; /* The "B" part of a "A AS B" phrase. zName is the "A" */
2533 Table
*pTab
; /* An SQL table corresponding to zName */
2534 Select
*pSelect
; /* A SELECT statement used in place of a table name */
2535 int addrFillSub
; /* Address of subroutine to manifest a subquery */
2536 int regReturn
; /* Register holding return address of addrFillSub */
2537 int regResult
; /* Registers holding results of a co-routine */
2539 u8 jointype
; /* Type of join between this table and the previous */
2540 unsigned notIndexed
:1; /* True if there is a NOT INDEXED clause */
2541 unsigned isIndexedBy
:1; /* True if there is an INDEXED BY clause */
2542 unsigned isTabFunc
:1; /* True if table-valued-function syntax */
2543 unsigned isCorrelated
:1; /* True if sub-query is correlated */
2544 unsigned viaCoroutine
:1; /* Implemented as a co-routine */
2545 unsigned isRecursive
:1; /* True for recursive reference in WITH */
2547 #ifndef SQLITE_OMIT_EXPLAIN
2548 u8 iSelectId
; /* If pSelect!=0, the id of the sub-select in EQP */
2550 int iCursor
; /* The VDBE cursor number used to access this table */
2551 Expr
*pOn
; /* The ON clause of a join */
2552 IdList
*pUsing
; /* The USING clause of a join */
2553 Bitmask colUsed
; /* Bit N (1<<N) set if column N of pTab is used */
2555 char *zIndexedBy
; /* Identifier from "INDEXED BY <zIndex>" clause */
2556 ExprList
*pFuncArg
; /* Arguments to table-valued-function */
2558 Index
*pIBIndex
; /* Index structure corresponding to u1.zIndexedBy */
2559 } a
[1]; /* One entry for each identifier on the list */
2563 ** Permitted values of the SrcList.a.jointype field
2565 #define JT_INNER 0x0001 /* Any kind of inner or cross join */
2566 #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
2567 #define JT_NATURAL 0x0004 /* True for a "natural" join */
2568 #define JT_LEFT 0x0008 /* Left outer join */
2569 #define JT_RIGHT 0x0010 /* Right outer join */
2570 #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
2571 #define JT_ERROR 0x0040 /* unknown or unsupported join type */
2575 ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
2576 ** and the WhereInfo.wctrlFlags member.
2578 ** Value constraints (enforced via assert()):
2579 ** WHERE_USE_LIMIT == SF_FixedLimit
2581 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
2582 #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
2583 #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
2584 #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
2585 #define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
2586 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
2587 #define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
2588 ** the OR optimization */
2589 #define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */
2590 #define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */
2591 #define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */
2592 #define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
2593 #define WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */
2594 #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
2595 #define WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */
2596 /* 0x2000 not currently used */
2597 #define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
2598 /* 0x8000 not currently used */
2600 /* Allowed return values from sqlite3WhereIsDistinct()
2602 #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
2603 #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */
2604 #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */
2605 #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */
2608 ** A NameContext defines a context in which to resolve table and column
2609 ** names. The context consists of a list of tables (the pSrcList) field and
2610 ** a list of named expression (pEList). The named expression list may
2611 ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
2612 ** to the table being operated on by INSERT, UPDATE, or DELETE. The
2613 ** pEList corresponds to the result set of a SELECT and is NULL for
2614 ** other statements.
2616 ** NameContexts can be nested. When resolving names, the inner-most
2617 ** context is searched first. If no match is found, the next outer
2618 ** context is checked. If there is still no match, the next context
2619 ** is checked. This process continues until either a match is found
2620 ** or all contexts are check. When a match is found, the nRef member of
2621 ** the context containing the match is incremented.
2623 ** Each subquery gets a new NameContext. The pNext field points to the
2624 ** NameContext in the parent query. Thus the process of scanning the
2625 ** NameContext list corresponds to searching through successively outer
2626 ** subqueries looking for a match.
2628 struct NameContext
{
2629 Parse
*pParse
; /* The parser */
2630 SrcList
*pSrcList
; /* One or more tables used to resolve names */
2631 ExprList
*pEList
; /* Optional list of result-set columns */
2632 AggInfo
*pAggInfo
; /* Information about aggregates at this level */
2633 NameContext
*pNext
; /* Next outer name context. NULL for outermost */
2634 int nRef
; /* Number of names resolved by this context */
2635 int nErr
; /* Number of errors encountered while resolving names */
2636 u16 ncFlags
; /* Zero or more NC_* flags defined below */
2640 ** Allowed values for the NameContext, ncFlags field.
2642 ** Value constraints (all checked via assert()):
2643 ** NC_HasAgg == SF_HasAgg
2644 ** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
2647 #define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */
2648 #define NC_PartIdx 0x0002 /* True if resolving a partial index WHERE */
2649 #define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */
2650 #define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */
2651 #define NC_HasAgg 0x0010 /* One or more aggregate functions seen */
2652 #define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */
2653 #define NC_VarSelect 0x0040 /* A correlated subquery has been seen */
2654 #define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */
2657 ** An instance of the following structure contains all information
2658 ** needed to generate code for a single SELECT statement.
2660 ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
2661 ** If there is a LIMIT clause, the parser sets nLimit to the value of the
2662 ** limit and nOffset to the value of the offset (or 0 if there is not
2663 ** offset). But later on, nLimit and nOffset become the memory locations
2664 ** in the VDBE that record the limit and offset counters.
2666 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
2667 ** These addresses must be stored so that we can go back and fill in
2668 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
2669 ** the number of columns in P2 can be computed at the same time
2670 ** as the OP_OpenEphm instruction is coded because not
2671 ** enough information about the compound query is known at that point.
2672 ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
2673 ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
2674 ** sequences for the ORDER BY clause.
2677 ExprList
*pEList
; /* The fields of the result */
2678 u8 op
; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
2679 LogEst nSelectRow
; /* Estimated number of result rows */
2680 u32 selFlags
; /* Various SF_* values */
2681 int iLimit
, iOffset
; /* Memory registers holding LIMIT & OFFSET counters */
2682 #if SELECTTRACE_ENABLED
2683 char zSelName
[12]; /* Symbolic name of this SELECT use for debugging */
2685 int addrOpenEphm
[2]; /* OP_OpenEphem opcodes related to this select */
2686 SrcList
*pSrc
; /* The FROM clause */
2687 Expr
*pWhere
; /* The WHERE clause */
2688 ExprList
*pGroupBy
; /* The GROUP BY clause */
2689 Expr
*pHaving
; /* The HAVING clause */
2690 ExprList
*pOrderBy
; /* The ORDER BY clause */
2691 Select
*pPrior
; /* Prior select in a compound select statement */
2692 Select
*pNext
; /* Next select to the left in a compound */
2693 Expr
*pLimit
; /* LIMIT expression. NULL means not used. */
2694 Expr
*pOffset
; /* OFFSET expression. NULL means not used. */
2695 With
*pWith
; /* WITH clause attached to this select. Or NULL. */
2699 ** Allowed values for Select.selFlags. The "SF" prefix stands for
2702 ** Value constraints (all checked via assert())
2703 ** SF_HasAgg == NC_HasAgg
2704 ** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX
2705 ** SF_FixedLimit == WHERE_USE_LIMIT
2707 #define SF_Distinct 0x00001 /* Output should be DISTINCT */
2708 #define SF_All 0x00002 /* Includes the ALL keyword */
2709 #define SF_Resolved 0x00004 /* Identifiers have been resolved */
2710 #define SF_Aggregate 0x00008 /* Contains agg functions or a GROUP BY */
2711 #define SF_HasAgg 0x00010 /* Contains aggregate functions */
2712 #define SF_UsesEphemeral 0x00020 /* Uses the OpenEphemeral opcode */
2713 #define SF_Expanded 0x00040 /* sqlite3SelectExpand() called on this */
2714 #define SF_HasTypeInfo 0x00080 /* FROM subqueries have Table metadata */
2715 #define SF_Compound 0x00100 /* Part of a compound query */
2716 #define SF_Values 0x00200 /* Synthesized from VALUES clause */
2717 #define SF_MultiValue 0x00400 /* Single VALUES term with multiple rows */
2718 #define SF_NestedFrom 0x00800 /* Part of a parenthesized FROM clause */
2719 #define SF_MinMaxAgg 0x01000 /* Aggregate containing min() or max() */
2720 #define SF_Recursive 0x02000 /* The recursive part of a recursive CTE */
2721 #define SF_FixedLimit 0x04000 /* nSelectRow set by a constant LIMIT */
2722 #define SF_MaybeConvert 0x08000 /* Need convertCompoundSelectToSubquery() */
2723 #define SF_Converted 0x10000 /* By convertCompoundSelectToSubquery() */
2724 #define SF_IncludeHidden 0x20000 /* Include hidden columns in output */
2728 ** The results of a SELECT can be distributed in several ways, as defined
2729 ** by one of the following macros. The "SRT" prefix means "SELECT Result
2732 ** SRT_Union Store results as a key in a temporary index
2733 ** identified by pDest->iSDParm.
2735 ** SRT_Except Remove results from the temporary index pDest->iSDParm.
2737 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
2738 ** set is not empty.
2740 ** SRT_Discard Throw the results away. This is used by SELECT
2741 ** statements within triggers whose only purpose is
2742 ** the side-effects of functions.
2744 ** All of the above are free to ignore their ORDER BY clause. Those that
2745 ** follow must honor the ORDER BY clause.
2747 ** SRT_Output Generate a row of output (using the OP_ResultRow
2748 ** opcode) for each row in the result set.
2750 ** SRT_Mem Only valid if the result is a single column.
2751 ** Store the first column of the first result row
2752 ** in register pDest->iSDParm then abandon the rest
2753 ** of the query. This destination implies "LIMIT 1".
2755 ** SRT_Set The result must be a single column. Store each
2756 ** row of result as the key in table pDest->iSDParm.
2757 ** Apply the affinity pDest->affSdst before storing
2758 ** results. Used to implement "IN (SELECT ...)".
2760 ** SRT_EphemTab Create an temporary table pDest->iSDParm and store
2761 ** the result there. The cursor is left open after
2762 ** returning. This is like SRT_Table except that
2763 ** this destination uses OP_OpenEphemeral to create
2766 ** SRT_Coroutine Generate a co-routine that returns a new row of
2767 ** results each time it is invoked. The entry point
2768 ** of the co-routine is stored in register pDest->iSDParm
2769 ** and the result row is stored in pDest->nDest registers
2770 ** starting with pDest->iSdst.
2772 ** SRT_Table Store results in temporary table pDest->iSDParm.
2773 ** SRT_Fifo This is like SRT_EphemTab except that the table
2774 ** is assumed to already be open. SRT_Fifo has
2775 ** the additional property of being able to ignore
2776 ** the ORDER BY clause.
2778 ** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
2779 ** But also use temporary table pDest->iSDParm+1 as
2780 ** a record of all prior results and ignore any duplicate
2781 ** rows. Name means: "Distinct Fifo".
2783 ** SRT_Queue Store results in priority queue pDest->iSDParm (really
2784 ** an index). Append a sequence number so that all entries
2787 ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
2788 ** the same record has never been stored before. The
2789 ** index at pDest->iSDParm+1 hold all prior stores.
2791 #define SRT_Union 1 /* Store result as keys in an index */
2792 #define SRT_Except 2 /* Remove result from a UNION index */
2793 #define SRT_Exists 3 /* Store 1 if the result is not empty */
2794 #define SRT_Discard 4 /* Do not save the results anywhere */
2795 #define SRT_Fifo 5 /* Store result as data with an automatic rowid */
2796 #define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */
2797 #define SRT_Queue 7 /* Store result in an queue */
2798 #define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */
2800 /* The ORDER BY clause is ignored for all of the above */
2801 #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)
2803 #define SRT_Output 9 /* Output each row of result */
2804 #define SRT_Mem 10 /* Store result in a memory cell */
2805 #define SRT_Set 11 /* Store results as keys in an index */
2806 #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */
2807 #define SRT_Coroutine 13 /* Generate a single row of result */
2808 #define SRT_Table 14 /* Store result as data with an automatic rowid */
2811 ** An instance of this object describes where to put of the results of
2812 ** a SELECT statement.
2815 u8 eDest
; /* How to dispose of the results. On of SRT_* above. */
2816 char *zAffSdst
; /* Affinity used when eDest==SRT_Set */
2817 int iSDParm
; /* A parameter used by the eDest disposal method */
2818 int iSdst
; /* Base register where results are written */
2819 int nSdst
; /* Number of registers allocated */
2820 ExprList
*pOrderBy
; /* Key columns for SRT_Queue and SRT_DistQueue */
2824 ** During code generation of statements that do inserts into AUTOINCREMENT
2825 ** tables, the following information is attached to the Table.u.autoInc.p
2826 ** pointer of each autoincrement table to record some side information that
2827 ** the code generator needs. We have to keep per-table autoincrement
2828 ** information in case inserts are done within triggers. Triggers do not
2829 ** normally coordinate their activities, but we do need to coordinate the
2830 ** loading and saving of autoincrement information.
2832 struct AutoincInfo
{
2833 AutoincInfo
*pNext
; /* Next info block in a list of them all */
2834 Table
*pTab
; /* Table this info block refers to */
2835 int iDb
; /* Index in sqlite3.aDb[] of database holding pTab */
2836 int regCtr
; /* Memory register holding the rowid counter */
2840 ** Size of the column cache
2842 #ifndef SQLITE_N_COLCACHE
2843 # define SQLITE_N_COLCACHE 10
2847 ** At least one instance of the following structure is created for each
2848 ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
2849 ** statement. All such objects are stored in the linked list headed at
2850 ** Parse.pTriggerPrg and deleted once statement compilation has been
2853 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
2854 ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
2855 ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
2856 ** The Parse.pTriggerPrg list never contains two entries with the same
2857 ** values for both pTrigger and orconf.
2859 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
2860 ** accessed (or set to 0 for triggers fired as a result of INSERT
2861 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
2862 ** a mask of new.* columns used by the program.
2865 Trigger
*pTrigger
; /* Trigger this program was coded from */
2866 TriggerPrg
*pNext
; /* Next entry in Parse.pTriggerPrg list */
2867 SubProgram
*pProgram
; /* Program implementing pTrigger/orconf */
2868 int orconf
; /* Default ON CONFLICT policy */
2869 u32 aColmask
[2]; /* Masks of old.*, new.* columns accessed */
2873 ** The yDbMask datatype for the bitmask of all attached databases.
2875 #if SQLITE_MAX_ATTACHED>30
2876 typedef unsigned char yDbMask
[(SQLITE_MAX_ATTACHED
+9)/8];
2877 # define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0)
2878 # define DbMaskZero(M) memset((M),0,sizeof(M))
2879 # define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7))
2880 # define DbMaskAllZero(M) sqlite3DbMaskAllZero(M)
2881 # define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0)
2883 typedef unsigned int yDbMask
;
2884 # define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0)
2885 # define DbMaskZero(M) (M)=0
2886 # define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I))
2887 # define DbMaskAllZero(M) (M)==0
2888 # define DbMaskNonZero(M) (M)!=0
2892 ** An SQL parser context. A copy of this structure is passed through
2893 ** the parser and down into all the parser action routine in order to
2894 ** carry around information that is global to the entire parse.
2896 ** The structure is divided into two parts. When the parser and code
2897 ** generate call themselves recursively, the first part of the structure
2898 ** is constant but the second part is reset at the beginning and end of
2901 ** The nTableLock and aTableLock variables are only used if the shared-cache
2902 ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
2903 ** used to store the set of table-locks required by the statement being
2904 ** compiled. Function sqlite3TableLock() is used to add entries to the
2908 sqlite3
*db
; /* The main database structure */
2909 char *zErrMsg
; /* An error message */
2910 Vdbe
*pVdbe
; /* An engine for executing database bytecode */
2911 int rc
; /* Return code from execution */
2912 u8 colNamesSet
; /* TRUE after OP_ColumnName has been issued to pVdbe */
2913 u8 checkSchema
; /* Causes schema cookie check after an error */
2914 u8 nested
; /* Number of nested calls to the parser/code generator */
2915 u8 nTempReg
; /* Number of temporary registers in aTempReg[] */
2916 u8 isMultiWrite
; /* True if statement may modify/insert multiple rows */
2917 u8 mayAbort
; /* True if statement may throw an ABORT exception */
2918 u8 hasCompound
; /* Need to invoke convertCompoundSelectToSubquery() */
2919 u8 okConstFactor
; /* OK to factor out constants */
2920 u8 disableLookaside
; /* Number of times lookaside has been disabled */
2921 u8 nColCache
; /* Number of entries in aColCache[] */
2922 int nRangeReg
; /* Size of the temporary register block */
2923 int iRangeReg
; /* First register in temporary register block */
2924 int nErr
; /* Number of errors seen */
2925 int nTab
; /* Number of previously allocated VDBE cursors */
2926 int nMem
; /* Number of memory cells used so far */
2927 int nOpAlloc
; /* Number of slots allocated for Vdbe.aOp[] */
2928 int szOpAlloc
; /* Bytes of memory space allocated for Vdbe.aOp[] */
2929 int ckBase
; /* Base register of data during check constraints */
2930 int iSelfTab
; /* Table of an index whose exprs are being coded */
2931 int iCacheLevel
; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
2932 int iCacheCnt
; /* Counter used to generate aColCache[].lru values */
2933 int nLabel
; /* Number of labels used */
2934 int *aLabel
; /* Space to hold the labels */
2935 ExprList
*pConstExpr
;/* Constant expressions */
2936 Token constraintName
;/* Name of the constraint currently being parsed */
2937 yDbMask writeMask
; /* Start a write transaction on these databases */
2938 yDbMask cookieMask
; /* Bitmask of schema verified databases */
2939 int regRowid
; /* Register holding rowid of CREATE TABLE entry */
2940 int regRoot
; /* Register holding root page number for new objects */
2941 int nMaxArg
; /* Max args passed to user function by sub-program */
2942 #if SELECTTRACE_ENABLED
2943 int nSelect
; /* Number of SELECT statements seen */
2944 int nSelectIndent
; /* How far to indent SELECTTRACE() output */
2946 #ifndef SQLITE_OMIT_SHARED_CACHE
2947 int nTableLock
; /* Number of locks in aTableLock */
2948 TableLock
*aTableLock
; /* Required table locks for shared-cache mode */
2950 AutoincInfo
*pAinc
; /* Information about AUTOINCREMENT counters */
2951 Parse
*pToplevel
; /* Parse structure for main program (or NULL) */
2952 Table
*pTriggerTab
; /* Table triggers are being coded for */
2953 int addrCrTab
; /* Address of OP_CreateTable opcode on CREATE TABLE */
2954 u32 nQueryLoop
; /* Est number of iterations of a query (10*log2(N)) */
2955 u32 oldmask
; /* Mask of old.* columns referenced */
2956 u32 newmask
; /* Mask of new.* columns referenced */
2957 u8 eTriggerOp
; /* TK_UPDATE, TK_INSERT or TK_DELETE */
2958 u8 eOrconf
; /* Default ON CONFLICT policy for trigger steps */
2959 u8 disableTriggers
; /* True to disable triggers */
2961 /**************************************************************************
2962 ** Fields above must be initialized to zero. The fields that follow,
2963 ** down to the beginning of the recursive section, do not need to be
2964 ** initialized as they will be set before being used. The boundary is
2965 ** determined by offsetof(Parse,aColCache).
2966 **************************************************************************/
2969 int iTable
; /* Table cursor number */
2970 i16 iColumn
; /* Table column number */
2971 u8 tempReg
; /* iReg is a temp register that needs to be freed */
2972 int iLevel
; /* Nesting level */
2973 int iReg
; /* Reg with value of this column. 0 means none. */
2974 int lru
; /* Least recently used entry has the smallest value */
2975 } aColCache
[SQLITE_N_COLCACHE
]; /* One for each column cache entry */
2976 int aTempReg
[8]; /* Holding area for temporary registers */
2977 Token sNameToken
; /* Token with unqualified schema object name */
2979 /************************************************************************
2980 ** Above is constant between recursions. Below is reset before and after
2981 ** each recursion. The boundary between these two regions is determined
2982 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
2983 ** first field in the recursive region.
2984 ************************************************************************/
2986 Token sLastToken
; /* The last token parsed */
2987 ynVar nVar
; /* Number of '?' variables seen in the SQL so far */
2988 u8 iPkSortOrder
; /* ASC or DESC for INTEGER PRIMARY KEY */
2989 u8 explain
; /* True if the EXPLAIN flag is found on the query */
2990 #ifndef SQLITE_OMIT_VIRTUALTABLE
2991 u8 declareVtab
; /* True if inside sqlite3_declare_vtab() */
2992 int nVtabLock
; /* Number of virtual tables to lock */
2994 int nHeight
; /* Expression tree height of current sub-select */
2995 #ifndef SQLITE_OMIT_EXPLAIN
2996 int iSelectId
; /* ID of current select for EXPLAIN output */
2997 int iNextSelectId
; /* Next available select ID for EXPLAIN output */
2999 VList
*pVList
; /* Mapping between variable names and numbers */
3000 Vdbe
*pReprepare
; /* VM being reprepared (sqlite3Reprepare()) */
3001 const char *zTail
; /* All SQL text past the last semicolon parsed */
3002 Table
*pNewTable
; /* A table being constructed by CREATE TABLE */
3003 Trigger
*pNewTrigger
; /* Trigger under construct by a CREATE TRIGGER */
3004 const char *zAuthContext
; /* The 6th parameter to db->xAuth callbacks */
3005 #ifndef SQLITE_OMIT_VIRTUALTABLE
3006 Token sArg
; /* Complete text of a module argument */
3007 Table
**apVtabLock
; /* Pointer to virtual tables needing locking */
3009 Table
*pZombieTab
; /* List of Table objects to delete after code gen */
3010 TriggerPrg
*pTriggerPrg
; /* Linked list of coded triggers */
3011 With
*pWith
; /* Current WITH clause, or NULL */
3012 With
*pWithToFree
; /* Free this WITH object at the end of the parse */
3016 ** Sizes and pointers of various parts of the Parse object.
3018 #define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
3019 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
3020 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
3021 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
3024 ** Return true if currently inside an sqlite3_declare_vtab() call.
3026 #ifdef SQLITE_OMIT_VIRTUALTABLE
3027 #define IN_DECLARE_VTAB 0
3029 #define IN_DECLARE_VTAB (pParse->declareVtab)
3033 ** An instance of the following structure can be declared on a stack and used
3034 ** to save the Parse.zAuthContext value so that it can be restored later.
3036 struct AuthContext
{
3037 const char *zAuthContext
; /* Put saved Parse.zAuthContext here */
3038 Parse
*pParse
; /* The Parse structure */
3042 ** Bitfield flags for P5 value in various opcodes.
3044 ** Value constraints (enforced via assert()):
3045 ** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH
3046 ** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF
3047 ** OPFLAG_BULKCSR == BTREE_BULKLOAD
3048 ** OPFLAG_SEEKEQ == BTREE_SEEK_EQ
3049 ** OPFLAG_FORDELETE == BTREE_FORDELETE
3050 ** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
3051 ** OPFLAG_AUXDELETE == BTREE_AUXDELETE
3053 #define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
3054 /* Also used in P2 (not P5) of OP_Delete */
3055 #define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
3056 #define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
3057 #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
3058 #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
3059 #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
3060 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
3061 #define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
3063 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
3064 #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
3065 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
3066 #define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
3067 #define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
3068 #define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
3069 #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
3070 #define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */
3071 #define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */
3074 * Each trigger present in the database schema is stored as an instance of
3077 * Pointers to instances of struct Trigger are stored in two ways.
3078 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
3079 * database). This allows Trigger structures to be retrieved by name.
3080 * 2. All triggers associated with a single table form a linked list, using the
3081 * pNext member of struct Trigger. A pointer to the first element of the
3082 * linked list is stored as the "pTrigger" member of the associated
3085 * The "step_list" member points to the first element of a linked list
3086 * containing the SQL statements specified as the trigger program.
3089 char *zName
; /* The name of the trigger */
3090 char *table
; /* The table or view to which the trigger applies */
3091 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
3092 u8 tr_tm
; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
3093 Expr
*pWhen
; /* The WHEN clause of the expression (may be NULL) */
3094 IdList
*pColumns
; /* If this is an UPDATE OF <column-list> trigger,
3095 the <column-list> is stored here */
3096 Schema
*pSchema
; /* Schema containing the trigger */
3097 Schema
*pTabSchema
; /* Schema containing the table */
3098 TriggerStep
*step_list
; /* Link list of trigger program steps */
3099 Trigger
*pNext
; /* Next trigger associated with the table */
3103 ** A trigger is either a BEFORE or an AFTER trigger. The following constants
3106 ** If there are multiple triggers, you might of some BEFORE and some AFTER.
3107 ** In that cases, the constants below can be ORed together.
3109 #define TRIGGER_BEFORE 1
3110 #define TRIGGER_AFTER 2
3113 * An instance of struct TriggerStep is used to store a single SQL statement
3114 * that is a part of a trigger-program.
3116 * Instances of struct TriggerStep are stored in a singly linked list (linked
3117 * using the "pNext" member) referenced by the "step_list" member of the
3118 * associated struct Trigger instance. The first element of the linked list is
3119 * the first step of the trigger-program.
3121 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
3122 * "SELECT" statement. The meanings of the other members is determined by the
3123 * value of "op" as follows:
3126 * orconf -> stores the ON CONFLICT algorithm
3127 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
3128 * this stores a pointer to the SELECT statement. Otherwise NULL.
3129 * zTarget -> Dequoted name of the table to insert into.
3130 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
3131 * this stores values to be inserted. Otherwise NULL.
3132 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
3133 * statement, then this stores the column-names to be
3137 * zTarget -> Dequoted name of the table to delete from.
3138 * pWhere -> The WHERE clause of the DELETE statement if one is specified.
3142 * zTarget -> Dequoted name of the table to update.
3143 * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
3145 * pExprList -> A list of the columns to update and the expressions to update
3146 * them to. See sqlite3Update() documentation of "pChanges"
3150 struct TriggerStep
{
3151 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
3152 u8 orconf
; /* OE_Rollback etc. */
3153 Trigger
*pTrig
; /* The trigger that this step is a part of */
3154 Select
*pSelect
; /* SELECT statement or RHS of INSERT INTO SELECT ... */
3155 char *zTarget
; /* Target table for DELETE, UPDATE, INSERT */
3156 Expr
*pWhere
; /* The WHERE clause for DELETE or UPDATE steps */
3157 ExprList
*pExprList
; /* SET clause for UPDATE. */
3158 IdList
*pIdList
; /* Column names for INSERT */
3159 TriggerStep
*pNext
; /* Next in the link-list */
3160 TriggerStep
*pLast
; /* Last element in link-list. Valid for 1st elem only */
3164 ** The following structure contains information used by the sqliteFix...
3165 ** routines as they walk the parse tree to make database references
3168 typedef struct DbFixer DbFixer
;
3170 Parse
*pParse
; /* The parsing context. Error messages written here */
3171 Schema
*pSchema
; /* Fix items to this schema */
3172 int bVarOnly
; /* Check for variable references only */
3173 const char *zDb
; /* Make sure all objects are contained in this database */
3174 const char *zType
; /* Type of the container - used for error messages */
3175 const Token
*pName
; /* Name of the container - used for error messages */
3179 ** An objected used to accumulate the text of a string where we
3180 ** do not necessarily know how big the string will be in the end.
3183 sqlite3
*db
; /* Optional database for lookaside. Can be NULL */
3184 char *zBase
; /* A base allocation. Not from malloc. */
3185 char *zText
; /* The string collected so far */
3186 u32 nChar
; /* Length of the string so far */
3187 u32 nAlloc
; /* Amount of space allocated in zText */
3188 u32 mxAlloc
; /* Maximum allowed allocation. 0 for no malloc usage */
3189 u8 accError
; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
3190 u8 printfFlags
; /* SQLITE_PRINTF flags below */
3192 #define STRACCUM_NOMEM 1
3193 #define STRACCUM_TOOBIG 2
3194 #define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
3195 #define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */
3196 #define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */
3198 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
3202 ** A pointer to this structure is used to communicate information
3203 ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
3206 sqlite3
*db
; /* The database being initialized */
3207 char **pzErrMsg
; /* Error message stored here */
3208 int iDb
; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
3209 int rc
; /* Result code stored here */
3213 ** Structure containing global configuration data for the SQLite library.
3215 ** This structure also contains some state information.
3217 struct Sqlite3Config
{
3218 int bMemstat
; /* True to enable memory status */
3219 int bCoreMutex
; /* True to enable core mutexing */
3220 int bFullMutex
; /* True to enable full mutexing */
3221 int bOpenUri
; /* True to interpret filenames as URIs */
3222 int bUseCis
; /* Use covering indices for full-scans */
3223 int mxStrlen
; /* Maximum string length */
3224 int neverCorrupt
; /* Database is always well-formed */
3225 int szLookaside
; /* Default lookaside buffer size */
3226 int nLookaside
; /* Default lookaside buffer count */
3227 int nStmtSpill
; /* Stmt-journal spill-to-disk threshold */
3228 sqlite3_mem_methods m
; /* Low-level memory allocation interface */
3229 sqlite3_mutex_methods mutex
; /* Low-level mutex interface */
3230 sqlite3_pcache_methods2 pcache2
; /* Low-level page-cache interface */
3231 void *pHeap
; /* Heap storage space */
3232 int nHeap
; /* Size of pHeap[] */
3233 int mnReq
, mxReq
; /* Min and max heap requests sizes */
3234 sqlite3_int64 szMmap
; /* mmap() space per open file */
3235 sqlite3_int64 mxMmap
; /* Maximum value for szMmap */
3236 void *pScratch
; /* Scratch memory */
3237 int szScratch
; /* Size of each scratch buffer */
3238 int nScratch
; /* Number of scratch buffers */
3239 void *pPage
; /* Page cache memory */
3240 int szPage
; /* Size of each page in pPage[] */
3241 int nPage
; /* Number of pages in pPage[] */
3242 int mxParserStack
; /* maximum depth of the parser stack */
3243 int sharedCacheEnabled
; /* true if shared-cache mode enabled */
3244 u32 szPma
; /* Maximum Sorter PMA size */
3245 /* The above might be initialized to non-zero. The following need to always
3246 ** initially be zero, however. */
3247 int isInit
; /* True after initialization has finished */
3248 int inProgress
; /* True while initialization in progress */
3249 int isMutexInit
; /* True after mutexes are initialized */
3250 int isMallocInit
; /* True after malloc is initialized */
3251 int isPCacheInit
; /* True after malloc is initialized */
3252 int nRefInitMutex
; /* Number of users of pInitMutex */
3253 sqlite3_mutex
*pInitMutex
; /* Mutex used by sqlite3_initialize() */
3254 void (*xLog
)(void*,int,const char*); /* Function for logging */
3255 void *pLogArg
; /* First argument to xLog() */
3256 #ifdef SQLITE_ENABLE_SQLLOG
3257 void(*xSqllog
)(void*,sqlite3
*,const char*, int);
3260 #ifdef SQLITE_VDBE_COVERAGE
3261 /* The following callback (if not NULL) is invoked on every VDBE branch
3262 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
3264 void (*xVdbeBranch
)(void*,int iSrcLine
,u8 eThis
,u8 eMx
); /* Callback */
3265 void *pVdbeBranchArg
; /* 1st argument */
3267 #ifndef SQLITE_UNTESTABLE
3268 int (*xTestCallback
)(int); /* Invoked by sqlite3FaultSim() */
3270 int bLocaltimeFault
; /* True to fail localtime() calls */
3271 int iOnceResetThreshold
; /* When to reset OP_Once counters */
3275 ** This macro is used inside of assert() statements to indicate that
3276 ** the assert is only valid on a well-formed database. Instead of:
3282 ** assert( X || CORRUPT_DB );
3284 ** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate
3285 ** that the database is definitely corrupt, only that it might be corrupt.
3286 ** For most test cases, CORRUPT_DB is set to false using a special
3287 ** sqlite3_test_control(). This enables assert() statements to prove
3288 ** things that are always true for well-formed databases.
3290 #define CORRUPT_DB (sqlite3Config.neverCorrupt==0)
3293 ** Context pointer passed down through the tree-walk.
3296 Parse
*pParse
; /* Parser context. */
3297 int (*xExprCallback
)(Walker
*, Expr
*); /* Callback for expressions */
3298 int (*xSelectCallback
)(Walker
*,Select
*); /* Callback for SELECTs */
3299 void (*xSelectCallback2
)(Walker
*,Select
*);/* Second callback for SELECTs */
3300 int walkerDepth
; /* Number of subqueries */
3301 u8 eCode
; /* A small processing code */
3302 union { /* Extra data for callback */
3303 NameContext
*pNC
; /* Naming context */
3304 int n
; /* A counter */
3305 int iCur
; /* A cursor number */
3306 SrcList
*pSrcList
; /* FROM clause */
3307 struct SrcCount
*pSrcCount
; /* Counting column references */
3308 struct CCurHint
*pCCurHint
; /* Used by codeCursorHint() */
3309 int *aiCol
; /* array of column indexes */
3310 struct IdxCover
*pIdxCover
; /* Check for index coverage */
3314 /* Forward declarations */
3315 int sqlite3WalkExpr(Walker
*, Expr
*);
3316 int sqlite3WalkExprList(Walker
*, ExprList
*);
3317 int sqlite3WalkSelect(Walker
*, Select
*);
3318 int sqlite3WalkSelectExpr(Walker
*, Select
*);
3319 int sqlite3WalkSelectFrom(Walker
*, Select
*);
3320 int sqlite3ExprWalkNoop(Walker
*, Expr
*);
3323 ** Return code from the parse-tree walking primitives and their
3326 #define WRC_Continue 0 /* Continue down into children */
3327 #define WRC_Prune 1 /* Omit children but continue walking siblings */
3328 #define WRC_Abort 2 /* Abandon the tree walk */
3331 ** An instance of this structure represents a set of one or more CTEs
3332 ** (common table expressions) created by a single WITH clause.
3335 int nCte
; /* Number of CTEs in the WITH clause */
3336 With
*pOuter
; /* Containing WITH clause, or NULL */
3337 struct Cte
{ /* For each CTE in the WITH clause.... */
3338 char *zName
; /* Name of this CTE */
3339 ExprList
*pCols
; /* List of explicit column names, or NULL */
3340 Select
*pSelect
; /* The definition of this CTE */
3341 const char *zCteErr
; /* Error message for circular references */
3347 ** An instance of the TreeView object is used for printing the content of
3348 ** data structures on sqlite3DebugPrintf() using a tree-like view.
3351 int iLevel
; /* Which level of the tree we are on */
3352 u8 bLine
[100]; /* Draw vertical in column i if bLine[i] is true */
3354 #endif /* SQLITE_DEBUG */
3357 ** Assuming zIn points to the first byte of a UTF-8 character,
3358 ** advance zIn to point to the first byte of the next UTF-8 character.
3360 #define SQLITE_SKIP_UTF8(zIn) { \
3361 if( (*(zIn++))>=0xc0 ){ \
3362 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
3367 ** The SQLITE_*_BKPT macros are substitutes for the error codes with
3368 ** the same name but without the _BKPT suffix. These macros invoke
3369 ** routines that report the line-number on which the error originated
3370 ** using sqlite3_log(). The routines also provide a convenient place
3371 ** to set a debugger breakpoint.
3373 int sqlite3CorruptError(int);
3374 int sqlite3MisuseError(int);
3375 int sqlite3CantopenError(int);
3376 #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
3377 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
3378 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
3380 int sqlite3NomemError(int);
3381 int sqlite3IoerrnomemError(int);
3382 # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
3383 # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
3385 # define SQLITE_NOMEM_BKPT SQLITE_NOMEM
3386 # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
3390 ** FTS3 and FTS4 both require virtual table support
3392 #if defined(SQLITE_OMIT_VIRTUALTABLE)
3393 # undef SQLITE_ENABLE_FTS3
3394 # undef SQLITE_ENABLE_FTS4
3398 ** FTS4 is really an extension for FTS3. It is enabled using the
3399 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call
3400 ** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
3402 #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
3403 # define SQLITE_ENABLE_FTS3 1
3407 ** The ctype.h header is needed for non-ASCII systems. It is also
3408 ** needed by FTS3 when FTS3 is included in the amalgamation.
3410 #if !defined(SQLITE_ASCII) || \
3411 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
3416 ** The following macros mimic the standard library functions toupper(),
3417 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
3418 ** sqlite versions only work for ASCII characters, regardless of locale.
3421 # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
3422 # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
3423 # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
3424 # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
3425 # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
3426 # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
3427 # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
3428 # define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
3430 # define sqlite3Toupper(x) toupper((unsigned char)(x))
3431 # define sqlite3Isspace(x) isspace((unsigned char)(x))
3432 # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
3433 # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
3434 # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
3435 # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
3436 # define sqlite3Tolower(x) tolower((unsigned char)(x))
3437 # define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
3439 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
3440 int sqlite3IsIdChar(u8
);
3444 ** Internal function prototypes
3446 int sqlite3StrICmp(const char*,const char*);
3447 int sqlite3Strlen30(const char*);
3448 char *sqlite3ColumnType(Column
*,char*);
3449 #define sqlite3StrNICmp sqlite3_strnicmp
3451 int sqlite3MallocInit(void);
3452 void sqlite3MallocEnd(void);
3453 void *sqlite3Malloc(u64
);
3454 void *sqlite3MallocZero(u64
);
3455 void *sqlite3DbMallocZero(sqlite3
*, u64
);
3456 void *sqlite3DbMallocRaw(sqlite3
*, u64
);
3457 void *sqlite3DbMallocRawNN(sqlite3
*, u64
);
3458 char *sqlite3DbStrDup(sqlite3
*,const char*);
3459 char *sqlite3DbStrNDup(sqlite3
*,const char*, u64
);
3460 void *sqlite3Realloc(void*, u64
);
3461 void *sqlite3DbReallocOrFree(sqlite3
*, void *, u64
);
3462 void *sqlite3DbRealloc(sqlite3
*, void *, u64
);
3463 void sqlite3DbFree(sqlite3
*, void*);
3464 int sqlite3MallocSize(void*);
3465 int sqlite3DbMallocSize(sqlite3
*, void*);
3466 void *sqlite3ScratchMalloc(int);
3467 void sqlite3ScratchFree(void*);
3468 void *sqlite3PageMalloc(int);
3469 void sqlite3PageFree(void*);
3470 void sqlite3MemSetDefault(void);
3471 #ifndef SQLITE_UNTESTABLE
3472 void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
3474 int sqlite3HeapNearlyFull(void);
3477 ** On systems with ample stack space and that support alloca(), make
3478 ** use of alloca() to obtain space for large automatic objects. By default,
3479 ** obtain space from malloc().
3481 ** The alloca() routine never returns NULL. This will cause code paths
3482 ** that deal with sqlite3StackAlloc() failures to be unreachable.
3484 #ifdef SQLITE_USE_ALLOCA
3485 # define sqlite3StackAllocRaw(D,N) alloca(N)
3486 # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
3487 # define sqlite3StackFree(D,P)
3489 # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
3490 # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
3491 # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
3494 /* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they
3495 ** are, disable MEMSYS3
3497 #ifdef SQLITE_ENABLE_MEMSYS5
3498 const sqlite3_mem_methods
*sqlite3MemGetMemsys5(void);
3499 #undef SQLITE_ENABLE_MEMSYS3
3501 #ifdef SQLITE_ENABLE_MEMSYS3
3502 const sqlite3_mem_methods
*sqlite3MemGetMemsys3(void);
3506 #ifndef SQLITE_MUTEX_OMIT
3507 sqlite3_mutex_methods
const *sqlite3DefaultMutex(void);
3508 sqlite3_mutex_methods
const *sqlite3NoopMutex(void);
3509 sqlite3_mutex
*sqlite3MutexAlloc(int);
3510 int sqlite3MutexInit(void);
3511 int sqlite3MutexEnd(void);
3513 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
3514 void sqlite3MemoryBarrier(void);
3516 # define sqlite3MemoryBarrier()
3519 sqlite3_int64
sqlite3StatusValue(int);
3520 void sqlite3StatusUp(int, int);
3521 void sqlite3StatusDown(int, int);
3522 void sqlite3StatusHighwater(int, int);
3524 /* Access to mutexes used by sqlite3_status() */
3525 sqlite3_mutex
*sqlite3Pcache1Mutex(void);
3526 sqlite3_mutex
*sqlite3MallocMutex(void);
3528 #ifndef SQLITE_OMIT_FLOATING_POINT
3529 int sqlite3IsNaN(double);
3531 # define sqlite3IsNaN(X) 0
3535 ** An instance of the following structure holds information about SQL
3536 ** functions arguments that are the parameters to the printf() function.
3538 struct PrintfArguments
{
3539 int nArg
; /* Total number of arguments */
3540 int nUsed
; /* Number of arguments used so far */
3541 sqlite3_value
**apArg
; /* The argument values */
3544 void sqlite3VXPrintf(StrAccum
*, const char*, va_list);
3545 void sqlite3XPrintf(StrAccum
*, const char*, ...);
3546 char *sqlite3MPrintf(sqlite3
*,const char*, ...);
3547 char *sqlite3VMPrintf(sqlite3
*,const char*, va_list);
3548 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
3549 void sqlite3DebugPrintf(const char*, ...);
3551 #if defined(SQLITE_TEST)
3552 void *sqlite3TestTextToPtr(const char*);
3555 #if defined(SQLITE_DEBUG)
3556 void sqlite3TreeViewExpr(TreeView
*, const Expr
*, u8
);
3557 void sqlite3TreeViewBareExprList(TreeView
*, const ExprList
*, const char*);
3558 void sqlite3TreeViewExprList(TreeView
*, const ExprList
*, u8
, const char*);
3559 void sqlite3TreeViewSelect(TreeView
*, const Select
*, u8
);
3560 void sqlite3TreeViewWith(TreeView
*, const With
*, u8
);
3564 void sqlite3SetString(char **, sqlite3
*, const char*);
3565 void sqlite3ErrorMsg(Parse
*, const char*, ...);
3566 void sqlite3Dequote(char*);
3567 void sqlite3TokenInit(Token
*,char*);
3568 int sqlite3KeywordCode(const unsigned char*, int);
3569 int sqlite3RunParser(Parse
*, const char*, char **);
3570 void sqlite3FinishCoding(Parse
*);
3571 int sqlite3GetTempReg(Parse
*);
3572 void sqlite3ReleaseTempReg(Parse
*,int);
3573 int sqlite3GetTempRange(Parse
*,int);
3574 void sqlite3ReleaseTempRange(Parse
*,int,int);
3575 void sqlite3ClearTempRegCache(Parse
*);
3577 int sqlite3NoTempsInRange(Parse
*,int,int);
3579 Expr
*sqlite3ExprAlloc(sqlite3
*,int,const Token
*,int);
3580 Expr
*sqlite3Expr(sqlite3
*,int,const char*);
3581 void sqlite3ExprAttachSubtrees(sqlite3
*,Expr
*,Expr
*,Expr
*);
3582 Expr
*sqlite3PExpr(Parse
*, int, Expr
*, Expr
*);
3583 void sqlite3PExprAddSelect(Parse
*, Expr
*, Select
*);
3584 Expr
*sqlite3ExprAnd(sqlite3
*,Expr
*, Expr
*);
3585 Expr
*sqlite3ExprFunction(Parse
*,ExprList
*, Token
*);
3586 void sqlite3ExprAssignVarNumber(Parse
*, Expr
*, u32
);
3587 void sqlite3ExprDelete(sqlite3
*, Expr
*);
3588 ExprList
*sqlite3ExprListAppend(Parse
*,ExprList
*,Expr
*);
3589 ExprList
*sqlite3ExprListAppendVector(Parse
*,ExprList
*,IdList
*,Expr
*);
3590 void sqlite3ExprListSetSortOrder(ExprList
*,int);
3591 void sqlite3ExprListSetName(Parse
*,ExprList
*,Token
*,int);
3592 void sqlite3ExprListSetSpan(Parse
*,ExprList
*,ExprSpan
*);
3593 void sqlite3ExprListDelete(sqlite3
*, ExprList
*);
3594 u32
sqlite3ExprListFlags(const ExprList
*);
3595 int sqlite3Init(sqlite3
*, char**);
3596 int sqlite3InitCallback(void*, int, char**, char**);
3597 void sqlite3Pragma(Parse
*,Token
*,Token
*,Token
*,int);
3598 #ifndef SQLITE_OMIT_VIRTUALTABLE
3599 Module
*sqlite3PragmaVtabRegister(sqlite3
*,const char *zName
);
3601 void sqlite3ResetAllSchemasOfConnection(sqlite3
*);
3602 void sqlite3ResetOneSchema(sqlite3
*,int);
3603 void sqlite3CollapseDatabaseArray(sqlite3
*);
3604 void sqlite3CommitInternalChanges(sqlite3
*);
3605 void sqlite3DeleteColumnNames(sqlite3
*,Table
*);
3606 int sqlite3ColumnsFromExprList(Parse
*,ExprList
*,i16
*,Column
**);
3607 void sqlite3SelectAddColumnTypeAndCollation(Parse
*,Table
*,Select
*);
3608 Table
*sqlite3ResultSetOfSelect(Parse
*,Select
*);
3609 void sqlite3OpenMasterTable(Parse
*, int);
3610 Index
*sqlite3PrimaryKeyIndex(Table
*);
3611 i16
sqlite3ColumnOfIndex(Index
*, i16
);
3612 void sqlite3StartTable(Parse
*,Token
*,Token
*,int,int,int,int);
3613 #if SQLITE_ENABLE_HIDDEN_COLUMNS
3614 void sqlite3ColumnPropertiesFromName(Table
*, Column
*);
3616 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
3618 void sqlite3AddColumn(Parse
*,Token
*,Token
*);
3619 void sqlite3AddNotNull(Parse
*, int);
3620 void sqlite3AddPrimaryKey(Parse
*, ExprList
*, int, int, int);
3621 void sqlite3AddCheckConstraint(Parse
*, Expr
*);
3622 void sqlite3AddDefaultValue(Parse
*,ExprSpan
*);
3623 void sqlite3AddCollateType(Parse
*, Token
*);
3624 void sqlite3EndTable(Parse
*,Token
*,Token
*,u8
,Select
*);
3625 int sqlite3ParseUri(const char*,const char*,unsigned int*,
3626 sqlite3_vfs
**,char**,char **);
3627 Btree
*sqlite3DbNameToBtree(sqlite3
*,const char*);
3629 #ifdef SQLITE_UNTESTABLE
3630 # define sqlite3FaultSim(X) SQLITE_OK
3632 int sqlite3FaultSim(int);
3635 Bitvec
*sqlite3BitvecCreate(u32
);
3636 int sqlite3BitvecTest(Bitvec
*, u32
);
3637 int sqlite3BitvecTestNotNull(Bitvec
*, u32
);
3638 int sqlite3BitvecSet(Bitvec
*, u32
);
3639 void sqlite3BitvecClear(Bitvec
*, u32
, void*);
3640 void sqlite3BitvecDestroy(Bitvec
*);
3641 u32
sqlite3BitvecSize(Bitvec
*);
3642 #ifndef SQLITE_UNTESTABLE
3643 int sqlite3BitvecBuiltinTest(int,int*);
3646 RowSet
*sqlite3RowSetInit(sqlite3
*, void*, unsigned int);
3647 void sqlite3RowSetClear(RowSet
*);
3648 void sqlite3RowSetInsert(RowSet
*, i64
);
3649 int sqlite3RowSetTest(RowSet
*, int iBatch
, i64
);
3650 int sqlite3RowSetNext(RowSet
*, i64
*);
3652 void sqlite3CreateView(Parse
*,Token
*,Token
*,Token
*,ExprList
*,Select
*,int,int);
3654 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
3655 int sqlite3ViewGetColumnNames(Parse
*,Table
*);
3657 # define sqlite3ViewGetColumnNames(A,B) 0
3660 #if SQLITE_MAX_ATTACHED>30
3661 int sqlite3DbMaskAllZero(yDbMask
);
3663 void sqlite3DropTable(Parse
*, SrcList
*, int, int);
3664 void sqlite3CodeDropTable(Parse
*, Table
*, int, int);
3665 void sqlite3DeleteTable(sqlite3
*, Table
*);
3666 #ifndef SQLITE_OMIT_AUTOINCREMENT
3667 void sqlite3AutoincrementBegin(Parse
*pParse
);
3668 void sqlite3AutoincrementEnd(Parse
*pParse
);
3670 # define sqlite3AutoincrementBegin(X)
3671 # define sqlite3AutoincrementEnd(X)
3673 void sqlite3Insert(Parse
*, SrcList
*, Select
*, IdList
*, int);
3674 void *sqlite3ArrayAllocate(sqlite3
*,void*,int,int*,int*);
3675 IdList
*sqlite3IdListAppend(sqlite3
*, IdList
*, Token
*);
3676 int sqlite3IdListIndex(IdList
*,const char*);
3677 SrcList
*sqlite3SrcListEnlarge(sqlite3
*, SrcList
*, int, int);
3678 SrcList
*sqlite3SrcListAppend(sqlite3
*, SrcList
*, Token
*, Token
*);
3679 SrcList
*sqlite3SrcListAppendFromTerm(Parse
*, SrcList
*, Token
*, Token
*,
3680 Token
*, Select
*, Expr
*, IdList
*);
3681 void sqlite3SrcListIndexedBy(Parse
*, SrcList
*, Token
*);
3682 void sqlite3SrcListFuncArgs(Parse
*, SrcList
*, ExprList
*);
3683 int sqlite3IndexedByLookup(Parse
*, struct SrcList_item
*);
3684 void sqlite3SrcListShiftJoinType(SrcList
*);
3685 void sqlite3SrcListAssignCursors(Parse
*, SrcList
*);
3686 void sqlite3IdListDelete(sqlite3
*, IdList
*);
3687 void sqlite3SrcListDelete(sqlite3
*, SrcList
*);
3688 Index
*sqlite3AllocateIndexObject(sqlite3
*,i16
,int,char**);
3689 void sqlite3CreateIndex(Parse
*,Token
*,Token
*,SrcList
*,ExprList
*,int,Token
*,
3690 Expr
*, int, int, u8
);
3691 void sqlite3DropIndex(Parse
*, SrcList
*, int);
3692 int sqlite3Select(Parse
*, Select
*, SelectDest
*);
3693 Select
*sqlite3SelectNew(Parse
*,ExprList
*,SrcList
*,Expr
*,ExprList
*,
3694 Expr
*,ExprList
*,u32
,Expr
*,Expr
*);
3695 void sqlite3SelectDelete(sqlite3
*, Select
*);
3696 Table
*sqlite3SrcListLookup(Parse
*, SrcList
*);
3697 int sqlite3IsReadOnly(Parse
*, Table
*, int);
3698 void sqlite3OpenTable(Parse
*, int iCur
, int iDb
, Table
*, int);
3699 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
3700 Expr
*sqlite3LimitWhere(Parse
*,SrcList
*,Expr
*,ExprList
*,Expr
*,Expr
*,char*);
3702 void sqlite3DeleteFrom(Parse
*, SrcList
*, Expr
*);
3703 void sqlite3Update(Parse
*, SrcList
*, ExprList
*, Expr
*, int);
3704 WhereInfo
*sqlite3WhereBegin(Parse
*,SrcList
*,Expr
*,ExprList
*,ExprList
*,u16
,int);
3705 void sqlite3WhereEnd(WhereInfo
*);
3706 LogEst
sqlite3WhereOutputRowCount(WhereInfo
*);
3707 int sqlite3WhereIsDistinct(WhereInfo
*);
3708 int sqlite3WhereIsOrdered(WhereInfo
*);
3709 int sqlite3WhereOrderedInnerLoop(WhereInfo
*);
3710 int sqlite3WhereIsSorted(WhereInfo
*);
3711 int sqlite3WhereContinueLabel(WhereInfo
*);
3712 int sqlite3WhereBreakLabel(WhereInfo
*);
3713 int sqlite3WhereOkOnePass(WhereInfo
*, int*);
3714 #define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */
3715 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
3716 #define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */
3717 void sqlite3ExprCodeLoadIndexColumn(Parse
*, Index
*, int, int, int);
3718 int sqlite3ExprCodeGetColumn(Parse
*, Table
*, int, int, int, u8
);
3719 void sqlite3ExprCodeGetColumnToReg(Parse
*, Table
*, int, int, int);
3720 void sqlite3ExprCodeGetColumnOfTable(Vdbe
*, Table
*, int, int, int);
3721 void sqlite3ExprCodeMove(Parse
*, int, int, int);
3722 void sqlite3ExprCacheStore(Parse
*, int, int, int);
3723 void sqlite3ExprCachePush(Parse
*);
3724 void sqlite3ExprCachePop(Parse
*);
3725 void sqlite3ExprCacheRemove(Parse
*, int, int);
3726 void sqlite3ExprCacheClear(Parse
*);
3727 void sqlite3ExprCacheAffinityChange(Parse
*, int, int);
3728 void sqlite3ExprCode(Parse
*, Expr
*, int);
3729 void sqlite3ExprCodeCopy(Parse
*, Expr
*, int);
3730 void sqlite3ExprCodeFactorable(Parse
*, Expr
*, int);
3731 int sqlite3ExprCodeAtInit(Parse
*, Expr
*, int);
3732 int sqlite3ExprCodeTemp(Parse
*, Expr
*, int*);
3733 int sqlite3ExprCodeTarget(Parse
*, Expr
*, int);
3734 void sqlite3ExprCodeAndCache(Parse
*, Expr
*, int);
3735 int sqlite3ExprCodeExprList(Parse
*, ExprList
*, int, int, u8
);
3736 #define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
3737 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
3738 #define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */
3739 #define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */
3740 void sqlite3ExprIfTrue(Parse
*, Expr
*, int, int);
3741 void sqlite3ExprIfFalse(Parse
*, Expr
*, int, int);
3742 void sqlite3ExprIfFalseDup(Parse
*, Expr
*, int, int);
3743 Table
*sqlite3FindTable(sqlite3
*,const char*, const char*);
3744 #define LOCATE_VIEW 0x01
3745 #define LOCATE_NOERR 0x02
3746 Table
*sqlite3LocateTable(Parse
*,u32 flags
,const char*, const char*);
3747 Table
*sqlite3LocateTableItem(Parse
*,u32 flags
,struct SrcList_item
*);
3748 Index
*sqlite3FindIndex(sqlite3
*,const char*, const char*);
3749 void sqlite3UnlinkAndDeleteTable(sqlite3
*,int,const char*);
3750 void sqlite3UnlinkAndDeleteIndex(sqlite3
*,int,const char*);
3751 void sqlite3Vacuum(Parse
*,Token
*);
3752 int sqlite3RunVacuum(char**, sqlite3
*, int);
3753 char *sqlite3NameFromToken(sqlite3
*, Token
*);
3754 int sqlite3ExprCompare(Expr
*, Expr
*, int);
3755 int sqlite3ExprListCompare(ExprList
*, ExprList
*, int);
3756 int sqlite3ExprImpliesExpr(Expr
*, Expr
*, int);
3757 void sqlite3ExprAnalyzeAggregates(NameContext
*, Expr
*);
3758 void sqlite3ExprAnalyzeAggList(NameContext
*,ExprList
*);
3759 int sqlite3ExprCoveredByIndex(Expr
*, int iCur
, Index
*pIdx
);
3760 int sqlite3FunctionUsesThisSrc(Expr
*, SrcList
*);
3761 Vdbe
*sqlite3GetVdbe(Parse
*);
3762 #ifndef SQLITE_UNTESTABLE
3763 void sqlite3PrngSaveState(void);
3764 void sqlite3PrngRestoreState(void);
3766 void sqlite3RollbackAll(sqlite3
*,int);
3767 void sqlite3CodeVerifySchema(Parse
*, int);
3768 void sqlite3CodeVerifyNamedSchema(Parse
*, const char *zDb
);
3769 void sqlite3BeginTransaction(Parse
*, int);
3770 void sqlite3CommitTransaction(Parse
*);
3771 void sqlite3RollbackTransaction(Parse
*);
3772 void sqlite3Savepoint(Parse
*, int, Token
*);
3773 void sqlite3CloseSavepoints(sqlite3
*);
3774 void sqlite3LeaveMutexAndCloseZombie(sqlite3
*);
3775 int sqlite3ExprIsConstant(Expr
*);
3776 int sqlite3ExprIsConstantNotJoin(Expr
*);
3777 int sqlite3ExprIsConstantOrFunction(Expr
*, u8
);
3778 int sqlite3ExprIsTableConstant(Expr
*,int);
3779 #ifdef SQLITE_ENABLE_CURSOR_HINTS
3780 int sqlite3ExprContainsSubquery(Expr
*);
3782 int sqlite3ExprIsInteger(Expr
*, int*);
3783 int sqlite3ExprCanBeNull(const Expr
*);
3784 int sqlite3ExprNeedsNoAffinityChange(const Expr
*, char);
3785 int sqlite3IsRowid(const char*);
3786 void sqlite3GenerateRowDelete(
3787 Parse
*,Table
*,Trigger
*,int,int,int,i16
,u8
,u8
,u8
,int);
3788 void sqlite3GenerateRowIndexDelete(Parse
*, Table
*, int, int, int*, int);
3789 int sqlite3GenerateIndexKey(Parse
*, Index
*, int, int, int, int*,Index
*,int);
3790 void sqlite3ResolvePartIdxLabel(Parse
*,int);
3791 void sqlite3GenerateConstraintChecks(Parse
*,Table
*,int*,int,int,int,int,
3792 u8
,u8
,int,int*,int*);
3793 #ifdef SQLITE_ENABLE_NULL_TRIM
3794 void sqlite3SetMakeRecordP5(Vdbe
*,Table
*);
3796 # define sqlite3SetMakeRecordP5(A,B)
3798 void sqlite3CompleteInsertion(Parse
*,Table
*,int,int,int,int*,int,int,int);
3799 int sqlite3OpenTableAndIndices(Parse
*, Table
*, int, u8
, int, u8
*, int*, int*);
3800 void sqlite3BeginWriteOperation(Parse
*, int, int);
3801 void sqlite3MultiWrite(Parse
*);
3802 void sqlite3MayAbort(Parse
*);
3803 void sqlite3HaltConstraint(Parse
*, int, int, char*, i8
, u8
);
3804 void sqlite3UniqueConstraint(Parse
*, int, Index
*);
3805 void sqlite3RowidConstraint(Parse
*, int, Table
*);
3806 Expr
*sqlite3ExprDup(sqlite3
*,Expr
*,int);
3807 ExprList
*sqlite3ExprListDup(sqlite3
*,ExprList
*,int);
3808 SrcList
*sqlite3SrcListDup(sqlite3
*,SrcList
*,int);
3809 IdList
*sqlite3IdListDup(sqlite3
*,IdList
*);
3810 Select
*sqlite3SelectDup(sqlite3
*,Select
*,int);
3811 #if SELECTTRACE_ENABLED
3812 void sqlite3SelectSetName(Select
*,const char*);
3814 # define sqlite3SelectSetName(A,B)
3816 void sqlite3InsertBuiltinFuncs(FuncDef
*,int);
3817 FuncDef
*sqlite3FindFunction(sqlite3
*,const char*,int,u8
,u8
);
3818 void sqlite3RegisterBuiltinFunctions(void);
3819 void sqlite3RegisterDateTimeFunctions(void);
3820 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3
*);
3821 int sqlite3SafetyCheckOk(sqlite3
*);
3822 int sqlite3SafetyCheckSickOrOk(sqlite3
*);
3823 void sqlite3ChangeCookie(Parse
*, int);
3825 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
3826 void sqlite3MaterializeView(Parse
*, Table
*, Expr
*, int);
3829 #ifndef SQLITE_OMIT_TRIGGER
3830 void sqlite3BeginTrigger(Parse
*, Token
*,Token
*,int,int,IdList
*,SrcList
*,
3832 void sqlite3FinishTrigger(Parse
*, TriggerStep
*, Token
*);
3833 void sqlite3DropTrigger(Parse
*, SrcList
*, int);
3834 void sqlite3DropTriggerPtr(Parse
*, Trigger
*);
3835 Trigger
*sqlite3TriggersExist(Parse
*, Table
*, int, ExprList
*, int *pMask
);
3836 Trigger
*sqlite3TriggerList(Parse
*, Table
*);
3837 void sqlite3CodeRowTrigger(Parse
*, Trigger
*, int, ExprList
*, int, Table
*,
3839 void sqlite3CodeRowTriggerDirect(Parse
*, Trigger
*, Table
*, int, int, int);
3840 void sqliteViewTriggers(Parse
*, Table
*, Expr
*, int, ExprList
*);
3841 void sqlite3DeleteTriggerStep(sqlite3
*, TriggerStep
*);
3842 TriggerStep
*sqlite3TriggerSelectStep(sqlite3
*,Select
*);
3843 TriggerStep
*sqlite3TriggerInsertStep(sqlite3
*,Token
*, IdList
*,
3845 TriggerStep
*sqlite3TriggerUpdateStep(sqlite3
*,Token
*,ExprList
*, Expr
*, u8
);
3846 TriggerStep
*sqlite3TriggerDeleteStep(sqlite3
*,Token
*, Expr
*);
3847 void sqlite3DeleteTrigger(sqlite3
*, Trigger
*);
3848 void sqlite3UnlinkAndDeleteTrigger(sqlite3
*,int,const char*);
3849 u32
sqlite3TriggerColmask(Parse
*,Trigger
*,ExprList
*,int,int,Table
*,int);
3850 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
3851 # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
3853 # define sqlite3TriggersExist(B,C,D,E,F) 0
3854 # define sqlite3DeleteTrigger(A,B)
3855 # define sqlite3DropTriggerPtr(A,B)
3856 # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
3857 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
3858 # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
3859 # define sqlite3TriggerList(X, Y) 0
3860 # define sqlite3ParseToplevel(p) p
3861 # define sqlite3IsToplevel(p) 1
3862 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
3865 int sqlite3JoinType(Parse
*, Token
*, Token
*, Token
*);
3866 void sqlite3CreateForeignKey(Parse
*, ExprList
*, Token
*, ExprList
*, int);
3867 void sqlite3DeferForeignKey(Parse
*, int);
3868 #ifndef SQLITE_OMIT_AUTHORIZATION
3869 void sqlite3AuthRead(Parse
*,Expr
*,Schema
*,SrcList
*);
3870 int sqlite3AuthCheck(Parse
*,int, const char*, const char*, const char*);
3871 void sqlite3AuthContextPush(Parse
*, AuthContext
*, const char*);
3872 void sqlite3AuthContextPop(AuthContext
*);
3873 int sqlite3AuthReadCol(Parse
*, const char *, const char *, int);
3875 # define sqlite3AuthRead(a,b,c,d)
3876 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
3877 # define sqlite3AuthContextPush(a,b,c)
3878 # define sqlite3AuthContextPop(a) ((void)(a))
3880 void sqlite3Attach(Parse
*, Expr
*, Expr
*, Expr
*);
3881 void sqlite3Detach(Parse
*, Expr
*);
3882 void sqlite3FixInit(DbFixer
*, Parse
*, int, const char*, const Token
*);
3883 int sqlite3FixSrcList(DbFixer
*, SrcList
*);
3884 int sqlite3FixSelect(DbFixer
*, Select
*);
3885 int sqlite3FixExpr(DbFixer
*, Expr
*);
3886 int sqlite3FixExprList(DbFixer
*, ExprList
*);
3887 int sqlite3FixTriggerStep(DbFixer
*, TriggerStep
*);
3888 int sqlite3AtoF(const char *z
, double*, int, u8
);
3889 int sqlite3GetInt32(const char *, int*);
3890 int sqlite3Atoi(const char*);
3891 int sqlite3Utf16ByteLen(const void *pData
, int nChar
);
3892 int sqlite3Utf8CharLen(const char *pData
, int nByte
);
3893 u32
sqlite3Utf8Read(const u8
**);
3894 LogEst
sqlite3LogEst(u64
);
3895 LogEst
sqlite3LogEstAdd(LogEst
,LogEst
);
3896 #ifndef SQLITE_OMIT_VIRTUALTABLE
3897 LogEst
sqlite3LogEstFromDouble(double);
3899 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
3900 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
3901 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
3902 u64
sqlite3LogEstToInt(LogEst
);
3904 VList
*sqlite3VListAdd(sqlite3
*,VList
*,const char*,int,int);
3905 const char *sqlite3VListNumToName(VList
*,int);
3906 int sqlite3VListNameToNum(VList
*,const char*,int);
3909 ** Routines to read and write variable-length integers. These used to
3910 ** be defined locally, but now we use the varint routines in the util.c
3913 int sqlite3PutVarint(unsigned char*, u64
);
3914 u8
sqlite3GetVarint(const unsigned char *, u64
*);
3915 u8
sqlite3GetVarint32(const unsigned char *, u32
*);
3916 int sqlite3VarintLen(u64 v
);
3919 ** The common case is for a varint to be a single byte. They following
3920 ** macros handle the common case without a procedure call, but then call
3921 ** the procedure for larger varints.
3923 #define getVarint32(A,B) \
3924 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
3925 #define putVarint32(A,B) \
3926 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
3927 sqlite3PutVarint((A),(B)))
3928 #define getVarint sqlite3GetVarint
3929 #define putVarint sqlite3PutVarint
3932 const char *sqlite3IndexAffinityStr(sqlite3
*, Index
*);
3933 void sqlite3TableAffinity(Vdbe
*, Table
*, int);
3934 char sqlite3CompareAffinity(Expr
*pExpr
, char aff2
);
3935 int sqlite3IndexAffinityOk(Expr
*pExpr
, char idx_affinity
);
3936 char sqlite3TableColumnAffinity(Table
*,int);
3937 char sqlite3ExprAffinity(Expr
*pExpr
);
3938 int sqlite3Atoi64(const char*, i64
*, int, u8
);
3939 int sqlite3DecOrHexToI64(const char*, i64
*);
3940 void sqlite3ErrorWithMsg(sqlite3
*, int, const char*,...);
3941 void sqlite3Error(sqlite3
*,int);
3942 void sqlite3SystemError(sqlite3
*,int);
3943 void *sqlite3HexToBlob(sqlite3
*, const char *z
, int n
);
3944 u8
sqlite3HexToInt(int h
);
3945 int sqlite3TwoPartName(Parse
*, Token
*, Token
*, Token
**);
3947 #if defined(SQLITE_NEED_ERR_NAME)
3948 const char *sqlite3ErrName(int);
3951 const char *sqlite3ErrStr(int);
3952 int sqlite3ReadSchema(Parse
*pParse
);
3953 CollSeq
*sqlite3FindCollSeq(sqlite3
*,u8 enc
, const char*,int);
3954 CollSeq
*sqlite3LocateCollSeq(Parse
*pParse
, const char*zName
);
3955 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, Expr
*pExpr
);
3956 Expr
*sqlite3ExprAddCollateToken(Parse
*pParse
, Expr
*, const Token
*, int);
3957 Expr
*sqlite3ExprAddCollateString(Parse
*,Expr
*,const char*);
3958 Expr
*sqlite3ExprSkipCollate(Expr
*);
3959 int sqlite3CheckCollSeq(Parse
*, CollSeq
*);
3960 int sqlite3CheckObjectName(Parse
*, const char *);
3961 void sqlite3VdbeSetChanges(sqlite3
*, int);
3962 int sqlite3AddInt64(i64
*,i64
);
3963 int sqlite3SubInt64(i64
*,i64
);
3964 int sqlite3MulInt64(i64
*,i64
);
3965 int sqlite3AbsInt32(int);
3966 #ifdef SQLITE_ENABLE_8_3_NAMES
3967 void sqlite3FileSuffix3(const char*, char*);
3969 # define sqlite3FileSuffix3(X,Y)
3971 u8
sqlite3GetBoolean(const char *z
,u8
);
3973 const void *sqlite3ValueText(sqlite3_value
*, u8
);
3974 int sqlite3ValueBytes(sqlite3_value
*, u8
);
3975 void sqlite3ValueSetStr(sqlite3_value
*, int, const void *,u8
,
3977 void sqlite3ValueSetNull(sqlite3_value
*);
3978 void sqlite3ValueFree(sqlite3_value
*);
3979 sqlite3_value
*sqlite3ValueNew(sqlite3
*);
3980 char *sqlite3Utf16to8(sqlite3
*, const void*, int, u8
);
3981 int sqlite3ValueFromExpr(sqlite3
*, Expr
*, u8
, u8
, sqlite3_value
**);
3982 void sqlite3ValueApplyAffinity(sqlite3_value
*, u8
, u8
);
3983 #ifndef SQLITE_AMALGAMATION
3984 extern const unsigned char sqlite3OpcodeProperty
[];
3985 extern const char sqlite3StrBINARY
[];
3986 extern const unsigned char sqlite3UpperToLower
[];
3987 extern const unsigned char sqlite3CtypeMap
[];
3988 extern const Token sqlite3IntTokens
[];
3989 extern SQLITE_WSD
struct Sqlite3Config sqlite3Config
;
3990 extern FuncDefHash sqlite3BuiltinFunctions
;
3991 #ifndef SQLITE_OMIT_WSD
3992 extern int sqlite3PendingByte
;
3995 void sqlite3RootPageMoved(sqlite3
*, int, int, int);
3996 void sqlite3Reindex(Parse
*, Token
*, Token
*);
3997 void sqlite3AlterFunctions(void);
3998 void sqlite3AlterRenameTable(Parse
*, SrcList
*, Token
*);
3999 int sqlite3GetToken(const unsigned char *, int *);
4000 void sqlite3NestedParse(Parse
*, const char*, ...);
4001 void sqlite3ExpirePreparedStatements(sqlite3
*);
4002 int sqlite3CodeSubselect(Parse
*, Expr
*, int, int);
4003 void sqlite3SelectPrep(Parse
*, Select
*, NameContext
*);
4004 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
);
4005 int sqlite3MatchSpanName(const char*, const char*, const char*, const char*);
4006 int sqlite3ResolveExprNames(NameContext
*, Expr
*);
4007 int sqlite3ResolveExprListNames(NameContext
*, ExprList
*);
4008 void sqlite3ResolveSelectNames(Parse
*, Select
*, NameContext
*);
4009 void sqlite3ResolveSelfReference(Parse
*,Table
*,int,Expr
*,ExprList
*);
4010 int sqlite3ResolveOrderGroupBy(Parse
*, Select
*, ExprList
*, const char*);
4011 void sqlite3ColumnDefault(Vdbe
*, Table
*, int, int);
4012 void sqlite3AlterFinishAddColumn(Parse
*, Token
*);
4013 void sqlite3AlterBeginAddColumn(Parse
*, SrcList
*);
4014 CollSeq
*sqlite3GetCollSeq(Parse
*, u8
, CollSeq
*, const char*);
4015 char sqlite3AffinityType(const char*, u8
*);
4016 void sqlite3Analyze(Parse
*, Token
*, Token
*);
4017 int sqlite3InvokeBusyHandler(BusyHandler
*);
4018 int sqlite3FindDb(sqlite3
*, Token
*);
4019 int sqlite3FindDbName(sqlite3
*, const char *);
4020 int sqlite3AnalysisLoad(sqlite3
*,int iDB
);
4021 void sqlite3DeleteIndexSamples(sqlite3
*,Index
*);
4022 void sqlite3DefaultRowEst(Index
*);
4023 void sqlite3RegisterLikeFunctions(sqlite3
*, int);
4024 int sqlite3IsLikeFunction(sqlite3
*,Expr
*,int*,char*);
4025 void sqlite3SchemaClear(void *);
4026 Schema
*sqlite3SchemaGet(sqlite3
*, Btree
*);
4027 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*);
4028 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*,int,int);
4029 void sqlite3KeyInfoUnref(KeyInfo
*);
4030 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*);
4031 KeyInfo
*sqlite3KeyInfoOfIndex(Parse
*, Index
*);
4033 int sqlite3KeyInfoIsWriteable(KeyInfo
*);
4035 int sqlite3CreateFunc(sqlite3
*, const char *, int, int, void *,
4036 void (*)(sqlite3_context
*,int,sqlite3_value
**),
4037 void (*)(sqlite3_context
*,int,sqlite3_value
**), void (*)(sqlite3_context
*),
4038 FuncDestructor
*pDestructor
4040 void sqlite3OomFault(sqlite3
*);
4041 void sqlite3OomClear(sqlite3
*);
4042 int sqlite3ApiExit(sqlite3
*db
, int);
4043 int sqlite3OpenTempDatabase(Parse
*);
4045 void sqlite3StrAccumInit(StrAccum
*, sqlite3
*, char*, int, int);
4046 void sqlite3StrAccumAppend(StrAccum
*,const char*,int);
4047 void sqlite3StrAccumAppendAll(StrAccum
*,const char*);
4048 void sqlite3AppendChar(StrAccum
*,int,char);
4049 char *sqlite3StrAccumFinish(StrAccum
*);
4050 void sqlite3StrAccumReset(StrAccum
*);
4051 void sqlite3SelectDestInit(SelectDest
*,int,int);
4052 Expr
*sqlite3CreateColumnExpr(sqlite3
*, SrcList
*, int, int);
4054 void sqlite3BackupRestart(sqlite3_backup
*);
4055 void sqlite3BackupUpdate(sqlite3_backup
*, Pgno
, const u8
*);
4057 #ifndef SQLITE_OMIT_SUBQUERY
4058 int sqlite3ExprCheckIN(Parse
*, Expr
*);
4060 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
4063 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
4064 void sqlite3AnalyzeFunctions(void);
4065 int sqlite3Stat4ProbeSetValue(
4066 Parse
*,Index
*,UnpackedRecord
**,Expr
*,int,int,int*);
4067 int sqlite3Stat4ValueFromExpr(Parse
*, Expr
*, u8
, sqlite3_value
**);
4068 void sqlite3Stat4ProbeFree(UnpackedRecord
*);
4069 int sqlite3Stat4Column(sqlite3
*, const void*, int, int, sqlite3_value
**);
4070 char sqlite3IndexColumnAffinity(sqlite3
*, Index
*, int);
4074 ** The interface to the LEMON-generated parser
4076 void *sqlite3ParserAlloc(void*(*)(u64
));
4077 void sqlite3ParserFree(void*, void(*)(void*));
4078 void sqlite3Parser(void*, int, Token
, Parse
*);
4079 #ifdef YYTRACKMAXSTACKDEPTH
4080 int sqlite3ParserStackPeak(void*);
4083 void sqlite3AutoLoadExtensions(sqlite3
*);
4084 #ifndef SQLITE_OMIT_LOAD_EXTENSION
4085 void sqlite3CloseExtensions(sqlite3
*);
4087 # define sqlite3CloseExtensions(X)
4090 #ifndef SQLITE_OMIT_SHARED_CACHE
4091 void sqlite3TableLock(Parse
*, int, int, u8
, const char *);
4093 #define sqlite3TableLock(v,w,x,y,z)
4097 int sqlite3Utf8To8(unsigned char*);
4100 #ifdef SQLITE_OMIT_VIRTUALTABLE
4101 # define sqlite3VtabClear(Y)
4102 # define sqlite3VtabSync(X,Y) SQLITE_OK
4103 # define sqlite3VtabRollback(X)
4104 # define sqlite3VtabCommit(X)
4105 # define sqlite3VtabInSync(db) 0
4106 # define sqlite3VtabLock(X)
4107 # define sqlite3VtabUnlock(X)
4108 # define sqlite3VtabUnlockList(X)
4109 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
4110 # define sqlite3GetVTable(X,Y) ((VTable*)0)
4112 void sqlite3VtabClear(sqlite3
*db
, Table
*);
4113 void sqlite3VtabDisconnect(sqlite3
*db
, Table
*p
);
4114 int sqlite3VtabSync(sqlite3
*db
, Vdbe
*);
4115 int sqlite3VtabRollback(sqlite3
*db
);
4116 int sqlite3VtabCommit(sqlite3
*db
);
4117 void sqlite3VtabLock(VTable
*);
4118 void sqlite3VtabUnlock(VTable
*);
4119 void sqlite3VtabUnlockList(sqlite3
*);
4120 int sqlite3VtabSavepoint(sqlite3
*, int, int);
4121 void sqlite3VtabImportErrmsg(Vdbe
*, sqlite3_vtab
*);
4122 VTable
*sqlite3GetVTable(sqlite3
*, Table
*);
4123 Module
*sqlite3VtabCreateModule(
4126 const sqlite3_module
*,
4130 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
4132 int sqlite3VtabEponymousTableInit(Parse
*,Module
*);
4133 void sqlite3VtabEponymousTableClear(sqlite3
*,Module
*);
4134 void sqlite3VtabMakeWritable(Parse
*,Table
*);
4135 void sqlite3VtabBeginParse(Parse
*, Token
*, Token
*, Token
*, int);
4136 void sqlite3VtabFinishParse(Parse
*, Token
*);
4137 void sqlite3VtabArgInit(Parse
*);
4138 void sqlite3VtabArgExtend(Parse
*, Token
*);
4139 int sqlite3VtabCallCreate(sqlite3
*, int, const char *, char **);
4140 int sqlite3VtabCallConnect(Parse
*, Table
*);
4141 int sqlite3VtabCallDestroy(sqlite3
*, int, const char *);
4142 int sqlite3VtabBegin(sqlite3
*, VTable
*);
4143 FuncDef
*sqlite3VtabOverloadFunction(sqlite3
*,FuncDef
*, int nArg
, Expr
*);
4144 void sqlite3InvalidFunction(sqlite3_context
*,int,sqlite3_value
**);
4145 sqlite3_int64
sqlite3StmtCurrentTime(sqlite3_context
*);
4146 int sqlite3VdbeParameterIndex(Vdbe
*, const char*, int);
4147 int sqlite3TransferBindings(sqlite3_stmt
*, sqlite3_stmt
*);
4148 void sqlite3ParserReset(Parse
*);
4149 int sqlite3Reprepare(Vdbe
*);
4150 void sqlite3ExprListCheckLength(Parse
*, ExprList
*, const char*);
4151 CollSeq
*sqlite3BinaryCompareCollSeq(Parse
*, Expr
*, Expr
*);
4152 int sqlite3TempInMemory(const sqlite3
*);
4153 const char *sqlite3JournalModename(int);
4154 #ifndef SQLITE_OMIT_WAL
4155 int sqlite3Checkpoint(sqlite3
*, int, int, int*, int*);
4156 int sqlite3WalDefaultHook(void*,sqlite3
*,const char*,int);
4158 #ifndef SQLITE_OMIT_CTE
4159 With
*sqlite3WithAdd(Parse
*,With
*,Token
*,ExprList
*,Select
*);
4160 void sqlite3WithDelete(sqlite3
*,With
*);
4161 void sqlite3WithPush(Parse
*, With
*, u8
);
4163 #define sqlite3WithPush(x,y,z)
4164 #define sqlite3WithDelete(x,y)
4167 /* Declarations for functions in fkey.c. All of these are replaced by
4168 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
4169 ** key functionality is available. If OMIT_TRIGGER is defined but
4170 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
4171 ** this case foreign keys are parsed, but no other functionality is
4172 ** provided (enforcement of FK constraints requires the triggers sub-system).
4174 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
4175 void sqlite3FkCheck(Parse
*, Table
*, int, int, int*, int);
4176 void sqlite3FkDropTable(Parse
*, SrcList
*, Table
*);
4177 void sqlite3FkActions(Parse
*, Table
*, ExprList
*, int, int*, int);
4178 int sqlite3FkRequired(Parse
*, Table
*, int*, int);
4179 u32
sqlite3FkOldmask(Parse
*, Table
*);
4180 FKey
*sqlite3FkReferences(Table
*);
4182 #define sqlite3FkActions(a,b,c,d,e,f)
4183 #define sqlite3FkCheck(a,b,c,d,e,f)
4184 #define sqlite3FkDropTable(a,b,c)
4185 #define sqlite3FkOldmask(a,b) 0
4186 #define sqlite3FkRequired(a,b,c,d) 0
4188 #ifndef SQLITE_OMIT_FOREIGN_KEY
4189 void sqlite3FkDelete(sqlite3
*, Table
*);
4190 int sqlite3FkLocateIndex(Parse
*,Table
*,FKey
*,Index
**,int**);
4192 #define sqlite3FkDelete(a,b)
4193 #define sqlite3FkLocateIndex(a,b,c,d,e)
4198 ** Available fault injectors. Should be numbered beginning with 0.
4200 #define SQLITE_FAULTINJECTOR_MALLOC 0
4201 #define SQLITE_FAULTINJECTOR_COUNT 1
4204 ** The interface to the code in fault.c used for identifying "benign"
4205 ** malloc failures. This is only present if SQLITE_UNTESTABLE
4208 #ifndef SQLITE_UNTESTABLE
4209 void sqlite3BeginBenignMalloc(void);
4210 void sqlite3EndBenignMalloc(void);
4212 #define sqlite3BeginBenignMalloc()
4213 #define sqlite3EndBenignMalloc()
4217 ** Allowed return values from sqlite3FindInIndex()
4219 #define IN_INDEX_ROWID 1 /* Search the rowid of the table */
4220 #define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
4221 #define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */
4222 #define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */
4223 #define IN_INDEX_NOOP 5 /* No table available. Use comparisons */
4225 ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
4227 #define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
4228 #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
4229 #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
4230 int sqlite3FindInIndex(Parse
*, Expr
*, u32
, int*, int*);
4232 int sqlite3JournalOpen(sqlite3_vfs
*, const char *, sqlite3_file
*, int, int);
4233 int sqlite3JournalSize(sqlite3_vfs
*);
4234 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
4235 int sqlite3JournalCreate(sqlite3_file
*);
4238 int sqlite3JournalIsInMemory(sqlite3_file
*p
);
4239 void sqlite3MemJournalOpen(sqlite3_file
*);
4241 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
);
4242 #if SQLITE_MAX_EXPR_DEPTH>0
4243 int sqlite3SelectExprHeight(Select
*);
4244 int sqlite3ExprCheckHeight(Parse
*, int);
4246 #define sqlite3SelectExprHeight(x) 0
4247 #define sqlite3ExprCheckHeight(x,y)
4250 u32
sqlite3Get4byte(const u8
*);
4251 void sqlite3Put4byte(u8
*, u32
);
4253 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
4254 void sqlite3ConnectionBlocked(sqlite3
*, sqlite3
*);
4255 void sqlite3ConnectionUnlocked(sqlite3
*db
);
4256 void sqlite3ConnectionClosed(sqlite3
*db
);
4258 #define sqlite3ConnectionBlocked(x,y)
4259 #define sqlite3ConnectionUnlocked(x)
4260 #define sqlite3ConnectionClosed(x)
4264 void sqlite3ParserTrace(FILE*, char *);
4268 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
4269 ** sqlite3IoTrace is a pointer to a printf-like routine used to
4270 ** print I/O tracing messages.
4272 #ifdef SQLITE_ENABLE_IOTRACE
4273 # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
4274 void sqlite3VdbeIOTraceSql(Vdbe
*);
4275 SQLITE_API SQLITE_EXTERN
void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*,...);
4278 # define sqlite3VdbeIOTraceSql(X)
4282 ** These routines are available for the mem2.c debugging memory allocator
4283 ** only. They are used to verify that different "types" of memory
4284 ** allocations are properly tracked by the system.
4286 ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
4287 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
4288 ** a single bit set.
4290 ** sqlite3MemdebugHasType() returns true if any of the bits in its second
4291 ** argument match the type set by the previous sqlite3MemdebugSetType().
4292 ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
4294 ** sqlite3MemdebugNoType() returns true if none of the bits in its second
4295 ** argument match the type set by the previous sqlite3MemdebugSetType().
4297 ** Perhaps the most important point is the difference between MEMTYPE_HEAP
4298 ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
4299 ** it might have been allocated by lookaside, except the allocation was
4300 ** too large or lookaside was already full. It is important to verify
4301 ** that allocations that might have been satisfied by lookaside are not
4302 ** passed back to non-lookaside free() routines. Asserts such as the
4303 ** example above are placed on the non-lookaside free() routines to verify
4306 ** All of this is no-op for a production build. It only comes into
4307 ** play when the SQLITE_MEMDEBUG compile-time option is used.
4309 #ifdef SQLITE_MEMDEBUG
4310 void sqlite3MemdebugSetType(void*,u8
);
4311 int sqlite3MemdebugHasType(void*,u8
);
4312 int sqlite3MemdebugNoType(void*,u8
);
4314 # define sqlite3MemdebugSetType(X,Y) /* no-op */
4315 # define sqlite3MemdebugHasType(X,Y) 1
4316 # define sqlite3MemdebugNoType(X,Y) 1
4318 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
4319 #define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */
4320 #define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
4321 #define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
4324 ** Threading interface
4326 #if SQLITE_MAX_WORKER_THREADS>0
4327 int sqlite3ThreadCreate(SQLiteThread
**,void*(*)(void*),void*);
4328 int sqlite3ThreadJoin(SQLiteThread
*, void**);
4331 #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
4332 int sqlite3DbstatRegister(sqlite3
*);
4335 int sqlite3ExprVectorSize(Expr
*pExpr
);
4336 int sqlite3ExprIsVector(Expr
*pExpr
);
4337 Expr
*sqlite3VectorFieldSubexpr(Expr
*, int);
4338 Expr
*sqlite3ExprForVectorField(Parse
*,Expr
*,int);
4339 void sqlite3VectorErrorMsg(Parse
*, Expr
*);
4341 #endif /* SQLITEINT_H */