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 always be false
29 ** and the correct answer is still obtained,
30 ** though perhaps more slowly.
32 ** OPTIMIZATION-IF-FALSE - This branch is allowed to always be true
33 ** and the correct answer is still obtained,
34 ** though perhaps more slowly.
36 ** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread
37 ** that would be harmless and undetectable
40 ** In all cases, the special comment must be enclosed in the usual
41 ** slash-asterisk...asterisk-slash comment marks, with no spaces between the
42 ** asterisks and the comment text.
46 ** Make sure the Tcl calling convention macro is defined. This macro is
47 ** only used by test code and Tcl integration code.
50 # define SQLITE_TCLAPI
54 ** Include the header file used to customize the compiler options for MSVC.
55 ** This should be done first so that it can successfully prevent spurious
56 ** compiler warnings due to subsequent content in this file and other files
57 ** that are included by this file.
62 ** Special setup for VxWorks
67 ** These #defines should enable >2GB file support on POSIX if the
68 ** underlying operating system supports it. If the OS lacks
69 ** large file support, or if the OS is windows, these should be no-ops.
71 ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
72 ** system #includes. Hence, this block of code must be the very first
73 ** code in all source files.
75 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
76 ** on the compiler command line. This is necessary if you are compiling
77 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
78 ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
79 ** without this option, LFS is enable. But LFS does not exist in the kernel
80 ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
81 ** portability you should omit LFS.
83 ** The previous paragraph was written in 2005. (This paragraph is written
84 ** on 2008-11-28.) These days, all Linux kernels support large files, so
85 ** you should probably leave LFS enabled. But some embedded platforms might
86 ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
88 ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
90 #ifndef SQLITE_DISABLE_LFS
91 # define _LARGE_FILE 1
92 # ifndef _FILE_OFFSET_BITS
93 # define _FILE_OFFSET_BITS 64
95 # define _LARGEFILE_SOURCE 1
98 /* The GCC_VERSION and MSVC_VERSION macros are used to
99 ** conditionally include optimizations for each of these compilers. A
100 ** value of 0 means that compiler is not being used. The
101 ** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
102 ** optimizations, and hence set all compiler macros to 0
104 ** There was once also a CLANG_VERSION macro. However, we learn that the
105 ** version numbers in clang are for "marketing" only and are inconsistent
106 ** and unreliable. Fortunately, all versions of clang also recognize the
107 ** gcc version numbers and have reasonable settings for gcc version numbers,
108 ** so the GCC_VERSION macro will be set to a correct non-zero value even
109 ** when compiling with clang.
111 #if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)
112 # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
114 # define GCC_VERSION 0
116 #if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
117 # define MSVC_VERSION _MSC_VER
119 # define MSVC_VERSION 0
123 ** Some C99 functions in "math.h" are only present for MSVC when its version
124 ** is associated with Visual Studio 2013 or higher.
126 #ifndef SQLITE_HAVE_C99_MATH_FUNCS
127 # if MSVC_VERSION==0 || MSVC_VERSION>=1800
128 # define SQLITE_HAVE_C99_MATH_FUNCS (1)
130 # define SQLITE_HAVE_C99_MATH_FUNCS (0)
134 /* Needed for various definitions... */
135 #if defined(__GNUC__) && !defined(_GNU_SOURCE)
139 #if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
144 ** Macro to disable warnings about missing "break" at the end of a "case".
146 #if GCC_VERSION>=7000000
147 # define deliberate_fall_through __attribute__((fallthrough));
149 # define deliberate_fall_through
153 ** For MinGW, check to see if we can include the header file containing its
154 ** version information, among other things. Normally, this internal MinGW
155 ** header file would [only] be included automatically by other MinGW header
156 ** files; however, the contained version information is now required by this
157 ** header file to work around binary compatibility issues (see below) and
158 ** this is the only known way to reliably obtain it. This entire #if block
159 ** would be completely unnecessary if there was any other way of detecting
160 ** MinGW via their preprocessor (e.g. if they customized their GCC to define
161 ** some MinGW-specific macros). When compiling for MinGW, either the
162 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
163 ** defined; otherwise, detection of conditions specific to MinGW will be
166 #if defined(_HAVE_MINGW_H)
168 #elif defined(_HAVE__MINGW_H)
173 ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
174 ** define is required to maintain binary compatibility with the MSVC runtime
175 ** library in use (e.g. for Windows XP).
177 #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
178 defined(_WIN32) && !defined(_WIN64) && \
179 defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
181 # define _USE_32BIT_TIME_T
184 /* Optionally #include a user-defined header, whereby compilation options
185 ** may be set prior to where they take effect, but after platform setup.
186 ** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include
189 #ifdef SQLITE_CUSTOM_INCLUDE
190 # define INC_STRINGIFY_(f) #f
191 # define INC_STRINGIFY(f) INC_STRINGIFY_(f)
192 # include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE)
195 /* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
196 ** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
202 ** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory.
204 #define SQLITE_MUTEX_STATIC_TEMPDIR SQLITE_MUTEX_STATIC_VFS1
207 ** Include the configuration header output by 'configure' if we're using the
208 ** autoconf-based build
210 #if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
211 #include "sqlite_cfg.h"
212 #define SQLITECONFIG_H 1
215 #include "sqliteLimit.h"
217 /* Disable nuisance warnings on Borland compilers */
218 #if defined(__BORLANDC__)
219 #pragma warn -rch /* unreachable code */
220 #pragma warn -ccc /* Condition is always true or false */
221 #pragma warn -aus /* Assigned value is never used */
222 #pragma warn -csu /* Comparing signed and unsigned */
223 #pragma warn -spa /* Suspicious pointer arithmetic */
227 ** A few places in the code require atomic load/store of aligned
230 #ifndef __has_extension
231 # define __has_extension(x) 0 /* compatibility with non-clang compilers */
233 #if GCC_VERSION>=4007000 || __has_extension(c_atomic)
234 # define SQLITE_ATOMIC_INTRINSICS 1
235 # define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED)
236 # define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED)
238 # define SQLITE_ATOMIC_INTRINSICS 0
239 # define AtomicLoad(PTR) (*(PTR))
240 # define AtomicStore(PTR,VAL) (*(PTR) = (VAL))
244 ** Include standard header files as necessary
249 #ifdef HAVE_INTTYPES_H
250 #include <inttypes.h>
254 ** The following macros are used to cast pointers to integers and
255 ** integers to pointers. The way you do this varies from one compiler
256 ** to the next, so we have developed the following set of #if statements
257 ** to generate appropriate macros for a wide range of compilers.
259 ** The correct "ANSI" way to do this is to use the intptr_t type.
260 ** Unfortunately, that typedef is not available on all compilers, or
261 ** if it is available, it requires an #include of specific headers
262 ** that vary from one machine to the next.
264 ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
265 ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
266 ** So we have to define the macros in different ways depending on the
269 #if defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
270 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
271 # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
272 #elif defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
273 # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
274 # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
275 #elif !defined(__GNUC__) /* Works for compilers other than LLVM */
276 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
277 # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
278 #else /* Generates a warning - but it always works */
279 # define SQLITE_INT_TO_PTR(X) ((void*)(X))
280 # define SQLITE_PTR_TO_INT(X) ((int)(X))
284 ** Macros to hint to the compiler that a function should or should not be
287 #if defined(__GNUC__)
288 # define SQLITE_NOINLINE __attribute__((noinline))
289 # define SQLITE_INLINE __attribute__((always_inline)) inline
290 #elif defined(_MSC_VER) && _MSC_VER>=1310
291 # define SQLITE_NOINLINE __declspec(noinline)
292 # define SQLITE_INLINE __forceinline
294 # define SQLITE_NOINLINE
295 # define SQLITE_INLINE
297 #if defined(SQLITE_COVERAGE_TEST) || defined(__STRICT_ANSI__)
298 # undef SQLITE_INLINE
299 # define SQLITE_INLINE
303 ** Make sure that the compiler intrinsics we desire are enabled when
304 ** compiling with an appropriate version of MSVC unless prevented by
305 ** the SQLITE_DISABLE_INTRINSIC define.
307 #if !defined(SQLITE_DISABLE_INTRINSIC)
308 # if defined(_MSC_VER) && _MSC_VER>=1400
309 # if !defined(_WIN32_WCE)
311 # pragma intrinsic(_byteswap_ushort)
312 # pragma intrinsic(_byteswap_ulong)
313 # pragma intrinsic(_byteswap_uint64)
314 # pragma intrinsic(_ReadWriteBarrier)
316 # include <cmnintrin.h>
322 ** Enable SQLITE_USE_SEH by default on MSVC builds. Only omit
323 ** SEH support if the -DSQLITE_OMIT_SEH option is given.
325 #if defined(_MSC_VER) && !defined(SQLITE_OMIT_SEH)
326 # define SQLITE_USE_SEH 1
328 # undef SQLITE_USE_SEH
332 ** Enable SQLITE_DIRECT_OVERFLOW_READ, unless the build explicitly
333 ** disables it using -DSQLITE_DIRECT_OVERFLOW_READ=0
335 #if defined(SQLITE_DIRECT_OVERFLOW_READ) && SQLITE_DIRECT_OVERFLOW_READ+1==1
336 /* Disable if -DSQLITE_DIRECT_OVERFLOW_READ=0 */
337 # undef SQLITE_DIRECT_OVERFLOW_READ
339 /* In all other cases, enable */
340 # define SQLITE_DIRECT_OVERFLOW_READ 1
345 ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
346 ** 0 means mutexes are permanently disable and the library is never
347 ** threadsafe. 1 means the library is serialized which is the highest
348 ** level of threadsafety. 2 means the library is multithreaded - multiple
349 ** threads can use SQLite as long as no two threads try to use the same
350 ** database connection at the same time.
352 ** Older versions of SQLite used an optional THREADSAFE macro.
353 ** We support that for legacy.
355 ** To ensure that the correct value of "THREADSAFE" is reported when querying
356 ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
357 ** logic is partially replicated in ctime.c. If it is updated here, it should
358 ** also be updated there.
360 #if !defined(SQLITE_THREADSAFE)
361 # if defined(THREADSAFE)
362 # define SQLITE_THREADSAFE THREADSAFE
364 # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
369 ** Powersafe overwrite is on by default. But can be turned off using
370 ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
372 #ifndef SQLITE_POWERSAFE_OVERWRITE
373 # define SQLITE_POWERSAFE_OVERWRITE 1
377 ** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
378 ** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in
379 ** which case memory allocation statistics are disabled by default.
381 #if !defined(SQLITE_DEFAULT_MEMSTATUS)
382 # define SQLITE_DEFAULT_MEMSTATUS 1
386 ** Exactly one of the following macros must be defined in order to
387 ** specify which memory allocation subsystem to use.
389 ** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
390 ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
391 ** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails
392 ** SQLITE_MEMDEBUG // Debugging version of system malloc()
394 ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
395 ** assert() macro is enabled, each call into the Win32 native heap subsystem
396 ** will cause HeapValidate to be called. If heap validation should fail, an
397 ** assertion will be triggered.
399 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
402 #if defined(SQLITE_SYSTEM_MALLOC) \
403 + defined(SQLITE_WIN32_MALLOC) \
404 + defined(SQLITE_ZERO_MALLOC) \
405 + defined(SQLITE_MEMDEBUG)>1
406 # error "Two or more of the following compile-time configuration options\
407 are defined but at most one is allowed:\
408 SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\
411 #if defined(SQLITE_SYSTEM_MALLOC) \
412 + defined(SQLITE_WIN32_MALLOC) \
413 + defined(SQLITE_ZERO_MALLOC) \
414 + defined(SQLITE_MEMDEBUG)==0
415 # define SQLITE_SYSTEM_MALLOC 1
419 ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
420 ** sizes of memory allocations below this value where possible.
422 #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
423 # define SQLITE_MALLOC_SOFT_LIMIT 1024
427 ** We need to define _XOPEN_SOURCE as follows in order to enable
428 ** recursive mutexes on most Unix systems and fchmod() on OpenBSD.
429 ** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
432 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
433 # define _XOPEN_SOURCE 600
437 ** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that
438 ** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,
439 ** make it true by defining or undefining NDEBUG.
441 ** Setting NDEBUG makes the code smaller and faster by disabling the
442 ** assert() statements in the code. So we want the default action
443 ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
444 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
447 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
450 #if defined(NDEBUG) && defined(SQLITE_DEBUG)
455 ** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
457 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
458 # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
462 ** The testcase() macro is used to aid in coverage testing. When
463 ** doing coverage testing, the condition inside the argument to
464 ** testcase() must be evaluated both true and false in order to
465 ** get full branch coverage. The testcase() macro is inserted
466 ** to help ensure adequate test coverage in places where simple
467 ** condition/decision coverage is inadequate. For example, testcase()
468 ** can be used to make sure boundary values are tested. For
469 ** bitmask tests, testcase() can be used to make sure each bit
470 ** is significant and used at least once. On switch statements
471 ** where multiple cases go to the same block of code, testcase()
472 ** can insure that all cases are evaluated.
474 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
475 # ifndef SQLITE_AMALGAMATION
476 extern unsigned int sqlite3CoverageCounter
;
478 # define testcase(X) if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; }
484 ** The TESTONLY macro is used to enclose variable declarations or
485 ** other bits of code that are needed to support the arguments
486 ** within testcase() and assert() macros.
488 #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
489 # define TESTONLY(X) X
495 ** Sometimes we need a small amount of code such as a variable initialization
496 ** to setup for a later assert() statement. We do not want this code to
497 ** appear when assert() is disabled. The following macro is therefore
498 ** used to contain that setup code. The "VVA" acronym stands for
499 ** "Verification, Validation, and Accreditation". In other words, the
500 ** code within VVA_ONLY() will only run during verification processes.
503 # define VVA_ONLY(X) X
509 ** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage
510 ** and mutation testing
512 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
513 # define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
517 ** The ALWAYS and NEVER macros surround boolean expressions which
518 ** are intended to always be true or false, respectively. Such
519 ** expressions could be omitted from the code completely. But they
520 ** are included in a few cases in order to enhance the resilience
521 ** of SQLite to unexpected behavior - to make the code "self-healing"
522 ** or "ductile" rather than being "brittle" and crashing at the first
523 ** hint of unplanned behavior.
525 ** In other words, ALWAYS and NEVER are added for defensive code.
527 ** When doing coverage testing ALWAYS and NEVER are hard-coded to
528 ** be true and false so that the unreachable code they specify will
529 ** not be counted as untested code.
531 #if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
532 # define ALWAYS(X) (1)
533 # define NEVER(X) (0)
534 #elif !defined(NDEBUG)
535 # define ALWAYS(X) ((X)?1:(assert(0),0))
536 # define NEVER(X) ((X)?(assert(0),1):0)
538 # define ALWAYS(X) (X)
539 # define NEVER(X) (X)
543 ** Some conditionals are optimizations only. In other words, if the
544 ** conditionals are replaced with a constant 1 (true) or 0 (false) then
545 ** the correct answer is still obtained, though perhaps not as quickly.
547 ** The following macros mark these optimizations conditionals.
549 #if defined(SQLITE_MUTATION_TEST)
550 # define OK_IF_ALWAYS_TRUE(X) (1)
551 # define OK_IF_ALWAYS_FALSE(X) (0)
553 # define OK_IF_ALWAYS_TRUE(X) (X)
554 # define OK_IF_ALWAYS_FALSE(X) (X)
558 ** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
559 ** defined. We need to defend against those failures when testing with
560 ** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
561 ** during a normal build. The following macro can be used to disable tests
562 ** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
564 #if defined(SQLITE_TEST_REALLOC_STRESS)
565 # define ONLY_IF_REALLOC_STRESS(X) (X)
566 #elif !defined(NDEBUG)
567 # define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)
569 # define ONLY_IF_REALLOC_STRESS(X) (0)
573 ** Declarations used for tracing the operating system interfaces.
575 #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \
576 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
577 extern int sqlite3OSTrace
;
578 # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
579 # define SQLITE_HAVE_OS_TRACE
582 # undef SQLITE_HAVE_OS_TRACE
586 ** Is the sqlite3ErrName() function needed in the build? Currently,
587 ** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when
588 ** OSTRACE is enabled), and by several "test*.c" files (which are
589 ** compiled using SQLITE_TEST).
591 #if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \
592 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
593 # define SQLITE_NEED_ERR_NAME
595 # undef SQLITE_NEED_ERR_NAME
599 ** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN
601 #ifdef SQLITE_OMIT_EXPLAIN
602 # undef SQLITE_ENABLE_EXPLAIN_COMMENTS
606 ** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE
608 #if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE)
609 # define SQLITE_OMIT_ALTERTABLE
612 #define SQLITE_DIGIT_SEPARATOR '_'
615 ** Return true (non-zero) if the input is an integer that is too large
616 ** to fit in 32-bits. This macro is used inside of various testcase()
617 ** macros to verify that we have tested SQLite for large-file support.
619 #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
622 ** The macro unlikely() is a hint that surrounds a boolean
623 ** expression that is usually false. Macro likely() surrounds
624 ** a boolean expression that is usually true. These hints could,
625 ** in theory, be used by the compiler to generate better code, but
626 ** currently they are just comments for human readers.
628 #define likely(X) (X)
629 #define unlikely(X) (X)
640 ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
641 ** This allows better measurements of where memcpy() is used when running
642 ** cachegrind. But this macro version of memcpy() is very slow so it
643 ** should not be used in production. This is a performance measurement
646 #ifdef SQLITE_INLINE_MEMCPY
647 # define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
648 int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
652 ** If compiling for a processor that lacks floating point support,
653 ** substitute integer for floating-point
655 #ifdef SQLITE_OMIT_FLOATING_POINT
656 # define double sqlite_int64
657 # define float sqlite_int64
658 # define LONGDOUBLE_TYPE sqlite_int64
659 # ifndef SQLITE_BIG_DBL
660 # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
662 # define SQLITE_OMIT_DATETIME_FUNCS 1
663 # define SQLITE_OMIT_TRACE 1
664 # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
665 # undef SQLITE_HAVE_ISNAN
667 #ifndef SQLITE_BIG_DBL
668 # define SQLITE_BIG_DBL (1e99)
672 ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
673 ** afterward. Having this macro allows us to cause the C compiler
674 ** to omit code used by TEMP tables without messy #ifndef statements.
676 #ifdef SQLITE_OMIT_TEMPDB
677 #define OMIT_TEMPDB 1
679 #define OMIT_TEMPDB 0
683 ** The "file format" number is an integer that is incremented whenever
684 ** the VDBE-level file format changes. The following macros define the
685 ** the default file format for new databases and the maximum file format
686 ** that the library can read.
688 #define SQLITE_MAX_FILE_FORMAT 4
689 #ifndef SQLITE_DEFAULT_FILE_FORMAT
690 # define SQLITE_DEFAULT_FILE_FORMAT 4
694 ** Determine whether triggers are recursive by default. This can be
695 ** changed at run-time using a pragma.
697 #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
698 # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
702 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
703 ** on the command-line
705 #ifndef SQLITE_TEMP_STORE
706 # define SQLITE_TEMP_STORE 1
710 ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
711 ** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
714 #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
715 # undef SQLITE_MAX_WORKER_THREADS
716 # define SQLITE_MAX_WORKER_THREADS 0
718 #ifndef SQLITE_MAX_WORKER_THREADS
719 # define SQLITE_MAX_WORKER_THREADS 8
721 #ifndef SQLITE_DEFAULT_WORKER_THREADS
722 # define SQLITE_DEFAULT_WORKER_THREADS 0
724 #if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS
725 # undef SQLITE_MAX_WORKER_THREADS
726 # define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS
730 ** The default initial allocation for the pagecache when using separate
731 ** pagecaches for each database connection. A positive number is the
732 ** number of pages. A negative number N translations means that a buffer
733 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
735 ** The default value of "20" was chosen to minimize the run-time of the
736 ** speedtest1 test program with options: --shrink-memory --reprepare
738 #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
739 # define SQLITE_DEFAULT_PCACHE_INITSZ 20
743 ** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.
745 #ifndef SQLITE_DEFAULT_SORTERREF_SIZE
746 # define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff
750 ** The compile-time options SQLITE_MMAP_READWRITE and
751 ** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.
752 ** You must choose one or the other (or neither) but not both.
754 #if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
755 #error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE
759 ** GCC does not define the offsetof() macro so we'll have to do it
763 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
767 ** Macros to compute minimum and maximum of two numbers.
770 # define MIN(A,B) ((A)<(B)?(A):(B))
773 # define MAX(A,B) ((A)>(B)?(A):(B))
777 ** Swap two objects of type TYPE.
779 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
782 ** Check to see if this machine uses EBCDIC. (Yes, believe it or
783 ** not, there are still machines out there that use EBCDIC.)
786 # define SQLITE_EBCDIC 1
788 # define SQLITE_ASCII 1
792 ** Integers of known sizes. These typedefs might change for architectures
793 ** where the sizes very. Preprocessor macros are available so that the
794 ** types can be conveniently redefined at compile-type. Like this:
796 ** cc '-DUINTPTR_TYPE=long long int' ...
799 # ifdef HAVE_UINT32_T
800 # define UINT32_TYPE uint32_t
802 # define UINT32_TYPE unsigned int
806 # ifdef HAVE_UINT16_T
807 # define UINT16_TYPE uint16_t
809 # define UINT16_TYPE unsigned short int
814 # define INT16_TYPE int16_t
816 # define INT16_TYPE short int
821 # define UINT8_TYPE uint8_t
823 # define UINT8_TYPE unsigned char
828 # define INT8_TYPE int8_t
830 # define INT8_TYPE signed char
833 #ifndef LONGDOUBLE_TYPE
834 # define LONGDOUBLE_TYPE long double
836 typedef sqlite_int64 i64
; /* 8-byte signed integer */
837 typedef sqlite_uint64 u64
; /* 8-byte unsigned integer */
838 typedef UINT32_TYPE u32
; /* 4-byte unsigned integer */
839 typedef UINT16_TYPE u16
; /* 2-byte unsigned integer */
840 typedef INT16_TYPE i16
; /* 2-byte signed integer */
841 typedef UINT8_TYPE u8
; /* 1-byte unsigned integer */
842 typedef INT8_TYPE i8
; /* 1-byte signed integer */
845 ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
846 ** that can be stored in a u32 without loss of data. The value
847 ** is 0x00000000ffffffff. But because of quirks of some compilers, we
848 ** have to specify the value in the less intuitive manner shown:
850 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
853 ** The datatype used to store estimates of the number of rows in a
859 ** Estimated quantities used for query planning are stored as 16-bit
860 ** logarithms. For quantity X, the value stored is 10*log2(X). This
861 ** gives a possible range of values of approximately 1.0e986 to 1e-986.
862 ** But the allowed values are "grainy". Not every value is representable.
863 ** For example, quantities 16 and 17 are both represented by a LogEst
864 ** of 40. However, since LogEst quantities are suppose to be estimates,
865 ** not exact values, this imprecision is not a problem.
867 ** "LogEst" is short for "Logarithmic Estimate".
870 ** 1 -> 0 20 -> 43 10000 -> 132
871 ** 2 -> 10 25 -> 46 25000 -> 146
872 ** 3 -> 16 100 -> 66 1000000 -> 199
873 ** 4 -> 20 1000 -> 99 1048576 -> 200
874 ** 10 -> 33 1024 -> 100 4294967296 -> 320
876 ** The LogEst can be negative to indicate fractional values.
879 ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
881 typedef INT16_TYPE LogEst
;
884 ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
886 #ifndef SQLITE_PTRSIZE
887 # if defined(__SIZEOF_POINTER__)
888 # define SQLITE_PTRSIZE __SIZEOF_POINTER__
889 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
890 defined(_M_ARM) || defined(__arm__) || defined(__x86) || \
891 (defined(__APPLE__) && defined(__POWERPC__)) || \
892 (defined(__TOS_AIX__) && !defined(__64BIT__))
893 # define SQLITE_PTRSIZE 4
895 # define SQLITE_PTRSIZE 8
899 /* The uptr type is an unsigned integer large enough to hold a pointer
901 #if defined(HAVE_STDINT_H)
902 typedef uintptr_t uptr
;
903 #elif SQLITE_PTRSIZE==4
910 ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
911 ** something between S (inclusive) and E (exclusive).
913 ** In other words, S is a buffer and E is a pointer to the first byte after
914 ** the end of buffer S. This macro returns true if P points to something
915 ** contained within the buffer S.
917 #define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
920 ** P is one byte past the end of a large buffer. Return true if a span of bytes
921 ** between S..E crosses the end of that buffer. In other words, return true
922 ** if the sub-buffer S..E-1 overflows the buffer whose last byte is P-1.
924 ** S is the start of the span. E is one byte past the end of end of span.
927 ** |-----------------| FALSE
932 ** |-----------------|
937 ** |-----------------|
941 #define SQLITE_OVERFLOW(P,S,E) (((uptr)(S)<(uptr)(P))&&((uptr)(E)>(uptr)(P)))
944 ** Macros to determine whether the machine is big or little endian,
945 ** and whether or not that determination is run-time or compile-time.
947 ** For best performance, an attempt is made to guess at the byte-order
948 ** using C-preprocessor macros. If that is unsuccessful, or if
949 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
952 ** If you are building SQLite on some obscure platform for which the
953 ** following ifdef magic does not work, you can always include either:
955 ** -DSQLITE_BYTEORDER=1234
959 ** -DSQLITE_BYTEORDER=4321
961 ** to cause the build to work for little-endian or big-endian processors,
964 #ifndef SQLITE_BYTEORDER /* Replicate changes at tag-20230904a */
965 # if defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
966 # define SQLITE_BYTEORDER 4321
967 # elif defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
968 # define SQLITE_BYTEORDER 1234
969 # elif defined(__BIG_ENDIAN__) && __BIG_ENDIAN__==1
970 # define SQLITE_BYTEORDER 4321
971 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
972 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
973 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
974 defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64)
975 # define SQLITE_BYTEORDER 1234
976 # elif defined(sparc) || defined(__ARMEB__) || defined(__AARCH64EB__)
977 # define SQLITE_BYTEORDER 4321
979 # define SQLITE_BYTEORDER 0
982 #if SQLITE_BYTEORDER==4321
983 # define SQLITE_BIGENDIAN 1
984 # define SQLITE_LITTLEENDIAN 0
985 # define SQLITE_UTF16NATIVE SQLITE_UTF16BE
986 #elif SQLITE_BYTEORDER==1234
987 # define SQLITE_BIGENDIAN 0
988 # define SQLITE_LITTLEENDIAN 1
989 # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
991 # ifdef SQLITE_AMALGAMATION
992 const int sqlite3one
= 1;
994 extern const int sqlite3one
;
996 # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
997 # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
998 # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
1002 ** Constants for the largest and smallest possible 64-bit signed integers.
1003 ** These macros are designed to work correctly on both 32-bit and 64-bit
1006 #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
1007 #define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32))
1008 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
1011 ** Round up a number to the next larger multiple of 8. This is used
1012 ** to force 8-byte alignment on 64-bit architectures.
1014 ** ROUND8() always does the rounding, for any argument.
1016 ** ROUND8P() assumes that the argument is already an integer number of
1017 ** pointers in size, and so it is a no-op on systems where the pointer
1020 #define ROUND8(x) (((x)+7)&~7)
1021 #if SQLITE_PTRSIZE==8
1022 # define ROUND8P(x) (x)
1024 # define ROUND8P(x) (((x)+7)&~7)
1028 ** Round down to the nearest multiple of 8
1030 #define ROUNDDOWN8(x) ((x)&~7)
1033 ** Assert that the pointer X is aligned to an 8-byte boundary. This
1034 ** macro is used only within assert() to verify that the code gets
1035 ** all alignment restrictions correct.
1037 ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
1038 ** underlying malloc() implementation might return us 4-byte aligned
1039 ** pointers. In that case, only verify 4-byte alignment.
1041 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
1042 # define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&3)==0)
1044 # define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&7)==0)
1048 ** Disable MMAP on platforms where it is known to not work
1050 #if defined(__OpenBSD__) || defined(__QNXNTO__)
1051 # undef SQLITE_MAX_MMAP_SIZE
1052 # define SQLITE_MAX_MMAP_SIZE 0
1056 ** Default maximum size of memory used by memory-mapped I/O in the VFS
1059 # include <TargetConditionals.h>
1061 #ifndef SQLITE_MAX_MMAP_SIZE
1062 # if defined(__linux__) \
1063 || defined(_WIN32) \
1064 || (defined(__APPLE__) && defined(__MACH__)) \
1066 || defined(__FreeBSD__) \
1067 || defined(__DragonFly__)
1068 # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */
1070 # define SQLITE_MAX_MMAP_SIZE 0
1075 ** The default MMAP_SIZE is zero on all platforms. Or, even if a larger
1076 ** default MMAP_SIZE is specified at compile-time, make sure that it does
1077 ** not exceed the maximum mmap size.
1079 #ifndef SQLITE_DEFAULT_MMAP_SIZE
1080 # define SQLITE_DEFAULT_MMAP_SIZE 0
1082 #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
1083 # undef SQLITE_DEFAULT_MMAP_SIZE
1084 # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
1088 ** TREETRACE_ENABLED will be either 1 or 0 depending on whether or not
1089 ** the Abstract Syntax Tree tracing logic is turned on.
1091 #if !defined(SQLITE_AMALGAMATION)
1092 extern u32 sqlite3TreeTrace
;
1094 #if defined(SQLITE_DEBUG) \
1095 && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE) \
1096 || defined(SQLITE_ENABLE_TREETRACE))
1097 # define TREETRACE_ENABLED 1
1098 # define TREETRACE(K,P,S,X) \
1099 if(sqlite3TreeTrace&(K)) \
1100 sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
1101 sqlite3DebugPrintf X
1103 # define TREETRACE(K,P,S,X)
1104 # define TREETRACE_ENABLED 0
1107 /* TREETRACE flag meanings:
1109 ** 0x00000001 Beginning and end of SELECT processing
1110 ** 0x00000002 WHERE clause processing
1111 ** 0x00000004 Query flattener
1112 ** 0x00000008 Result-set wildcard expansion
1113 ** 0x00000010 Query name resolution
1114 ** 0x00000020 Aggregate analysis
1115 ** 0x00000040 Window functions
1116 ** 0x00000080 Generated column names
1117 ** 0x00000100 Move HAVING terms into WHERE
1118 ** 0x00000200 Count-of-view optimization
1119 ** 0x00000400 Compound SELECT processing
1120 ** 0x00000800 Drop superfluous ORDER BY
1121 ** 0x00001000 LEFT JOIN simplifies to JOIN
1122 ** 0x00002000 Constant propagation
1123 ** 0x00004000 Push-down optimization
1124 ** 0x00008000 After all FROM-clause analysis
1125 ** 0x00010000 Beginning of DELETE/INSERT/UPDATE processing
1126 ** 0x00020000 Transform DISTINCT into GROUP BY
1127 ** 0x00040000 SELECT tree dump after all code has been generated
1131 ** Macros for "wheretrace"
1133 extern u32 sqlite3WhereTrace
;
1134 #if defined(SQLITE_DEBUG) \
1135 && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE))
1136 # define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X
1137 # define WHERETRACE_ENABLED 1
1139 # define WHERETRACE(K,X)
1143 ** Bits for the sqlite3WhereTrace mask:
1145 ** (---any--) Top-level block structure
1146 ** 0x-------F High-level debug messages
1147 ** 0x----FFF- More detail
1148 ** 0xFFFF---- Low-level debug messages
1150 ** 0x00000001 Code generation
1151 ** 0x00000002 Solver
1152 ** 0x00000004 Solver costs
1153 ** 0x00000008 WhereLoop inserts
1155 ** 0x00000010 Display sqlite3_index_info xBestIndex calls
1156 ** 0x00000020 Range an equality scan metrics
1157 ** 0x00000040 IN operator decisions
1158 ** 0x00000080 WhereLoop cost adjustements
1160 ** 0x00000200 Covering index decisions
1161 ** 0x00000400 OR optimization
1162 ** 0x00000800 Index scanner
1163 ** 0x00001000 More details associated with code generation
1165 ** 0x00004000 Show all WHERE terms at key points
1166 ** 0x00008000 Show the full SELECT statement at key places
1168 ** 0x00010000 Show more detail when printing WHERE terms
1169 ** 0x00020000 Show WHERE terms returned from whereScanNext()
1174 ** An instance of the following structure is used to store the busy-handler
1175 ** callback for a given sqlite handle.
1177 ** The sqlite.busyHandler member of the sqlite struct contains the busy
1178 ** callback for the database handle. Each pager opened via the sqlite
1179 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
1180 ** callback is currently invoked only from within pager.c.
1182 typedef struct BusyHandler BusyHandler
;
1183 struct BusyHandler
{
1184 int (*xBusyHandler
)(void *,int); /* The busy callback */
1185 void *pBusyArg
; /* First arg to busy callback */
1186 int nBusy
; /* Incremented with each busy call */
1190 ** Name of table that holds the database schema.
1192 ** The PREFERRED names are used wherever possible. But LEGACY is also
1193 ** used for backwards compatibility.
1195 ** 1. Queries can use either the PREFERRED or the LEGACY names
1196 ** 2. The sqlite3_set_authorizer() callback uses the LEGACY name
1197 ** 3. The PRAGMA table_list statement uses the PREFERRED name
1199 ** The LEGACY names are stored in the internal symbol hash table
1200 ** in support of (2). Names are translated using sqlite3PreferredTableName()
1201 ** for (3). The sqlite3FindTable() function takes care of translating
1204 ** Note that "sqlite_temp_schema" can also be called "temp.sqlite_schema".
1206 #define LEGACY_SCHEMA_TABLE "sqlite_master"
1207 #define LEGACY_TEMP_SCHEMA_TABLE "sqlite_temp_master"
1208 #define PREFERRED_SCHEMA_TABLE "sqlite_schema"
1209 #define PREFERRED_TEMP_SCHEMA_TABLE "sqlite_temp_schema"
1213 ** The root-page of the schema table.
1215 #define SCHEMA_ROOT 1
1218 ** The name of the schema table. The name is different for TEMP.
1220 #define SCHEMA_TABLE(x) \
1221 ((!OMIT_TEMPDB)&&(x==1)?LEGACY_TEMP_SCHEMA_TABLE:LEGACY_SCHEMA_TABLE)
1224 ** A convenience macro that returns the number of elements in
1227 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
1230 ** Determine if the argument is a power of two
1232 #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
1235 ** The following value as a destructor means to use sqlite3DbFree().
1236 ** The sqlite3DbFree() routine requires two parameters instead of the
1237 ** one parameter that destructors normally want. So we have to introduce
1238 ** this magic value that the code knows to handle differently. Any
1239 ** pointer will work here as long as it is distinct from SQLITE_STATIC
1240 ** and SQLITE_TRANSIENT.
1242 #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3OomClear)
1245 ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
1246 ** not support Writable Static Data (WSD) such as global and static variables.
1247 ** All variables must either be on the stack or dynamically allocated from
1248 ** the heap. When WSD is unsupported, the variable declarations scattered
1249 ** throughout the SQLite code must become constants instead. The SQLITE_WSD
1250 ** macro is used for this purpose. And instead of referencing the variable
1251 ** directly, we use its constant as a key to lookup the run-time allocated
1252 ** buffer that holds real variable. The constant is also the initializer
1253 ** for the run-time allocated buffer.
1255 ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
1256 ** macros become no-ops and have zero performance impact.
1258 #ifdef SQLITE_OMIT_WSD
1259 #define SQLITE_WSD const
1260 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
1261 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
1262 int sqlite3_wsd_init(int N
, int J
);
1263 void *sqlite3_wsd_find(void *K
, int L
);
1266 #define GLOBAL(t,v) v
1267 #define sqlite3GlobalConfig sqlite3Config
1271 ** The following macros are used to suppress compiler warnings and to
1272 ** make it clear to human readers when a function parameter is deliberately
1273 ** left unused within the body of a function. This usually happens when
1274 ** a function is called via a function pointer. For example the
1275 ** implementation of an SQL aggregate step callback may not use the
1276 ** parameter indicating the number of arguments passed to the aggregate,
1277 ** if it knows that this is enforced elsewhere.
1279 ** When a function parameter is not used at all within the body of a function,
1280 ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
1281 ** However, these macros may also be used to suppress warnings related to
1282 ** parameters that may or may not be used depending on compilation options.
1283 ** For example those parameters only used in assert() statements. In these
1284 ** cases the parameters are named as per the usual conventions.
1286 #define UNUSED_PARAMETER(x) (void)(x)
1287 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
1290 ** Forward references to structures
1292 typedef struct AggInfo AggInfo
;
1293 typedef struct AuthContext AuthContext
;
1294 typedef struct AutoincInfo AutoincInfo
;
1295 typedef struct Bitvec Bitvec
;
1296 typedef struct CollSeq CollSeq
;
1297 typedef struct Column Column
;
1298 typedef struct Cte Cte
;
1299 typedef struct CteUse CteUse
;
1300 typedef struct Db Db
;
1301 typedef struct DbClientData DbClientData
;
1302 typedef struct DbFixer DbFixer
;
1303 typedef struct Schema Schema
;
1304 typedef struct Expr Expr
;
1305 typedef struct ExprList ExprList
;
1306 typedef struct FKey FKey
;
1307 typedef struct FpDecode FpDecode
;
1308 typedef struct FuncDestructor FuncDestructor
;
1309 typedef struct FuncDef FuncDef
;
1310 typedef struct FuncDefHash FuncDefHash
;
1311 typedef struct IdList IdList
;
1312 typedef struct Index Index
;
1313 typedef struct IndexedExpr IndexedExpr
;
1314 typedef struct IndexSample IndexSample
;
1315 typedef struct KeyClass KeyClass
;
1316 typedef struct KeyInfo KeyInfo
;
1317 typedef struct Lookaside Lookaside
;
1318 typedef struct LookasideSlot LookasideSlot
;
1319 typedef struct Module Module
;
1320 typedef struct NameContext NameContext
;
1321 typedef struct OnOrUsing OnOrUsing
;
1322 typedef struct Parse Parse
;
1323 typedef struct ParseCleanup ParseCleanup
;
1324 typedef struct PreUpdate PreUpdate
;
1325 typedef struct PrintfArguments PrintfArguments
;
1326 typedef struct RCStr RCStr
;
1327 typedef struct RenameToken RenameToken
;
1328 typedef struct Returning Returning
;
1329 typedef struct RowSet RowSet
;
1330 typedef struct Savepoint Savepoint
;
1331 typedef struct Select Select
;
1332 typedef struct SQLiteThread SQLiteThread
;
1333 typedef struct SelectDest SelectDest
;
1334 typedef struct SrcItem SrcItem
;
1335 typedef struct SrcList SrcList
;
1336 typedef struct sqlite3_str StrAccum
; /* Internal alias for sqlite3_str */
1337 typedef struct Table Table
;
1338 typedef struct TableLock TableLock
;
1339 typedef struct Token Token
;
1340 typedef struct TreeView TreeView
;
1341 typedef struct Trigger Trigger
;
1342 typedef struct TriggerPrg TriggerPrg
;
1343 typedef struct TriggerStep TriggerStep
;
1344 typedef struct UnpackedRecord UnpackedRecord
;
1345 typedef struct Upsert Upsert
;
1346 typedef struct VTable VTable
;
1347 typedef struct VtabCtx VtabCtx
;
1348 typedef struct Walker Walker
;
1349 typedef struct WhereInfo WhereInfo
;
1350 typedef struct Window Window
;
1351 typedef struct With With
;
1355 ** The bitmask datatype defined below is used for various optimizations.
1357 ** Changing this from a 64-bit to a 32-bit type limits the number of
1358 ** tables in a join to 32 instead of 64. But it also reduces the size
1359 ** of the library by 738 bytes on ix86.
1361 #ifdef SQLITE_BITMASK_TYPE
1362 typedef SQLITE_BITMASK_TYPE Bitmask
;
1364 typedef u64 Bitmask
;
1368 ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
1370 #define BMS ((int)(sizeof(Bitmask)*8))
1373 ** A bit in a Bitmask
1375 #define MASKBIT(n) (((Bitmask)1)<<(n))
1376 #define MASKBIT64(n) (((u64)1)<<(n))
1377 #define MASKBIT32(n) (((unsigned int)1)<<(n))
1378 #define SMASKBIT32(n) ((n)<=31?((unsigned int)1)<<(n):0)
1379 #define ALLBITS ((Bitmask)-1)
1380 #define TOPBIT (((Bitmask)1)<<(BMS-1))
1382 /* A VList object records a mapping between parameters/variables/wildcards
1383 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
1384 ** variable number associated with that parameter. See the format description
1385 ** on the sqlite3VListAdd() routine for more information. A VList is really
1386 ** just an array of integers.
1391 ** Defer sourcing vdbe.h and btree.h until after the "u8" and
1392 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
1393 ** pointer types (i.e. FuncDef) defined above.
1402 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
1403 ** synchronous setting to EXTRA. It is no longer supported.
1405 #ifdef SQLITE_EXTRA_DURABLE
1406 # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
1407 # define SQLITE_DEFAULT_SYNCHRONOUS 3
1411 ** Default synchronous levels.
1413 ** Note that (for historical reasons) the PAGER_SYNCHRONOUS_* macros differ
1414 ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
1416 ** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS
1422 ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
1423 ** In other words, the zero-based numbers are used for all external interfaces
1424 ** and the one-based values are used internally.
1426 #ifndef SQLITE_DEFAULT_SYNCHRONOUS
1427 # define SQLITE_DEFAULT_SYNCHRONOUS 2
1429 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
1430 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
1434 ** Each database file to be accessed by the system is an instance
1435 ** of the following structure. There are normally two of these structures
1436 ** in the sqlite.aDb[] array. aDb[0] is the main database file and
1437 ** aDb[1] is the database file used to hold temporary tables. Additional
1438 ** databases may be attached.
1441 char *zDbSName
; /* Name of this database. (schema name, not filename) */
1442 Btree
*pBt
; /* The B*Tree structure for this database file */
1443 u8 safety_level
; /* How aggressive at syncing data to disk */
1444 u8 bSyncSet
; /* True if "PRAGMA synchronous=N" has been run */
1445 Schema
*pSchema
; /* Pointer to database schema (possibly shared) */
1449 ** An instance of the following structure stores a database schema.
1451 ** Most Schema objects are associated with a Btree. The exception is
1452 ** the Schema for the TEMP database (sqlite3.aDb[1]) which is free-standing.
1453 ** In shared cache mode, a single Schema object can be shared by multiple
1454 ** Btrees that refer to the same underlying BtShared object.
1456 ** Schema objects are automatically deallocated when the last Btree that
1457 ** references them is destroyed. The TEMP Schema is manually freed by
1460 ** A thread must be holding a mutex on the corresponding Btree in order
1461 ** to access Schema content. This implies that the thread must also be
1462 ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
1463 ** For a TEMP Schema, only the connection mutex is required.
1466 int schema_cookie
; /* Database schema version number for this file */
1467 int iGeneration
; /* Generation counter. Incremented with each change */
1468 Hash tblHash
; /* All tables indexed by name */
1469 Hash idxHash
; /* All (named) indices indexed by name */
1470 Hash trigHash
; /* All triggers indexed by name */
1471 Hash fkeyHash
; /* All foreign keys by referenced table name */
1472 Table
*pSeqTab
; /* The sqlite_sequence table used by AUTOINCREMENT */
1473 u8 file_format
; /* Schema format version for this file */
1474 u8 enc
; /* Text encoding used by this database */
1475 u16 schemaFlags
; /* Flags associated with this schema */
1476 int cache_size
; /* Number of pages to use in the cache */
1480 ** These macros can be used to test, set, or clear bits in the
1481 ** Db.pSchema->flags field.
1483 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
1484 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
1485 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
1486 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
1489 ** Allowed values for the DB.pSchema->flags field.
1491 ** The DB_SchemaLoaded flag is set after the database schema has been
1492 ** read into internal hash tables.
1494 ** DB_UnresetViews means that one or more views have column names that
1495 ** have been filled out. If the schema changes, these column names might
1496 ** changes and so the view will need to be reset.
1498 #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
1499 #define DB_UnresetViews 0x0002 /* Some views have defined column names */
1500 #define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */
1503 ** The number of different kinds of things that can be limited
1504 ** using the sqlite3_limit() interface.
1506 #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
1509 ** Lookaside malloc is a set of fixed-size buffers that can be used
1510 ** to satisfy small transient memory allocation requests for objects
1511 ** associated with a particular database connection. The use of
1512 ** lookaside malloc provides a significant performance enhancement
1513 ** (approx 10%) by avoiding numerous malloc/free requests while parsing
1516 ** The Lookaside structure holds configuration information about the
1517 ** lookaside malloc subsystem. Each available memory allocation in
1518 ** the lookaside subsystem is stored on a linked list of LookasideSlot
1521 ** Lookaside allocations are only allowed for objects that are associated
1522 ** with a particular database connection. Hence, schema information cannot
1523 ** be stored in lookaside because in shared cache mode the schema information
1524 ** is shared by multiple database connections. Therefore, while parsing
1525 ** schema information, the Lookaside.bEnabled flag is cleared so that
1526 ** lookaside allocations are not used to construct the schema objects.
1528 ** New lookaside allocations are only allowed if bDisable==0. When
1529 ** bDisable is greater than zero, sz is set to zero which effectively
1530 ** disables lookaside without adding a new test for the bDisable flag
1531 ** in a performance-critical path. sz should be set by to szTrue whenever
1532 ** bDisable changes back to zero.
1534 ** Lookaside buffers are initially held on the pInit list. As they are
1535 ** used and freed, they are added back to the pFree list. New allocations
1536 ** come off of pFree first, then pInit as a fallback. This dual-list
1537 ** allows use to compute a high-water mark - the maximum number of allocations
1538 ** outstanding at any point in the past - by subtracting the number of
1539 ** allocations on the pInit list from the total number of allocations.
1541 ** Enhancement on 2019-12-12: Two-size-lookaside
1542 ** The default lookaside configuration is 100 slots of 1200 bytes each.
1543 ** The larger slot sizes are important for performance, but they waste
1544 ** a lot of space, as most lookaside allocations are less than 128 bytes.
1545 ** The two-size-lookaside enhancement breaks up the lookaside allocation
1546 ** into two pools: One of 128-byte slots and the other of the default size
1547 ** (1200-byte) slots. Allocations are filled from the small-pool first,
1548 ** failing over to the full-size pool if that does not work. Thus more
1549 ** lookaside slots are available while also using less memory.
1550 ** This enhancement can be omitted by compiling with
1551 ** SQLITE_OMIT_TWOSIZE_LOOKASIDE.
1554 u32 bDisable
; /* Only operate the lookaside when zero */
1555 u16 sz
; /* Size of each buffer in bytes */
1556 u16 szTrue
; /* True value of sz, even if disabled */
1557 u8 bMalloced
; /* True if pStart obtained from sqlite3_malloc() */
1558 u32 nSlot
; /* Number of lookaside slots allocated */
1559 u32 anStat
[3]; /* 0: hits. 1: size misses. 2: full misses */
1560 LookasideSlot
*pInit
; /* List of buffers not previously used */
1561 LookasideSlot
*pFree
; /* List of available buffers */
1562 #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
1563 LookasideSlot
*pSmallInit
; /* List of small buffers not previously used */
1564 LookasideSlot
*pSmallFree
; /* List of available small buffers */
1565 void *pMiddle
; /* First byte past end of full-size buffers and
1566 ** the first byte of LOOKASIDE_SMALL buffers */
1567 #endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
1568 void *pStart
; /* First byte of available memory space */
1569 void *pEnd
; /* First byte past end of available space */
1570 void *pTrueEnd
; /* True value of pEnd, when db->pnBytesFreed!=0 */
1572 struct LookasideSlot
{
1573 LookasideSlot
*pNext
; /* Next buffer in the list of free buffers */
1576 #define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0
1577 #define EnableLookaside db->lookaside.bDisable--;\
1578 db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue
1580 /* Size of the smaller allocations in two-size lookaside */
1581 #ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE
1582 # define LOOKASIDE_SMALL 0
1584 # define LOOKASIDE_SMALL 128
1588 ** A hash table for built-in function definitions. (Application-defined
1589 ** functions use a regular table table from hash.h.)
1591 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
1592 ** Collisions are on the FuncDef.u.pHash chain. Use the SQLITE_FUNC_HASH()
1593 ** macro to compute a hash on the function name.
1595 #define SQLITE_FUNC_HASH_SZ 23
1596 struct FuncDefHash
{
1597 FuncDef
*a
[SQLITE_FUNC_HASH_SZ
]; /* Hash table for functions */
1599 #define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ)
1601 #ifdef SQLITE_USER_AUTHENTICATION
1603 ** Information held in the "sqlite3" database connection object and used
1604 ** to manage user authentication.
1606 typedef struct sqlite3_userauth sqlite3_userauth
;
1607 struct sqlite3_userauth
{
1608 u8 authLevel
; /* Current authentication level */
1609 int nAuthPW
; /* Size of the zAuthPW in bytes */
1610 char *zAuthPW
; /* Password used to authenticate */
1611 char *zAuthUser
; /* User name used to authenticate */
1614 /* Allowed values for sqlite3_userauth.authLevel */
1615 #define UAUTH_Unknown 0 /* Authentication not yet checked */
1616 #define UAUTH_Fail 1 /* User authentication failed */
1617 #define UAUTH_User 2 /* Authenticated as a normal user */
1618 #define UAUTH_Admin 3 /* Authenticated as an administrator */
1620 /* Functions used only by user authorization logic */
1621 int sqlite3UserAuthTable(const char*);
1622 int sqlite3UserAuthCheckLogin(sqlite3
*,const char*,u8
*);
1623 void sqlite3UserAuthInit(sqlite3
*);
1624 void sqlite3CryptFunc(sqlite3_context
*,int,sqlite3_value
**);
1626 #endif /* SQLITE_USER_AUTHENTICATION */
1629 ** typedef for the authorization callback function.
1631 #ifdef SQLITE_USER_AUTHENTICATION
1632 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1633 const char*, const char*);
1635 typedef int (*sqlite3_xauth
)(void*,int,const char*,const char*,const char*,
1639 #ifndef SQLITE_OMIT_DEPRECATED
1640 /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
1641 ** in the style of sqlite3_trace()
1643 #define SQLITE_TRACE_LEGACY 0x40 /* Use the legacy xTrace */
1644 #define SQLITE_TRACE_XPROFILE 0x80 /* Use the legacy xProfile */
1646 #define SQLITE_TRACE_LEGACY 0
1647 #define SQLITE_TRACE_XPROFILE 0
1648 #endif /* SQLITE_OMIT_DEPRECATED */
1649 #define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */
1652 ** Maximum number of sqlite3.aDb[] entries. This is the number of attached
1653 ** databases plus 2 for "main" and "temp".
1655 #define SQLITE_MAX_DB (SQLITE_MAX_ATTACHED+2)
1658 ** Each database connection is an instance of the following structure.
1661 sqlite3_vfs
*pVfs
; /* OS Interface */
1662 struct Vdbe
*pVdbe
; /* List of active virtual machines */
1663 CollSeq
*pDfltColl
; /* BINARY collseq for the database encoding */
1664 sqlite3_mutex
*mutex
; /* Connection mutex */
1665 Db
*aDb
; /* All backends */
1666 int nDb
; /* Number of backends currently in use */
1667 u32 mDbFlags
; /* flags recording internal state */
1668 u64 flags
; /* flags settable by pragmas. See below */
1669 i64 lastRowid
; /* ROWID of most recent insert (see above) */
1670 i64 szMmap
; /* Default mmap_size setting */
1671 u32 nSchemaLock
; /* Do not reset the schema when non-zero */
1672 unsigned int openFlags
; /* Flags passed to sqlite3_vfs.xOpen() */
1673 int errCode
; /* Most recent error code (SQLITE_*) */
1674 int errByteOffset
; /* Byte offset of error in SQL statement */
1675 int errMask
; /* & result codes with this before returning */
1676 int iSysErrno
; /* Errno value from last system error */
1677 u32 dbOptFlags
; /* Flags to enable/disable optimizations */
1678 u8 enc
; /* Text encoding */
1679 u8 autoCommit
; /* The auto-commit flag. */
1680 u8 temp_store
; /* 1: file 2: memory 0: default */
1681 u8 mallocFailed
; /* True if we have seen a malloc failure */
1682 u8 bBenignMalloc
; /* Do not require OOMs if true */
1683 u8 dfltLockMode
; /* Default locking-mode for attached dbs */
1684 signed char nextAutovac
; /* Autovac setting after VACUUM if >=0 */
1685 u8 suppressErr
; /* Do not issue error messages if true */
1686 u8 vtabOnConflict
; /* Value to return for s3_vtab_on_conflict() */
1687 u8 isTransactionSavepoint
; /* True if the outermost savepoint is a TS */
1688 u8 mTrace
; /* zero or more SQLITE_TRACE flags */
1689 u8 noSharedCache
; /* True if no shared-cache backends */
1690 u8 nSqlExec
; /* Number of pending OP_SqlExec opcodes */
1691 u8 eOpenState
; /* Current condition of the connection */
1692 int nextPagesize
; /* Pagesize after VACUUM if >0 */
1693 i64 nChange
; /* Value returned by sqlite3_changes() */
1694 i64 nTotalChange
; /* Value returned by sqlite3_total_changes() */
1695 int aLimit
[SQLITE_N_LIMIT
]; /* Limits */
1696 int nMaxSorterMmap
; /* Maximum size of regions mapped by sorter */
1697 struct sqlite3InitInfo
{ /* Information used during initialization */
1698 Pgno newTnum
; /* Rootpage of table being initialized */
1699 u8 iDb
; /* Which db file is being initialized */
1700 u8 busy
; /* TRUE if currently initializing */
1701 unsigned orphanTrigger
: 1; /* Last statement is orphaned TEMP trigger */
1702 unsigned imposterTable
: 1; /* Building an imposter table */
1703 unsigned reopenMemdb
: 1; /* ATTACH is really a reopen using MemDB */
1704 const char **azInit
; /* "type", "name", and "tbl_name" columns */
1706 int nVdbeActive
; /* Number of VDBEs currently running */
1707 int nVdbeRead
; /* Number of active VDBEs that read or write */
1708 int nVdbeWrite
; /* Number of active VDBEs that read and write */
1709 int nVdbeExec
; /* Number of nested calls to VdbeExec() */
1710 int nVDestroy
; /* Number of active OP_VDestroy operations */
1711 int nExtension
; /* Number of loaded extensions */
1712 void **aExtension
; /* Array of shared library handles */
1714 void (*xLegacy
)(void*,const char*); /* mTrace==SQLITE_TRACE_LEGACY */
1715 int (*xV2
)(u32
,void*,void*,void*); /* All other mTrace values */
1717 void *pTraceArg
; /* Argument to the trace function */
1718 #ifndef SQLITE_OMIT_DEPRECATED
1719 void (*xProfile
)(void*,const char*,u64
); /* Profiling function */
1720 void *pProfileArg
; /* Argument to profile function */
1722 void *pCommitArg
; /* Argument to xCommitCallback() */
1723 int (*xCommitCallback
)(void*); /* Invoked at every commit. */
1724 void *pRollbackArg
; /* Argument to xRollbackCallback() */
1725 void (*xRollbackCallback
)(void*); /* Invoked at every commit. */
1727 void (*xUpdateCallback
)(void*,int, const char*,const char*,sqlite_int64
);
1728 void *pAutovacPagesArg
; /* Client argument to autovac_pages */
1729 void (*xAutovacDestr
)(void*); /* Destructor for pAutovacPAgesArg */
1730 unsigned int (*xAutovacPages
)(void*,const char*,u32
,u32
,u32
);
1731 Parse
*pParse
; /* Current parse */
1732 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1733 void *pPreUpdateArg
; /* First argument to xPreUpdateCallback */
1734 void (*xPreUpdateCallback
)( /* Registered using sqlite3_preupdate_hook() */
1735 void*,sqlite3
*,int,char const*,char const*,sqlite3_int64
,sqlite3_int64
1737 PreUpdate
*pPreUpdate
; /* Context for active pre-update callback */
1738 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
1739 #ifndef SQLITE_OMIT_WAL
1740 int (*xWalCallback
)(void *, sqlite3
*, const char *, int);
1743 void(*xCollNeeded
)(void*,sqlite3
*,int eTextRep
,const char*);
1744 void(*xCollNeeded16
)(void*,sqlite3
*,int eTextRep
,const void*);
1745 void *pCollNeededArg
;
1746 sqlite3_value
*pErr
; /* Most recent error message */
1748 volatile int isInterrupted
; /* True if sqlite3_interrupt has been called */
1749 double notUsed1
; /* Spacer */
1751 Lookaside lookaside
; /* Lookaside malloc configuration */
1752 #ifndef SQLITE_OMIT_AUTHORIZATION
1753 sqlite3_xauth xAuth
; /* Access authorization function */
1754 void *pAuthArg
; /* 1st argument to the access auth function */
1756 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1757 int (*xProgress
)(void *); /* The progress callback */
1758 void *pProgressArg
; /* Argument to the progress callback */
1759 unsigned nProgressOps
; /* Number of opcodes for progress callback */
1761 #ifndef SQLITE_OMIT_VIRTUALTABLE
1762 int nVTrans
; /* Allocated size of aVTrans */
1763 Hash aModule
; /* populated by sqlite3_create_module() */
1764 VtabCtx
*pVtabCtx
; /* Context for active vtab connect/create */
1765 VTable
**aVTrans
; /* Virtual tables with open transactions */
1766 VTable
*pDisconnect
; /* Disconnect these in next sqlite3_prepare() */
1768 Hash aFunc
; /* Hash table of connection functions */
1769 Hash aCollSeq
; /* All collating sequences */
1770 BusyHandler busyHandler
; /* Busy callback */
1771 Db aDbStatic
[2]; /* Static space for the 2 default backends */
1772 Savepoint
*pSavepoint
; /* List of active savepoints */
1773 int nAnalysisLimit
; /* Number of index rows to ANALYZE */
1774 int busyTimeout
; /* Busy handler timeout, in msec */
1775 int nSavepoint
; /* Number of non-transaction savepoints */
1776 int nStatement
; /* Number of nested statement-transactions */
1777 i64 nDeferredCons
; /* Net deferred constraints this transaction. */
1778 i64 nDeferredImmCons
; /* Net deferred immediate constraints */
1779 int *pnBytesFreed
; /* If not NULL, increment this in DbFree() */
1780 DbClientData
*pDbData
; /* sqlite3_set_clientdata() content */
1781 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
1782 /* The following variables are all protected by the STATIC_MAIN
1783 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
1785 ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
1786 ** unlock so that it can proceed.
1788 ** When X.pBlockingConnection==Y, that means that something that X tried
1789 ** tried to do recently failed with an SQLITE_LOCKED error due to locks
1792 sqlite3
*pBlockingConnection
; /* Connection that caused SQLITE_LOCKED */
1793 sqlite3
*pUnlockConnection
; /* Connection to watch for unlock */
1794 void *pUnlockArg
; /* Argument to xUnlockNotify */
1795 void (*xUnlockNotify
)(void **, int); /* Unlock notify callback */
1796 sqlite3
*pNextBlocked
; /* Next in list of all blocked connections */
1798 #ifdef SQLITE_USER_AUTHENTICATION
1799 sqlite3_userauth auth
; /* User authentication information */
1804 ** A macro to discover the encoding of a database.
1806 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
1807 #define ENC(db) ((db)->enc)
1810 ** A u64 constant where the lower 32 bits are all zeros. Only the
1811 ** upper 32 bits are included in the argument. Necessary because some
1812 ** C-compilers still do not accept LL integer literals.
1814 #define HI(X) ((u64)(X)<<32)
1817 ** Possible values for the sqlite3.flags.
1819 ** Value constraints (enforced via assert()):
1820 ** SQLITE_FullFSync == PAGER_FULLFSYNC
1821 ** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
1822 ** SQLITE_CacheSpill == PAGER_CACHE_SPILL
1824 #define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_SCHEMA */
1825 #define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */
1826 #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
1827 #define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */
1828 #define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */
1829 #define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */
1830 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
1831 #define SQLITE_TrustedSchema 0x00000080 /* Allow unsafe functions and
1832 ** vtabs in the schema definition */
1833 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
1834 /* result set is empty */
1835 #define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */
1836 #define SQLITE_StmtScanStatus 0x00000400 /* Enable stmt_scanstats() counters */
1837 #define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */
1838 #define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */
1839 #define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */
1840 #define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */
1841 #define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */
1842 #define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */
1843 #define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */
1844 #define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */
1845 #define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */
1846 #define SQLITE_QueryOnly 0x00100000 /* Disable database changes */
1847 #define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */
1848 #define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */
1849 #define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/
1850 #define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */
1851 #define SQLITE_ResetDatabase 0x02000000 /* Reset the database */
1852 #define SQLITE_LegacyAlter 0x04000000 /* Legacy ALTER TABLE behaviour */
1853 #define SQLITE_NoSchemaError 0x08000000 /* Do not report schema parse errors*/
1854 #define SQLITE_Defensive 0x10000000 /* Input SQL is likely hostile */
1855 #define SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/
1856 #define SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/
1857 #define SQLITE_EnableView 0x80000000 /* Enable the use of views */
1858 #define SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */
1859 /* DELETE, or UPDATE and return */
1860 /* the count using a callback. */
1861 #define SQLITE_CorruptRdOnly HI(0x00002) /* Prohibit writes due to error */
1862 #define SQLITE_ReadUncommit HI(0x00004) /* READ UNCOMMITTED in shared-cache */
1863 #define SQLITE_FkNoAction HI(0x00008) /* Treat all FK as NO ACTION */
1865 /* Flags used only if debugging */
1867 #define SQLITE_SqlTrace HI(0x0100000) /* Debug print SQL as it executes */
1868 #define SQLITE_VdbeListing HI(0x0200000) /* Debug listings of VDBE progs */
1869 #define SQLITE_VdbeTrace HI(0x0400000) /* True to trace VDBE execution */
1870 #define SQLITE_VdbeAddopTrace HI(0x0800000) /* Trace sqlite3VdbeAddOp() calls */
1871 #define SQLITE_VdbeEQP HI(0x1000000) /* Debug EXPLAIN QUERY PLAN */
1872 #define SQLITE_ParserTrace HI(0x2000000) /* PRAGMA parser_trace=ON */
1876 ** Allowed values for sqlite3.mDbFlags
1878 #define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */
1879 #define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */
1880 #define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */
1881 #define DBFLAG_VacuumInto 0x0008 /* Currently running VACUUM INTO */
1882 #define DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */
1883 #define DBFLAG_InternalFunc 0x0020 /* Allow use of internal functions */
1884 #define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */
1887 ** Bits of the sqlite3.dbOptFlags field that are used by the
1888 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
1889 ** selectively disable various optimizations.
1891 #define SQLITE_QueryFlattener 0x00000001 /* Query flattening */
1892 #define SQLITE_WindowFunc 0x00000002 /* Use xInverse for window functions */
1893 #define SQLITE_GroupByOrder 0x00000004 /* GROUPBY cover of ORDERBY */
1894 #define SQLITE_FactorOutConst 0x00000008 /* Constant factoring */
1895 #define SQLITE_DistinctOpt 0x00000010 /* DISTINCT using indexes */
1896 #define SQLITE_CoverIdxScan 0x00000020 /* Covering index scans */
1897 #define SQLITE_OrderByIdxJoin 0x00000040 /* ORDER BY of joins via index */
1898 #define SQLITE_Transitive 0x00000080 /* Transitive constraints */
1899 #define SQLITE_OmitNoopJoin 0x00000100 /* Omit unused tables in joins */
1900 #define SQLITE_CountOfView 0x00000200 /* The count-of-view optimization */
1901 #define SQLITE_CursorHints 0x00000400 /* Add OP_CursorHint opcodes */
1902 #define SQLITE_Stat4 0x00000800 /* Use STAT4 data */
1903 /* TH3 expects this value ^^^^^^^^^^ to be 0x0000800. Don't change it */
1904 #define SQLITE_PushDown 0x00001000 /* The push-down optimization */
1905 #define SQLITE_SimplifyJoin 0x00002000 /* Convert LEFT JOIN to JOIN */
1906 #define SQLITE_SkipScan 0x00004000 /* Skip-scans */
1907 #define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */
1908 #define SQLITE_MinMaxOpt 0x00010000 /* The min/max optimization */
1909 #define SQLITE_SeekScan 0x00020000 /* The OP_SeekScan optimization */
1910 #define SQLITE_OmitOrderBy 0x00040000 /* Omit pointless ORDER BY */
1911 /* TH3 expects this value ^^^^^^^^^^ to be 0x40000. Coordinate any change */
1912 #define SQLITE_BloomFilter 0x00080000 /* Use a Bloom filter on searches */
1913 #define SQLITE_BloomPulldown 0x00100000 /* Run Bloom filters early */
1914 #define SQLITE_BalancedMerge 0x00200000 /* Balance multi-way merges */
1915 #define SQLITE_ReleaseReg 0x00400000 /* Use OP_ReleaseReg for testing */
1916 #define SQLITE_FlttnUnionAll 0x00800000 /* Disable the UNION ALL flattener */
1917 /* TH3 expects this value ^^^^^^^^^^ See flatten04.test */
1918 #define SQLITE_IndexedExpr 0x01000000 /* Pull exprs from index when able */
1919 #define SQLITE_Coroutines 0x02000000 /* Co-routines for subqueries */
1920 #define SQLITE_NullUnusedCols 0x04000000 /* NULL unused columns in subqueries */
1921 #define SQLITE_OnePass 0x08000000 /* Single-pass DELETE and UPDATE */
1922 #define SQLITE_AllOpts 0xffffffff /* All optimizations */
1925 ** Macros for testing whether or not optimizations are enabled or disabled.
1927 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
1928 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
1931 ** Return true if it OK to factor constant expressions into the initialization
1932 ** code. The argument is a Parse object for the code generator.
1934 #define ConstFactorOk(P) ((P)->okConstFactor)
1936 /* Possible values for the sqlite3.eOpenState field.
1937 ** The numbers are randomly selected such that a minimum of three bits must
1938 ** change to convert any number to another or to zero
1940 #define SQLITE_STATE_OPEN 0x76 /* Database is open */
1941 #define SQLITE_STATE_CLOSED 0xce /* Database is closed */
1942 #define SQLITE_STATE_SICK 0xba /* Error and awaiting close */
1943 #define SQLITE_STATE_BUSY 0x6d /* Database currently in use */
1944 #define SQLITE_STATE_ERROR 0xd5 /* An SQLITE_MISUSE error occurred */
1945 #define SQLITE_STATE_ZOMBIE 0xa7 /* Close with last statement close */
1948 ** Each SQL function is defined by an instance of the following
1949 ** structure. For global built-in functions (ex: substr(), max(), count())
1950 ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
1951 ** For per-connection application-defined functions, a pointer to this
1952 ** structure is held in the db->aHash hash table.
1954 ** The u.pHash field is used by the global built-ins. The u.pDestructor
1955 ** field is used by per-connection app-def functions.
1958 i8 nArg
; /* Number of arguments. -1 means unlimited */
1959 u32 funcFlags
; /* Some combination of SQLITE_FUNC_* */
1960 void *pUserData
; /* User data parameter */
1961 FuncDef
*pNext
; /* Next function with same name */
1962 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**); /* func or agg-step */
1963 void (*xFinalize
)(sqlite3_context
*); /* Agg finalizer */
1964 void (*xValue
)(sqlite3_context
*); /* Current agg value */
1965 void (*xInverse
)(sqlite3_context
*,int,sqlite3_value
**); /* inverse agg-step */
1966 const char *zName
; /* SQL name of the function. */
1968 FuncDef
*pHash
; /* Next with a different name but the same hash */
1969 FuncDestructor
*pDestructor
; /* Reference counted destructor function */
1970 } u
; /* pHash if SQLITE_FUNC_BUILTIN, pDestructor otherwise */
1974 ** This structure encapsulates a user-function destructor callback (as
1975 ** configured using create_function_v2()) and a reference counter. When
1976 ** create_function_v2() is called to create a function with a destructor,
1977 ** a single object of this type is allocated. FuncDestructor.nRef is set to
1978 ** the number of FuncDef objects created (either 1 or 3, depending on whether
1979 ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
1980 ** member of each of the new FuncDef objects is set to point to the allocated
1983 ** Thereafter, when one of the FuncDef objects is deleted, the reference
1984 ** count on this object is decremented. When it reaches 0, the destructor
1985 ** is invoked and the FuncDestructor structure freed.
1987 struct FuncDestructor
{
1989 void (*xDestroy
)(void *);
1994 ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
1995 ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
1996 ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
1997 ** are assert() statements in the code to verify this.
1999 ** Value constraints (enforced via assert()):
2000 ** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
2001 ** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd
2002 ** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
2003 ** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
2004 ** SQLITE_FUNC_BYTELEN == OPFLAG_BYTELENARG
2005 ** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
2006 ** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API
2007 ** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!!
2008 ** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
2010 ** Note that even though SQLITE_FUNC_UNSAFE and SQLITE_INNOCUOUS have the
2011 ** same bit value, their meanings are inverted. SQLITE_FUNC_UNSAFE is
2012 ** used internally and if set means that the function has side effects.
2013 ** SQLITE_INNOCUOUS is used by application code and means "not unsafe".
2014 ** See multiple instances of tag-20230109-1.
2016 #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
2017 #define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */
2018 #define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */
2019 #define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */
2020 #define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
2021 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
2022 #define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */
2023 #define SQLITE_FUNC_BYTELEN 0x00c0 /* Built-in octet_length() function */
2024 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
2025 /* 0x0200 -- available for reuse */
2026 #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
2027 #define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
2028 #define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
2029 #define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
2030 ** single query - might change over time */
2031 #define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */
2032 #define SQLITE_FUNC_RUNONLY 0x8000 /* Cannot be used by valueFromFunction */
2033 #define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */
2034 #define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
2035 #define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */
2036 /* SQLITE_SUBTYPE 0x00100000 // Consumer of subtypes */
2037 #define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */
2038 #define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */
2039 #define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */
2040 /* SQLITE_RESULT_SUBTYPE 0x01000000 // Generator of subtypes */
2041 #define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
2043 /* Identifier numbers for each in-line function */
2044 #define INLINEFUNC_coalesce 0
2045 #define INLINEFUNC_implies_nonnull_row 1
2046 #define INLINEFUNC_expr_implies_expr 2
2047 #define INLINEFUNC_expr_compare 3
2048 #define INLINEFUNC_affinity 4
2049 #define INLINEFUNC_iif 5
2050 #define INLINEFUNC_sqlite_offset 6
2051 #define INLINEFUNC_unlikely 99 /* Default case */
2054 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
2055 ** used to create the initializers for the FuncDef structures.
2057 ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
2058 ** Used to create a scalar function definition of a function zName
2059 ** implemented by C function xFunc that accepts nArg arguments. The
2060 ** value passed as iArg is cast to a (void*) and made available
2061 ** as the user-data (sqlite3_user_data()) for the function. If
2062 ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
2064 ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
2065 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
2067 ** SFUNCTION(zName, nArg, iArg, bNC, xFunc)
2068 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
2069 ** adds the SQLITE_DIRECTONLY flag.
2071 ** INLINE_FUNC(zName, nArg, iFuncId, mFlags)
2072 ** zName is the name of a function that is implemented by in-line
2073 ** byte code rather than by the usual callbacks. The iFuncId
2074 ** parameter determines the function id. The mFlags parameter is
2075 ** optional SQLITE_FUNC_ flags for this function.
2077 ** TEST_FUNC(zName, nArg, iFuncId, mFlags)
2078 ** zName is the name of a test-only function implemented by in-line
2079 ** byte code rather than by the usual callbacks. The iFuncId
2080 ** parameter determines the function id. The mFlags parameter is
2081 ** optional SQLITE_FUNC_ flags for this function.
2083 ** DFUNCTION(zName, nArg, iArg, bNC, xFunc)
2084 ** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
2085 ** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions
2086 ** and functions like sqlite_version() that can change, but not during
2087 ** a single query. The iArg is ignored. The user-data is always set
2088 ** to a NULL pointer. The bNC parameter is not used.
2090 ** MFUNCTION(zName, nArg, xPtr, xFunc)
2091 ** For math-library functions. xPtr is an arbitrary pointer.
2093 ** PURE_DATE(zName, nArg, iArg, bNC, xFunc)
2094 ** Used for "pure" date/time functions, this macro is like DFUNCTION
2095 ** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is
2096 ** ignored and the user-data for these functions is set to an
2097 ** arbitrary non-NULL pointer. The bNC parameter is not used.
2099 ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
2100 ** Used to create an aggregate function definition implemented by
2101 ** the C functions xStep and xFinal. The first four parameters
2102 ** are interpreted in the same way as the first 4 parameters to
2105 ** WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse)
2106 ** Used to create an aggregate function definition implemented by
2107 ** the C functions xStep and xFinal. The first four parameters
2108 ** are interpreted in the same way as the first 4 parameters to
2111 ** LIKEFUNC(zName, nArg, pArg, flags)
2112 ** Used to create a scalar function definition of a function zName
2113 ** that accepts nArg arguments and is implemented by a call to C
2114 ** function likeFunc. Argument pArg is cast to a (void *) and made
2115 ** available as the function user-data (sqlite3_user_data()). The
2116 ** FuncDef.flags variable is set to the value passed as the flags
2119 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
2120 {nArg, SQLITE_FUNC_BUILTIN|\
2121 SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
2122 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
2123 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
2124 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
2125 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
2126 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
2127 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
2128 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
2129 #define MFUNCTION(zName, nArg, xPtr, xFunc) \
2130 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \
2131 xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
2132 #define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, bJsonB, iArg, xFunc) \
2133 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|SQLITE_FUNC_CONSTANT|\
2134 SQLITE_UTF8|((bUseCache)*SQLITE_FUNC_RUNONLY)|\
2135 ((bRS)*SQLITE_SUBTYPE)|((bWS)*SQLITE_RESULT_SUBTYPE), \
2136 SQLITE_INT_TO_PTR(iArg|((bJsonB)*JSON_BLOB)),0,xFunc,0, 0, 0, #zName, {0} }
2137 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \
2138 {nArg, SQLITE_FUNC_BUILTIN|\
2139 SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
2140 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
2141 #define TEST_FUNC(zName, nArg, iArg, mFlags) \
2142 {nArg, SQLITE_FUNC_BUILTIN|\
2143 SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
2144 SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
2145 SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
2146 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
2147 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
2148 0, 0, xFunc, 0, 0, 0, #zName, {0} }
2149 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
2150 {nArg, SQLITE_FUNC_BUILTIN|\
2151 SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
2152 (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
2153 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
2154 {nArg, SQLITE_FUNC_BUILTIN|\
2155 SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
2156 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
2157 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
2158 {nArg, SQLITE_FUNC_BUILTIN|\
2159 SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
2160 pArg, 0, xFunc, 0, 0, 0, #zName, }
2161 #define LIKEFUNC(zName, nArg, arg, flags) \
2162 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
2163 (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
2164 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
2165 {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
2166 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
2167 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \
2168 {nArg, SQLITE_FUNC_BUILTIN|\
2169 SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
2170 0, 0, xFunc, 0, 0, 0, #zName, {0} }
2174 ** All current savepoints are stored in a linked list starting at
2175 ** sqlite3.pSavepoint. The first element in the list is the most recently
2176 ** opened savepoint. Savepoints are added to the list by the vdbe
2177 ** OP_Savepoint instruction.
2180 char *zName
; /* Savepoint name (nul-terminated) */
2181 i64 nDeferredCons
; /* Number of deferred fk violations */
2182 i64 nDeferredImmCons
; /* Number of deferred imm fk. */
2183 Savepoint
*pNext
; /* Parent savepoint (if any) */
2187 ** The following are used as the second parameter to sqlite3Savepoint(),
2188 ** and as the P1 argument to the OP_Savepoint instruction.
2190 #define SAVEPOINT_BEGIN 0
2191 #define SAVEPOINT_RELEASE 1
2192 #define SAVEPOINT_ROLLBACK 2
2196 ** Each SQLite module (virtual table definition) is defined by an
2197 ** instance of the following structure, stored in the sqlite3.aModule
2201 const sqlite3_module
*pModule
; /* Callback pointers */
2202 const char *zName
; /* Name passed to create_module() */
2203 int nRefModule
; /* Number of pointers to this object */
2204 void *pAux
; /* pAux passed to create_module() */
2205 void (*xDestroy
)(void *); /* Module destructor function */
2206 Table
*pEpoTab
; /* Eponymous table for this module */
2210 ** Information about each column of an SQL table is held in an instance
2211 ** of the Column structure, in the Table.aCol[] array.
2215 ** "table column index" This is the index of the column in the
2216 ** Table.aCol[] array, and also the index of
2217 ** the column in the original CREATE TABLE stmt.
2219 ** "storage column index" This is the index of the column in the
2220 ** record BLOB generated by the OP_MakeRecord
2221 ** opcode. The storage column index is less than
2222 ** or equal to the table column index. It is
2223 ** equal if and only if there are no VIRTUAL
2224 ** columns to the left.
2226 ** Notes on zCnName:
2227 ** The zCnName field stores the name of the column, the datatype of the
2228 ** column, and the collating sequence for the column, in that order, all in
2229 ** a single allocation. Each string is 0x00 terminated. The datatype
2230 ** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the
2231 ** collating sequence name is only included if the COLFLAG_HASCOLL bit is
2235 char *zCnName
; /* Name of this column */
2236 unsigned notNull
:4; /* An OE_ code for handling a NOT NULL constraint */
2237 unsigned eCType
:4; /* One of the standard types */
2238 char affinity
; /* One of the SQLITE_AFF_... values */
2239 u8 szEst
; /* Est size of value in this column. sizeof(INT)==1 */
2240 u8 hName
; /* Column name hash for faster lookup */
2241 u16 iDflt
; /* 1-based index of DEFAULT. 0 means "none" */
2242 u16 colFlags
; /* Boolean properties. See COLFLAG_ defines below */
2245 /* Allowed values for Column.eCType.
2247 ** Values must match entries in the global constant arrays
2248 ** sqlite3StdTypeLen[] and sqlite3StdType[]. Each value is one more
2249 ** than the offset into these arrays for the corresponding name.
2250 ** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
2252 #define COLTYPE_CUSTOM 0 /* Type appended to zName */
2253 #define COLTYPE_ANY 1
2254 #define COLTYPE_BLOB 2
2255 #define COLTYPE_INT 3
2256 #define COLTYPE_INTEGER 4
2257 #define COLTYPE_REAL 5
2258 #define COLTYPE_TEXT 6
2259 #define SQLITE_N_STDTYPE 6 /* Number of standard types */
2261 /* Allowed values for Column.colFlags.
2264 ** TF_HasVirtual == COLFLAG_VIRTUAL
2265 ** TF_HasStored == COLFLAG_STORED
2266 ** TF_HasHidden == COLFLAG_HIDDEN
2268 #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
2269 #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
2270 #define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
2271 #define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */
2272 #define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */
2273 #define COLFLAG_VIRTUAL 0x0020 /* GENERATED ALWAYS AS ... VIRTUAL */
2274 #define COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */
2275 #define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */
2276 #define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */
2277 #define COLFLAG_HASCOLL 0x0200 /* Has collating sequence name in zCnName */
2278 #define COLFLAG_NOEXPAND 0x0400 /* Omit this column when expanding "*" */
2279 #define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */
2280 #define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */
2283 ** A "Collating Sequence" is defined by an instance of the following
2284 ** structure. Conceptually, a collating sequence consists of a name and
2285 ** a comparison routine that defines the order of that sequence.
2287 ** If CollSeq.xCmp is NULL, it means that the
2288 ** collating sequence is undefined. Indices built on an undefined
2289 ** collating sequence may not be read or written.
2292 char *zName
; /* Name of the collating sequence, UTF-8 encoded */
2293 u8 enc
; /* Text encoding handled by xCmp() */
2294 void *pUser
; /* First argument to xCmp() */
2295 int (*xCmp
)(void*,int, const void*, int, const void*);
2296 void (*xDel
)(void*); /* Destructor for pUser */
2300 ** A sort order can be either ASC or DESC.
2302 #define SQLITE_SO_ASC 0 /* Sort in ascending order */
2303 #define SQLITE_SO_DESC 1 /* Sort in ascending order */
2304 #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
2307 ** Column affinity types.
2309 ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
2310 ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
2311 ** the speed a little by numbering the values consecutively.
2313 ** But rather than start with 0 or 1, we begin with 'A'. That way,
2314 ** when multiple affinity types are concatenated into a string and
2315 ** used as the P4 operand, they will be more readable.
2317 ** Note also that the numeric types are grouped together so that testing
2318 ** for a numeric type is a single comparison. And the BLOB type is first.
2320 #define SQLITE_AFF_NONE 0x40 /* '@' */
2321 #define SQLITE_AFF_BLOB 0x41 /* 'A' */
2322 #define SQLITE_AFF_TEXT 0x42 /* 'B' */
2323 #define SQLITE_AFF_NUMERIC 0x43 /* 'C' */
2324 #define SQLITE_AFF_INTEGER 0x44 /* 'D' */
2325 #define SQLITE_AFF_REAL 0x45 /* 'E' */
2326 #define SQLITE_AFF_FLEXNUM 0x46 /* 'F' */
2328 #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
2331 ** The SQLITE_AFF_MASK values masks off the significant bits of an
2334 #define SQLITE_AFF_MASK 0x47
2337 ** Additional bit values that can be ORed with an affinity without
2338 ** changing the affinity.
2340 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
2341 ** It causes an assert() to fire if either operand to a comparison
2342 ** operator is NULL. It is added to certain comparison operators to
2343 ** prove that the operands are always NOT NULL.
2345 #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
2346 #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
2347 #define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */
2350 ** An object of this type is created for each virtual table present in
2351 ** the database schema.
2353 ** If the database schema is shared, then there is one instance of this
2354 ** structure for each database connection (sqlite3*) that uses the shared
2355 ** schema. This is because each database connection requires its own unique
2356 ** instance of the sqlite3_vtab* handle used to access the virtual table
2357 ** implementation. sqlite3_vtab* handles can not be shared between
2358 ** database connections, even when the rest of the in-memory database
2359 ** schema is shared, as the implementation often stores the database
2360 ** connection handle passed to it via the xConnect() or xCreate() method
2361 ** during initialization internally. This database connection handle may
2362 ** then be used by the virtual table implementation to access real tables
2363 ** within the database. So that they appear as part of the callers
2364 ** transaction, these accesses need to be made via the same database
2365 ** connection as that used to execute SQL operations on the virtual table.
2367 ** All VTable objects that correspond to a single table in a shared
2368 ** database schema are initially stored in a linked-list pointed to by
2369 ** the Table.pVTable member variable of the corresponding Table object.
2370 ** When an sqlite3_prepare() operation is required to access the virtual
2371 ** table, it searches the list for the VTable that corresponds to the
2372 ** database connection doing the preparing so as to use the correct
2373 ** sqlite3_vtab* handle in the compiled query.
2375 ** When an in-memory Table object is deleted (for example when the
2376 ** schema is being reloaded for some reason), the VTable objects are not
2377 ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
2378 ** immediately. Instead, they are moved from the Table.pVTable list to
2379 ** another linked list headed by the sqlite3.pDisconnect member of the
2380 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
2381 ** next time a statement is prepared using said sqlite3*. This is done
2382 ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
2383 ** Refer to comments above function sqlite3VtabUnlockList() for an
2384 ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
2385 ** list without holding the corresponding sqlite3.mutex mutex.
2387 ** The memory for objects of this type is always allocated by
2388 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
2389 ** the first argument.
2392 sqlite3
*db
; /* Database connection associated with this table */
2393 Module
*pMod
; /* Pointer to module implementation */
2394 sqlite3_vtab
*pVtab
; /* Pointer to vtab instance */
2395 int nRef
; /* Number of pointers to this structure */
2396 u8 bConstraint
; /* True if constraints are supported */
2397 u8 bAllSchemas
; /* True if might use any attached schema */
2398 u8 eVtabRisk
; /* Riskiness of allowing hacker access */
2399 int iSavepoint
; /* Depth of the SAVEPOINT stack */
2400 VTable
*pNext
; /* Next in linked list (see above) */
2403 /* Allowed values for VTable.eVtabRisk
2405 #define SQLITE_VTABRISK_Low 0
2406 #define SQLITE_VTABRISK_Normal 1
2407 #define SQLITE_VTABRISK_High 2
2410 ** The schema for each SQL table, virtual table, and view is represented
2411 ** in memory by an instance of the following structure.
2414 char *zName
; /* Name of the table or view */
2415 Column
*aCol
; /* Information about each column */
2416 Index
*pIndex
; /* List of SQL indexes on this table. */
2417 char *zColAff
; /* String defining the affinity of each column */
2418 ExprList
*pCheck
; /* All CHECK constraints */
2419 /* ... also used as column name list in a VIEW */
2420 Pgno tnum
; /* Root BTree page for this table */
2421 u32 nTabRef
; /* Number of pointers to this Table */
2422 u32 tabFlags
; /* Mask of TF_* values */
2423 i16 iPKey
; /* If not negative, use aCol[iPKey] as the rowid */
2424 i16 nCol
; /* Number of columns in this table */
2425 i16 nNVCol
; /* Number of columns that are not VIRTUAL */
2426 LogEst nRowLogEst
; /* Estimated rows in table - from sqlite_stat1 table */
2427 LogEst szTabRow
; /* Estimated size of each table row in bytes */
2428 #ifdef SQLITE_ENABLE_COSTMULT
2429 LogEst costMult
; /* Cost multiplier for using this table */
2431 u8 keyConf
; /* What to do in case of uniqueness conflict on iPKey */
2432 u8 eTabType
; /* 0: normal, 1: virtual, 2: view */
2434 struct { /* Used by ordinary tables: */
2435 int addColOffset
; /* Offset in CREATE TABLE stmt to add a new column */
2436 FKey
*pFKey
; /* Linked list of all foreign keys in this table */
2437 ExprList
*pDfltList
; /* DEFAULT clauses on various columns.
2438 ** Or the AS clause for generated columns. */
2440 struct { /* Used by views: */
2441 Select
*pSelect
; /* View definition */
2443 struct { /* Used by virtual tables only: */
2444 int nArg
; /* Number of arguments to the module */
2445 char **azArg
; /* 0: module 1: schema 2: vtab name 3...: args */
2446 VTable
*p
; /* List of VTable objects. */
2449 Trigger
*pTrigger
; /* List of triggers on this object */
2450 Schema
*pSchema
; /* Schema that contains this table */
2454 ** Allowed values for Table.tabFlags.
2456 ** TF_OOOHidden applies to tables or view that have hidden columns that are
2457 ** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING
2458 ** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden,
2459 ** the TF_OOOHidden attribute would apply in this case. Such tables require
2460 ** special handling during INSERT processing. The "OOO" means "Out Of Order".
2464 ** TF_HasVirtual == COLFLAG_VIRTUAL
2465 ** TF_HasStored == COLFLAG_STORED
2466 ** TF_HasHidden == COLFLAG_HIDDEN
2468 #define TF_Readonly 0x00000001 /* Read-only system table */
2469 #define TF_HasHidden 0x00000002 /* Has one or more hidden columns */
2470 #define TF_HasPrimaryKey 0x00000004 /* Table has a primary key */
2471 #define TF_Autoincrement 0x00000008 /* Integer primary key is autoincrement */
2472 #define TF_HasStat1 0x00000010 /* nRowLogEst set from sqlite_stat1 */
2473 #define TF_HasVirtual 0x00000020 /* Has one or more VIRTUAL columns */
2474 #define TF_HasStored 0x00000040 /* Has one or more STORED columns */
2475 #define TF_HasGenerated 0x00000060 /* Combo: HasVirtual + HasStored */
2476 #define TF_WithoutRowid 0x00000080 /* No rowid. PRIMARY KEY is the key */
2477 #define TF_StatsUsed 0x00000100 /* Query planner decisions affected by
2478 ** Index.aiRowLogEst[] values */
2479 #define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */
2480 #define TF_OOOHidden 0x00000400 /* Out-of-Order hidden columns */
2481 #define TF_HasNotNull 0x00000800 /* Contains NOT NULL constraints */
2482 #define TF_Shadow 0x00001000 /* True for a shadow table */
2483 #define TF_HasStat4 0x00002000 /* STAT4 info available for this table */
2484 #define TF_Ephemeral 0x00004000 /* An ephemeral table */
2485 #define TF_Eponymous 0x00008000 /* An eponymous virtual table */
2486 #define TF_Strict 0x00010000 /* STRICT mode */
2489 ** Allowed values for Table.eTabType
2491 #define TABTYP_NORM 0 /* Ordinary table */
2492 #define TABTYP_VTAB 1 /* Virtual table */
2493 #define TABTYP_VIEW 2 /* A view */
2495 #define IsView(X) ((X)->eTabType==TABTYP_VIEW)
2496 #define IsOrdinaryTable(X) ((X)->eTabType==TABTYP_NORM)
2499 ** Test to see whether or not a table is a virtual table. This is
2500 ** done as a macro so that it will be optimized out when virtual
2501 ** table support is omitted from the build.
2503 #ifndef SQLITE_OMIT_VIRTUALTABLE
2504 # define IsVirtual(X) ((X)->eTabType==TABTYP_VTAB)
2505 # define ExprIsVtab(X) \
2506 ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB)
2508 # define IsVirtual(X) 0
2509 # define ExprIsVtab(X) 0
2513 ** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn()
2514 ** only works for non-virtual tables (ordinary tables and views) and is
2515 ** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The
2516 ** IsHiddenColumn() macro is general purpose.
2518 #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS)
2519 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
2520 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
2521 #elif !defined(SQLITE_OMIT_VIRTUALTABLE)
2522 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
2523 # define IsOrdinaryHiddenColumn(X) 0
2525 # define IsHiddenColumn(X) 0
2526 # define IsOrdinaryHiddenColumn(X) 0
2530 /* Does the table have a rowid */
2531 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
2532 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
2535 ** Each foreign key constraint is an instance of the following structure.
2537 ** A foreign key is associated with two tables. The "from" table is
2538 ** the table that contains the REFERENCES clause that creates the foreign
2539 ** key. The "to" table is the table that is named in the REFERENCES clause.
2540 ** Consider this example:
2542 ** CREATE TABLE ex1(
2543 ** a INTEGER PRIMARY KEY,
2544 ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
2547 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
2548 ** Equivalent names:
2550 ** from-table == child-table
2551 ** to-table == parent-table
2553 ** Each REFERENCES clause generates an instance of the following structure
2554 ** which is attached to the from-table. The to-table need not exist when
2555 ** the from-table is created. The existence of the to-table is not checked.
2557 ** The list of all parents for child Table X is held at X.pFKey.
2559 ** A list of all children for a table named Z (which might not even exist)
2560 ** is held in Schema.fkeyHash with a hash key of Z.
2563 Table
*pFrom
; /* Table containing the REFERENCES clause (aka: Child) */
2564 FKey
*pNextFrom
; /* Next FKey with the same in pFrom. Next parent of pFrom */
2565 char *zTo
; /* Name of table that the key points to (aka: Parent) */
2566 FKey
*pNextTo
; /* Next with the same zTo. Next child of zTo. */
2567 FKey
*pPrevTo
; /* Previous with the same zTo */
2568 int nCol
; /* Number of columns in this key */
2569 /* EV: R-30323-21917 */
2570 u8 isDeferred
; /* True if constraint checking is deferred till COMMIT */
2571 u8 aAction
[2]; /* ON DELETE and ON UPDATE actions, respectively */
2572 Trigger
*apTrigger
[2];/* Triggers for aAction[] actions */
2573 struct sColMap
{ /* Mapping of columns in pFrom to columns in zTo */
2574 int iFrom
; /* Index of column in pFrom */
2575 char *zCol
; /* Name of column in zTo. If NULL use PRIMARY KEY */
2576 } aCol
[1]; /* One entry for each of nCol columns */
2580 ** SQLite supports many different ways to resolve a constraint
2581 ** error. ROLLBACK processing means that a constraint violation
2582 ** causes the operation in process to fail and for the current transaction
2583 ** to be rolled back. ABORT processing means the operation in process
2584 ** fails and any prior changes from that one operation are backed out,
2585 ** but the transaction is not rolled back. FAIL processing means that
2586 ** the operation in progress stops and returns an error code. But prior
2587 ** changes due to the same operation are not backed out and no rollback
2588 ** occurs. IGNORE means that the particular row that caused the constraint
2589 ** error is not inserted or updated. Processing continues and no error
2590 ** is returned. REPLACE means that preexisting database rows that caused
2591 ** a UNIQUE constraint violation are removed so that the new insert or
2592 ** update can proceed. Processing continues and no error is reported.
2593 ** UPDATE applies to insert operations only and means that the insert
2594 ** is omitted and the DO UPDATE clause of an upsert is run instead.
2596 ** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys.
2597 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
2598 ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
2599 ** key is set to NULL. SETDFLT means that the foreign key is set
2600 ** to its default value. CASCADE means that a DELETE or UPDATE of the
2601 ** referenced table row is propagated into the row that holds the
2604 ** The OE_Default value is a place holder that means to use whatever
2605 ** conflict resolution algorithm is required from context.
2607 ** The following symbolic values are used to record which type
2608 ** of conflict resolution action to take.
2610 #define OE_None 0 /* There is no constraint to check */
2611 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
2612 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
2613 #define OE_Fail 3 /* Stop the operation but leave all prior changes */
2614 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
2615 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
2616 #define OE_Update 6 /* Process as a DO UPDATE in an upsert */
2617 #define OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
2618 #define OE_SetNull 8 /* Set the foreign key value to NULL */
2619 #define OE_SetDflt 9 /* Set the foreign key value to its default */
2620 #define OE_Cascade 10 /* Cascade the changes */
2621 #define OE_Default 11 /* Do whatever the default action is */
2625 ** An instance of the following structure is passed as the first
2626 ** argument to sqlite3VdbeKeyCompare and is used to control the
2627 ** comparison of the two index keys.
2629 ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
2630 ** are nField slots for the columns of an index then one extra slot
2631 ** for the rowid at the end.
2634 u32 nRef
; /* Number of references to this KeyInfo object */
2635 u8 enc
; /* Text encoding - one of the SQLITE_UTF* values */
2636 u16 nKeyField
; /* Number of key columns in the index */
2637 u16 nAllField
; /* Total columns, including key plus others */
2638 sqlite3
*db
; /* The database connection */
2639 u8
*aSortFlags
; /* Sort order for each column. */
2640 CollSeq
*aColl
[1]; /* Collating sequence for each term of the key */
2644 ** Allowed bit values for entries in the KeyInfo.aSortFlags[] array.
2646 #define KEYINFO_ORDER_DESC 0x01 /* DESC sort order */
2647 #define KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */
2650 ** This object holds a record which has been parsed out into individual
2651 ** fields, for the purposes of doing a comparison.
2653 ** A record is an object that contains one or more fields of data.
2654 ** Records are used to store the content of a table row and to store
2655 ** the key of an index. A blob encoding of a record is created by
2656 ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
2657 ** OP_Column opcode.
2659 ** An instance of this object serves as a "key" for doing a search on
2660 ** an index b+tree. The goal of the search is to find the entry that
2661 ** is closed to the key described by this object. This object might hold
2662 ** just a prefix of the key. The number of fields is given by
2663 ** pKeyInfo->nField.
2665 ** The r1 and r2 fields are the values to return if this key is less than
2666 ** or greater than a key in the btree, respectively. These are normally
2667 ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
2668 ** is in DESC order.
2670 ** The key comparison functions actually return default_rc when they find
2671 ** an equals comparison. default_rc can be -1, 0, or +1. If there are
2672 ** multiple entries in the b-tree with the same key (when only looking
2673 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
2674 ** cause the search to find the last match, or +1 to cause the search to
2675 ** find the first match.
2677 ** The key comparison functions will set eqSeen to true if they ever
2678 ** get and equal results when comparing this structure to a b-tree record.
2679 ** When default_rc!=0, the search might end up on the record immediately
2680 ** before the first match or immediately after the last match. The
2681 ** eqSeen field will indicate whether or not an exact match exists in the
2684 struct UnpackedRecord
{
2685 KeyInfo
*pKeyInfo
; /* Collation and sort-order information */
2686 Mem
*aMem
; /* Values */
2688 char *z
; /* Cache of aMem[0].z for vdbeRecordCompareString() */
2689 i64 i
; /* Cache of aMem[0].u.i for vdbeRecordCompareInt() */
2691 int n
; /* Cache of aMem[0].n used by vdbeRecordCompareString() */
2692 u16 nField
; /* Number of entries in apMem[] */
2693 i8 default_rc
; /* Comparison result if keys are equal */
2694 u8 errCode
; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
2695 i8 r1
; /* Value to return if (lhs < rhs) */
2696 i8 r2
; /* Value to return if (lhs > rhs) */
2697 u8 eqSeen
; /* True if an equality comparison has been seen */
2702 ** Each SQL index is represented in memory by an
2703 ** instance of the following structure.
2705 ** The columns of the table that are to be indexed are described
2706 ** by the aiColumn[] field of this structure. For example, suppose
2707 ** we have the following table and index:
2709 ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
2710 ** CREATE INDEX Ex2 ON Ex1(c3,c1);
2712 ** In the Table structure describing Ex1, nCol==3 because there are
2713 ** three columns in the table. In the Index structure describing
2714 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
2715 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
2716 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
2717 ** The second column to be indexed (c1) has an index of 0 in
2718 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
2720 ** The Index.onError field determines whether or not the indexed columns
2721 ** must be unique and what to do if they are not. When Index.onError=OE_None,
2722 ** it means this is not a unique index. Otherwise it is a unique index
2723 ** and the value of Index.onError indicates which conflict resolution
2724 ** algorithm to employ when an attempt is made to insert a non-unique
2727 ** The colNotIdxed bitmask is used in combination with SrcItem.colUsed
2728 ** for a fast test to see if an index can serve as a covering index.
2729 ** colNotIdxed has a 1 bit for every column of the original table that
2730 ** is *not* available in the index. Thus the expression
2731 ** "colUsed & colNotIdxed" will be non-zero if the index is not a
2732 ** covering index. The most significant bit of of colNotIdxed will always
2733 ** be true (note-20221022-a). If a column beyond the 63rd column of the
2734 ** table is used, the "colUsed & colNotIdxed" test will always be non-zero
2735 ** and we have to assume either that the index is not covering, or use
2736 ** an alternative (slower) algorithm to determine whether or not
2737 ** the index is covering.
2739 ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
2740 ** generate VDBE code (as opposed to parsing one read from an sqlite_schema
2741 ** table as part of parsing an existing database schema), transient instances
2742 ** of this structure may be created. In this case the Index.tnum variable is
2743 ** used to store the address of a VDBE instruction, not a database page
2744 ** number (it cannot - the database page is not allocated until the VDBE
2745 ** program is executed). See convertToWithoutRowidTable() for details.
2748 char *zName
; /* Name of this index */
2749 i16
*aiColumn
; /* Which columns are used by this index. 1st is 0 */
2750 LogEst
*aiRowLogEst
; /* From ANALYZE: Est. rows selected by each column */
2751 Table
*pTable
; /* The SQL table being indexed */
2752 char *zColAff
; /* String defining the affinity of each column */
2753 Index
*pNext
; /* The next index associated with the same table */
2754 Schema
*pSchema
; /* Schema containing this index */
2755 u8
*aSortOrder
; /* for each column: True==DESC, False==ASC */
2756 const char **azColl
; /* Array of collation sequence names for index */
2757 Expr
*pPartIdxWhere
; /* WHERE clause for partial indices */
2758 ExprList
*aColExpr
; /* Column expressions */
2759 Pgno tnum
; /* DB Page containing root of this index */
2760 LogEst szIdxRow
; /* Estimated average row size in bytes */
2761 u16 nKeyCol
; /* Number of columns forming the key */
2762 u16 nColumn
; /* Number of columns stored in the index */
2763 u8 onError
; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
2764 unsigned idxType
:2; /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */
2765 unsigned bUnordered
:1; /* Use this index for == or IN queries only */
2766 unsigned uniqNotNull
:1; /* True if UNIQUE and NOT NULL for all columns */
2767 unsigned isResized
:1; /* True if resizeIndexObject() has been called */
2768 unsigned isCovering
:1; /* True if this is a covering index */
2769 unsigned noSkipScan
:1; /* Do not try to use skip-scan if true */
2770 unsigned hasStat1
:1; /* aiRowLogEst values come from sqlite_stat1 */
2771 unsigned bLowQual
:1; /* sqlite_stat1 says this is a low-quality index */
2772 unsigned bNoQuery
:1; /* Do not use this index to optimize queries */
2773 unsigned bAscKeyBug
:1; /* True if the bba7b69f9849b5bf bug applies */
2774 unsigned bHasVCol
:1; /* Index references one or more VIRTUAL columns */
2775 unsigned bHasExpr
:1; /* Index contains an expression, either a literal
2776 ** expression, or a reference to a VIRTUAL column */
2777 #ifdef SQLITE_ENABLE_STAT4
2778 int nSample
; /* Number of elements in aSample[] */
2779 int mxSample
; /* Number of slots allocated to aSample[] */
2780 int nSampleCol
; /* Size of IndexSample.anEq[] and so on */
2781 tRowcnt
*aAvgEq
; /* Average nEq values for keys not in aSample */
2782 IndexSample
*aSample
; /* Samples of the left-most key */
2783 tRowcnt
*aiRowEst
; /* Non-logarithmic stat1 data for this index */
2784 tRowcnt nRowEst0
; /* Non-logarithmic number of rows in the index */
2786 Bitmask colNotIdxed
; /* Unindexed columns in pTab */
2790 ** Allowed values for Index.idxType
2792 #define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
2793 #define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */
2794 #define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */
2795 #define SQLITE_IDXTYPE_IPK 3 /* INTEGER PRIMARY KEY index */
2797 /* Return true if index X is a PRIMARY KEY index */
2798 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
2800 /* Return true if index X is a UNIQUE index */
2801 #define IsUniqueIndex(X) ((X)->onError!=OE_None)
2803 /* The Index.aiColumn[] values are normally positive integer. But
2804 ** there are some negative values that have special meaning:
2806 #define XN_ROWID (-1) /* Indexed column is the rowid */
2807 #define XN_EXPR (-2) /* Indexed column is an expression */
2810 ** Each sample stored in the sqlite_stat4 table is represented in memory
2811 ** using a structure of this type. See documentation at the top of the
2812 ** analyze.c source file for additional information.
2814 struct IndexSample
{
2815 void *p
; /* Pointer to sampled record */
2816 int n
; /* Size of record in bytes */
2817 tRowcnt
*anEq
; /* Est. number of rows where the key equals this sample */
2818 tRowcnt
*anLt
; /* Est. number of rows where key is less than this sample */
2819 tRowcnt
*anDLt
; /* Est. number of distinct keys less than this sample */
2823 ** Possible values to use within the flags argument to sqlite3GetToken().
2825 #define SQLITE_TOKEN_QUOTED 0x1 /* Token is a quoted identifier. */
2826 #define SQLITE_TOKEN_KEYWORD 0x2 /* Token is a keyword. */
2829 ** Each token coming out of the lexer is an instance of
2830 ** this structure. Tokens are also used as part of an expression.
2832 ** The memory that "z" points to is owned by other objects. Take care
2833 ** that the owner of the "z" string does not deallocate the string before
2834 ** the Token goes out of scope! Very often, the "z" points to some place
2835 ** in the middle of the Parse.zSql text. But it might also point to a
2839 const char *z
; /* Text of the token. Not NULL-terminated! */
2840 unsigned int n
; /* Number of characters in this token */
2844 ** An instance of this structure contains information needed to generate
2845 ** code for a SELECT that contains aggregate functions.
2847 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
2848 ** pointer to this structure. The Expr.iAgg field is the index in
2849 ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
2850 ** code for that node.
2852 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
2853 ** original Select structure that describes the SELECT statement. These
2854 ** fields do not need to be freed when deallocating the AggInfo structure.
2857 u8 directMode
; /* Direct rendering mode means take data directly
2858 ** from source tables rather than from accumulators */
2859 u8 useSortingIdx
; /* In direct mode, reference the sorting index rather
2860 ** than the source table */
2861 u16 nSortingColumn
; /* Number of columns in the sorting index */
2862 int sortingIdx
; /* Cursor number of the sorting index */
2863 int sortingIdxPTab
; /* Cursor number of pseudo-table */
2864 int iFirstReg
; /* First register in range for aCol[] and aFunc[] */
2865 ExprList
*pGroupBy
; /* The group by clause */
2866 struct AggInfo_col
{ /* For each column used in source tables */
2867 Table
*pTab
; /* Source table */
2868 Expr
*pCExpr
; /* The original expression */
2869 int iTable
; /* Cursor number of the source table */
2870 i16 iColumn
; /* Column number within the source table */
2871 i16 iSorterColumn
; /* Column number in the sorting index */
2873 int nColumn
; /* Number of used entries in aCol[] */
2874 int nAccumulator
; /* Number of columns that show through to the output.
2875 ** Additional columns are used only as parameters to
2876 ** aggregate functions */
2877 struct AggInfo_func
{ /* For each aggregate function */
2878 Expr
*pFExpr
; /* Expression encoding the function */
2879 FuncDef
*pFunc
; /* The aggregate function implementation */
2880 int iDistinct
; /* Ephemeral table used to enforce DISTINCT */
2881 int iDistAddr
; /* Address of OP_OpenEphemeral */
2882 int iOBTab
; /* Ephemeral table to implement ORDER BY */
2883 u8 bOBPayload
; /* iOBTab has payload columns separate from key */
2884 u8 bOBUnique
; /* Enforce uniqueness on iOBTab keys */
2885 u8 bUseSubtype
; /* Transfer subtype info through sorter */
2887 int nFunc
; /* Number of entries in aFunc[] */
2888 u32 selId
; /* Select to which this AggInfo belongs */
2890 Select
*pSelect
; /* SELECT statement that this AggInfo supports */
2895 ** Macros to compute aCol[] and aFunc[] register numbers.
2897 ** These macros should not be used prior to the call to
2898 ** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg.
2899 ** The assert()s that are part of this macro verify that constraint.
2901 #define AggInfoColumnReg(A,I) (assert((A)->iFirstReg),(A)->iFirstReg+(I))
2902 #define AggInfoFuncReg(A,I) \
2903 (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))
2906 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
2907 ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
2908 ** than 32767 we have to make it 32-bit. 16-bit is preferred because
2909 ** it uses less memory in the Expr object, which is a big memory user
2910 ** in systems with lots of prepared statements. And few applications
2911 ** need more than about 10 or 20 variables. But some extreme users want
2912 ** to have prepared statements with over 32766 variables, and for them
2913 ** the option is available (at compile-time).
2915 #if SQLITE_MAX_VARIABLE_NUMBER<32767
2922 ** Each node of an expression in the parse tree is an instance
2923 ** of this structure.
2925 ** Expr.op is the opcode. The integer parser token codes are reused
2926 ** as opcodes here. For example, the parser defines TK_GE to be an integer
2927 ** code representing the ">=" operator. This same integer code is reused
2928 ** to represent the greater-than-or-equal-to operator in the expression
2931 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
2932 ** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If
2933 ** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the
2934 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
2935 ** then Expr.u.zToken contains the name of the function.
2937 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
2938 ** binary operator. Either or both may be NULL.
2940 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
2941 ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
2942 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
2943 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
2944 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
2947 ** An expression of the form ID or ID.ID refers to a column in a table.
2948 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
2949 ** the integer cursor number of a VDBE cursor pointing to that table and
2950 ** Expr.iColumn is the column number for the specific column. If the
2951 ** expression is used as a result in an aggregate SELECT, then the
2952 ** value is also stored in the Expr.iAgg column in the aggregate so that
2953 ** it can be accessed after all aggregates are computed.
2955 ** If the expression is an unbound variable marker (a question mark
2956 ** character '?' in the original SQL) then the Expr.iTable holds the index
2957 ** number for that variable.
2959 ** If the expression is a subquery then Expr.iColumn holds an integer
2960 ** register number containing the result of the subquery. If the
2961 ** subquery gives a constant result, then iTable is -1. If the subquery
2962 ** gives a different answer at different times during statement processing
2963 ** then iTable is the address of a subroutine that computes the subquery.
2965 ** If the Expr is of type OP_Column, and the table it is selecting from
2966 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
2967 ** corresponding table definition.
2969 ** ALLOCATION NOTES:
2971 ** Expr objects can use a lot of memory space in database schema. To
2972 ** help reduce memory requirements, sometimes an Expr object will be
2973 ** truncated. And to reduce the number of memory allocations, sometimes
2974 ** two or more Expr objects will be stored in a single memory allocation,
2975 ** together with Expr.u.zToken strings.
2977 ** If the EP_Reduced and EP_TokenOnly flags are set when
2978 ** an Expr object is truncated. When EP_Reduced is set, then all
2979 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
2980 ** are contained within the same memory allocation. Note, however, that
2981 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
2982 ** allocated, regardless of whether or not EP_Reduced is set.
2985 u8 op
; /* Operation performed by this node */
2986 char affExpr
; /* affinity, or RAISE type */
2987 u8 op2
; /* TK_REGISTER/TK_TRUTH: original value of Expr.op
2988 ** TK_COLUMN: the value of p5 for OP_Column
2989 ** TK_AGG_FUNCTION: nesting depth
2990 ** TK_FUNCTION: NC_SelfRef flag if needs OP_PureFunc */
2992 u8 vvaFlags
; /* Verification flags. */
2994 u32 flags
; /* Various flags. EP_* See below */
2996 char *zToken
; /* Token value. Zero terminated and dequoted */
2997 int iValue
; /* Non-negative integer value if EP_IntValue */
3000 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
3001 ** space is allocated for the fields below this point. An attempt to
3002 ** access them will result in a segfault or malfunction.
3003 *********************************************************************/
3005 Expr
*pLeft
; /* Left subnode */
3006 Expr
*pRight
; /* Right subnode */
3008 ExprList
*pList
; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
3009 Select
*pSelect
; /* EP_xIsSelect and op = IN, EXISTS, SELECT */
3012 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
3013 ** space is allocated for the fields below this point. An attempt to
3014 ** access them will result in a segfault or malfunction.
3015 *********************************************************************/
3017 #if SQLITE_MAX_EXPR_DEPTH>0
3018 int nHeight
; /* Height of the tree headed by this node */
3020 int iTable
; /* TK_COLUMN: cursor number of table holding column
3021 ** TK_REGISTER: register number
3022 ** TK_TRIGGER: 1 -> new, 0 -> old
3023 ** EP_Unlikely: 134217728 times likelihood
3024 ** TK_IN: ephemeral table holding RHS
3025 ** TK_SELECT_COLUMN: Number of columns on the LHS
3026 ** TK_SELECT: 1st register of result vector */
3027 ynVar iColumn
; /* TK_COLUMN: column index. -1 for rowid.
3028 ** TK_VARIABLE: variable number (always >= 1).
3029 ** TK_SELECT_COLUMN: column of the result vector */
3030 i16 iAgg
; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
3032 int iJoin
; /* If EP_OuterON or EP_InnerON, the right table */
3033 int iOfst
; /* else: start of token from start of statement */
3035 AggInfo
*pAggInfo
; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
3037 Table
*pTab
; /* TK_COLUMN: Table containing column. Can be NULL
3038 ** for a column of an index on an expression */
3039 Window
*pWin
; /* EP_WinFunc: Window/Filter defn for a function */
3040 struct { /* TK_IN, TK_SELECT, and TK_EXISTS */
3041 int iAddr
; /* Subroutine entry address */
3042 int regReturn
; /* Register used to hold return address */
3047 /* The following are the meanings of bits in the Expr.flags field.
3048 ** Value restrictions:
3050 ** EP_Agg == NC_HasAgg == SF_HasAgg
3051 ** EP_Win == NC_HasWin
3053 #define EP_OuterON 0x000001 /* Originates in ON/USING clause of outer join */
3054 #define EP_InnerON 0x000002 /* Originates in ON/USING of an inner join */
3055 #define EP_Distinct 0x000004 /* Aggregate function with DISTINCT keyword */
3056 #define EP_HasFunc 0x000008 /* Contains one or more functions of any kind */
3057 #define EP_Agg 0x000010 /* Contains one or more aggregate functions */
3058 #define EP_FixedCol 0x000020 /* TK_Column with a known fixed value */
3059 #define EP_VarSelect 0x000040 /* pSelect is correlated, not constant */
3060 #define EP_DblQuoted 0x000080 /* token.z was originally in "..." */
3061 #define EP_InfixFunc 0x000100 /* True for an infix function: LIKE, GLOB, etc */
3062 #define EP_Collate 0x000200 /* Tree contains a TK_COLLATE operator */
3063 #define EP_Commuted 0x000400 /* Comparison operator has been commuted */
3064 #define EP_IntValue 0x000800 /* Integer value contained in u.iValue */
3065 #define EP_xIsSelect 0x001000 /* x.pSelect is valid (otherwise x.pList is) */
3066 #define EP_Skip 0x002000 /* Operator does not contribute to affinity */
3067 #define EP_Reduced 0x004000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
3068 #define EP_Win 0x008000 /* Contains window functions */
3069 #define EP_TokenOnly 0x010000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
3070 #define EP_FullSize 0x020000 /* Expr structure must remain full sized */
3071 #define EP_IfNullRow 0x040000 /* The TK_IF_NULL_ROW opcode */
3072 #define EP_Unlikely 0x080000 /* unlikely() or likelihood() function */
3073 #define EP_ConstFunc 0x100000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
3074 #define EP_CanBeNull 0x200000 /* Can be null despite NOT NULL constraint */
3075 #define EP_Subquery 0x400000 /* Tree contains a TK_SELECT operator */
3076 #define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
3077 #define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */
3078 #define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */
3079 #define EP_Quoted 0x4000000 /* TK_ID was originally quoted */
3080 #define EP_Static 0x8000000 /* Held in memory not obtained from malloc() */
3081 #define EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */
3082 #define EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */
3083 #define EP_FromDDL 0x40000000 /* Originates from sqlite_schema */
3084 /* 0x80000000 // Available */
3086 /* The EP_Propagate mask is a set of properties that automatically propagate
3087 ** upwards into parent nodes.
3089 #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)
3091 /* Macros can be used to test, set, or clear bits in the
3092 ** Expr.flags field.
3094 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
3095 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
3096 #define ExprSetProperty(E,P) (E)->flags|=(P)
3097 #define ExprClearProperty(E,P) (E)->flags&=~(P)
3098 #define ExprAlwaysTrue(E) (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue)
3099 #define ExprAlwaysFalse(E) (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse)
3100 #define ExprIsFullSize(E) (((E)->flags&(EP_Reduced|EP_TokenOnly))==0)
3102 /* Macros used to ensure that the correct members of unions are accessed
3105 #define ExprUseUToken(E) (((E)->flags&EP_IntValue)==0)
3106 #define ExprUseUValue(E) (((E)->flags&EP_IntValue)!=0)
3107 #define ExprUseWOfst(E) (((E)->flags&(EP_InnerON|EP_OuterON))==0)
3108 #define ExprUseWJoin(E) (((E)->flags&(EP_InnerON|EP_OuterON))!=0)
3109 #define ExprUseXList(E) (((E)->flags&EP_xIsSelect)==0)
3110 #define ExprUseXSelect(E) (((E)->flags&EP_xIsSelect)!=0)
3111 #define ExprUseYTab(E) (((E)->flags&(EP_WinFunc|EP_Subrtn))==0)
3112 #define ExprUseYWin(E) (((E)->flags&EP_WinFunc)!=0)
3113 #define ExprUseYSub(E) (((E)->flags&EP_Subrtn)!=0)
3115 /* Flags for use with Expr.vvaFlags
3117 #define EP_NoReduce 0x01 /* Cannot EXPRDUP_REDUCE this Expr */
3118 #define EP_Immutable 0x02 /* Do not change this Expr node */
3120 /* The ExprSetVVAProperty() macro is used for Verification, Validation,
3121 ** and Accreditation only. It works like ExprSetProperty() during VVA
3122 ** processes but is a no-op for delivery.
3125 # define ExprSetVVAProperty(E,P) (E)->vvaFlags|=(P)
3126 # define ExprHasVVAProperty(E,P) (((E)->vvaFlags&(P))!=0)
3127 # define ExprClearVVAProperties(E) (E)->vvaFlags = 0
3129 # define ExprSetVVAProperty(E,P)
3130 # define ExprHasVVAProperty(E,P) 0
3131 # define ExprClearVVAProperties(E)
3135 ** Macros to determine the number of bytes required by a normal Expr
3136 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
3137 ** and an Expr struct with the EP_TokenOnly flag set.
3139 #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
3140 #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
3141 #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
3144 ** Flags passed to the sqlite3ExprDup() function. See the header comment
3145 ** above sqlite3ExprDup() for details.
3147 #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
3150 ** True if the expression passed as an argument was a function with
3151 ** an OVER() clause (a window function).
3153 #ifdef SQLITE_OMIT_WINDOWFUNC
3154 # define IsWindowFunc(p) 0
3156 # define IsWindowFunc(p) ( \
3157 ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \
3162 ** A list of expressions. Each expression may optionally have a
3163 ** name. An expr/name combination can be used in several ways, such
3164 ** as the list of "expr AS ID" fields following a "SELECT" or in the
3165 ** list of "ID = expr" items in an UPDATE. A list of expressions can
3166 ** also be used as the argument to a function, in which case the a.zName
3167 ** field is not used.
3169 ** In order to try to keep memory usage down, the Expr.a.zEName field
3170 ** is used for multiple purposes:
3173 ** ---------- -------------------------
3174 ** ENAME_NAME (1) the AS of result set column
3175 ** (2) COLUMN= of an UPDATE
3177 ** ENAME_TAB DB.TABLE.NAME used to resolve names
3180 ** ENAME_SPAN Text of the original result set
3184 int nExpr
; /* Number of expressions on the list */
3185 int nAlloc
; /* Number of a[] slots allocated */
3186 struct ExprList_item
{ /* For each expression in the list */
3187 Expr
*pExpr
; /* The parse tree for this expression */
3188 char *zEName
; /* Token associated with this expression */
3190 u8 sortFlags
; /* Mask of KEYINFO_ORDER_* flags */
3191 unsigned eEName
:2; /* Meaning of zEName */
3192 unsigned done
:1; /* Indicates when processing is finished */
3193 unsigned reusable
:1; /* Constant expression is reusable */
3194 unsigned bSorterRef
:1; /* Defer evaluation until after sorting */
3195 unsigned bNulls
:1; /* True if explicit "NULLS FIRST/LAST" */
3196 unsigned bUsed
:1; /* This column used in a SF_NestedFrom subquery */
3197 unsigned bUsingTerm
:1; /* Term from the USING clause of a NestedFrom */
3198 unsigned bNoExpand
: 1; /* Term is an auxiliary in NestedFrom and should
3199 ** not be expanded by "*" in parent queries */
3202 struct { /* Used by any ExprList other than Parse.pConsExpr */
3203 u16 iOrderByCol
; /* For ORDER BY, column number in result set */
3204 u16 iAlias
; /* Index into Parse.aAlias[] for zName */
3206 int iConstExprReg
; /* Register in which Expr value is cached. Used only
3207 ** by Parse.pConstExpr */
3209 } a
[1]; /* One slot for each expression in the list */
3213 ** Allowed values for Expr.a.eEName
3215 #define ENAME_NAME 0 /* The AS clause of a result set */
3216 #define ENAME_SPAN 1 /* Complete text of the result set expression */
3217 #define ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */
3218 #define ENAME_ROWID 3 /* "DB.TABLE._rowid_" for * expansion of rowid */
3221 ** An instance of this structure can hold a simple list of identifiers,
3222 ** such as the list "a,b,c" in the following statements:
3224 ** INSERT INTO t(a,b,c) VALUES ...;
3225 ** CREATE INDEX idx ON t(a,b,c);
3226 ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
3228 ** The IdList.a.idx field is used when the IdList represents the list of
3229 ** column names after a table name in an INSERT statement. In the statement
3231 ** INSERT INTO t(a,b,c) ...
3233 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
3236 int nId
; /* Number of identifiers on the list */
3237 u8 eU4
; /* Which element of a.u4 is valid */
3238 struct IdList_item
{
3239 char *zName
; /* Name of the identifier */
3241 int idx
; /* Index in some Table.aCol[] of a column named zName */
3242 Expr
*pExpr
; /* Expr to implement a USING variable -- NOT USED */
3248 ** Allowed values for IdList.eType, which determines which value of the a.u4
3251 #define EU4_NONE 0 /* Does not use IdList.a.u4 */
3252 #define EU4_IDX 1 /* Uses IdList.a.u4.idx */
3253 #define EU4_EXPR 2 /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
3256 ** The SrcItem object represents a single term in the FROM clause of a query.
3257 ** The SrcList object is mostly an array of SrcItems.
3259 ** The jointype starts out showing the join type between the current table
3260 ** and the next table on the list. The parser builds the list this way.
3261 ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
3262 ** jointype expresses the join between the table and the previous table.
3264 ** In the colUsed field, the high-order bit (bit 63) is set if the table
3265 ** contains more than 63 columns and the 64-th or later column is used.
3267 ** Union member validity:
3269 ** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc
3270 ** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy
3271 ** u2.pIBIndex fg.isIndexedBy && !fg.isCte
3272 ** u2.pCteUse fg.isCte && !fg.isIndexedBy
3275 Schema
*pSchema
; /* Schema to which this item is fixed */
3276 char *zDatabase
; /* Name of database holding this table */
3277 char *zName
; /* Name of the table */
3278 char *zAlias
; /* The "B" part of a "A AS B" phrase. zName is the "A" */
3279 Table
*pTab
; /* An SQL table corresponding to zName */
3280 Select
*pSelect
; /* A SELECT statement used in place of a table name */
3281 int addrFillSub
; /* Address of subroutine to manifest a subquery */
3282 int regReturn
; /* Register holding return address of addrFillSub */
3283 int regResult
; /* Registers holding results of a co-routine */
3285 u8 jointype
; /* Type of join between this table and the previous */
3286 unsigned notIndexed
:1; /* True if there is a NOT INDEXED clause */
3287 unsigned isIndexedBy
:1; /* True if there is an INDEXED BY clause */
3288 unsigned isTabFunc
:1; /* True if table-valued-function syntax */
3289 unsigned isCorrelated
:1; /* True if sub-query is correlated */
3290 unsigned isMaterialized
:1; /* This is a materialized view */
3291 unsigned viaCoroutine
:1; /* Implemented as a co-routine */
3292 unsigned isRecursive
:1; /* True for recursive reference in WITH */
3293 unsigned fromDDL
:1; /* Comes from sqlite_schema */
3294 unsigned isCte
:1; /* This is a CTE */
3295 unsigned notCte
:1; /* This item may not match a CTE */
3296 unsigned isUsing
:1; /* u3.pUsing is valid */
3297 unsigned isOn
:1; /* u3.pOn was once valid and non-NULL */
3298 unsigned isSynthUsing
:1; /* u3.pUsing is synthesized from NATURAL */
3299 unsigned isNestedFrom
:1; /* pSelect is a SF_NestedFrom subquery */
3301 int iCursor
; /* The VDBE cursor number used to access this table */
3303 Expr
*pOn
; /* fg.isUsing==0 => The ON clause of a join */
3304 IdList
*pUsing
; /* fg.isUsing==1 => The USING clause of a join */
3306 Bitmask colUsed
; /* Bit N set if column N used. Details above for N>62 */
3308 char *zIndexedBy
; /* Identifier from "INDEXED BY <zIndex>" clause */
3309 ExprList
*pFuncArg
; /* Arguments to table-valued-function */
3312 Index
*pIBIndex
; /* Index structure corresponding to u1.zIndexedBy */
3313 CteUse
*pCteUse
; /* CTE Usage info when fg.isCte is true */
3318 ** The OnOrUsing object represents either an ON clause or a USING clause.
3319 ** It can never be both at the same time, but it can be neither.
3322 Expr
*pOn
; /* The ON clause of a join */
3323 IdList
*pUsing
; /* The USING clause of a join */
3327 ** This object represents one or more tables that are the source of
3328 ** content for an SQL statement. For example, a single SrcList object
3329 ** is used to hold the FROM clause of a SELECT statement. SrcList also
3330 ** represents the target tables for DELETE, INSERT, and UPDATE statements.
3334 int nSrc
; /* Number of tables or subqueries in the FROM clause */
3335 u32 nAlloc
; /* Number of entries allocated in a[] below */
3336 SrcItem a
[1]; /* One entry for each identifier on the list */
3340 ** Permitted values of the SrcList.a.jointype field
3342 #define JT_INNER 0x01 /* Any kind of inner or cross join */
3343 #define JT_CROSS 0x02 /* Explicit use of the CROSS keyword */
3344 #define JT_NATURAL 0x04 /* True for a "natural" join */
3345 #define JT_LEFT 0x08 /* Left outer join */
3346 #define JT_RIGHT 0x10 /* Right outer join */
3347 #define JT_OUTER 0x20 /* The "OUTER" keyword is present */
3348 #define JT_LTORJ 0x40 /* One of the LEFT operands of a RIGHT JOIN
3349 ** Mnemonic: Left Table Of Right Join */
3350 #define JT_ERROR 0x80 /* unknown or unsupported join type */
3353 ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
3354 ** and the WhereInfo.wctrlFlags member.
3356 ** Value constraints (enforced via assert()):
3357 ** WHERE_USE_LIMIT == SF_FixedLimit
3359 #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
3360 #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
3361 #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
3362 #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
3363 #define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
3364 #define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
3365 #define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
3366 ** the OR optimization */
3367 #define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */
3368 #define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */
3369 #define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */
3370 #define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
3371 #define WHERE_AGG_DISTINCT 0x0400 /* Query is "SELECT agg(DISTINCT ...)" */
3372 #define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
3373 #define WHERE_RIGHT_JOIN 0x1000 /* Processing a RIGHT JOIN */
3374 /* 0x2000 not currently used */
3375 #define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
3376 /* 0x8000 not currently used */
3378 /* Allowed return values from sqlite3WhereIsDistinct()
3380 #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
3381 #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */
3382 #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */
3383 #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */
3386 ** A NameContext defines a context in which to resolve table and column
3387 ** names. The context consists of a list of tables (the pSrcList) field and
3388 ** a list of named expression (pEList). The named expression list may
3389 ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
3390 ** to the table being operated on by INSERT, UPDATE, or DELETE. The
3391 ** pEList corresponds to the result set of a SELECT and is NULL for
3392 ** other statements.
3394 ** NameContexts can be nested. When resolving names, the inner-most
3395 ** context is searched first. If no match is found, the next outer
3396 ** context is checked. If there is still no match, the next context
3397 ** is checked. This process continues until either a match is found
3398 ** or all contexts are check. When a match is found, the nRef member of
3399 ** the context containing the match is incremented.
3401 ** Each subquery gets a new NameContext. The pNext field points to the
3402 ** NameContext in the parent query. Thus the process of scanning the
3403 ** NameContext list corresponds to searching through successively outer
3404 ** subqueries looking for a match.
3406 struct NameContext
{
3407 Parse
*pParse
; /* The parser */
3408 SrcList
*pSrcList
; /* One or more tables used to resolve names */
3410 ExprList
*pEList
; /* Optional list of result-set columns */
3411 AggInfo
*pAggInfo
; /* Information about aggregates at this level */
3412 Upsert
*pUpsert
; /* ON CONFLICT clause information from an upsert */
3413 int iBaseReg
; /* For TK_REGISTER when parsing RETURNING */
3415 NameContext
*pNext
; /* Next outer name context. NULL for outermost */
3416 int nRef
; /* Number of names resolved by this context */
3417 int nNcErr
; /* Number of errors encountered while resolving names */
3418 int ncFlags
; /* Zero or more NC_* flags defined below */
3419 u32 nNestedSelect
; /* Number of nested selects using this NC */
3420 Select
*pWinSelect
; /* SELECT statement for any window functions */
3424 ** Allowed values for the NameContext, ncFlags field.
3426 ** Value constraints (all checked via assert()):
3427 ** NC_HasAgg == SF_HasAgg == EP_Agg
3428 ** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
3429 ** NC_OrderAgg == SF_OrderByReqd == SQLITE_FUNC_ANYORDER
3430 ** NC_HasWin == EP_Win
3433 #define NC_AllowAgg 0x000001 /* Aggregate functions are allowed here */
3434 #define NC_PartIdx 0x000002 /* True if resolving a partial index WHERE */
3435 #define NC_IsCheck 0x000004 /* True if resolving a CHECK constraint */
3436 #define NC_GenCol 0x000008 /* True for a GENERATED ALWAYS AS clause */
3437 #define NC_HasAgg 0x000010 /* One or more aggregate functions seen */
3438 #define NC_IdxExpr 0x000020 /* True if resolving columns of CREATE INDEX */
3439 #define NC_SelfRef 0x00002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */
3440 #define NC_Subquery 0x000040 /* A subquery has been seen */
3441 #define NC_UEList 0x000080 /* True if uNC.pEList is used */
3442 #define NC_UAggInfo 0x000100 /* True if uNC.pAggInfo is used */
3443 #define NC_UUpsert 0x000200 /* True if uNC.pUpsert is used */
3444 #define NC_UBaseReg 0x000400 /* True if uNC.iBaseReg is used */
3445 #define NC_MinMaxAgg 0x001000 /* min/max aggregates seen. See note above */
3446 #define NC_Complex 0x002000 /* True if a function or subquery seen */
3447 #define NC_AllowWin 0x004000 /* Window functions are allowed here */
3448 #define NC_HasWin 0x008000 /* One or more window functions seen */
3449 #define NC_IsDDL 0x010000 /* Resolving names in a CREATE statement */
3450 #define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */
3451 #define NC_FromDDL 0x040000 /* SQL text comes from sqlite_schema */
3452 #define NC_NoSelect 0x080000 /* Do not descend into sub-selects */
3453 #define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
3456 ** An instance of the following object describes a single ON CONFLICT
3457 ** clause in an upsert.
3459 ** The pUpsertTarget field is only set if the ON CONFLICT clause includes
3460 ** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the
3461 ** conflict-target clause.) The pUpsertTargetWhere is the optional
3462 ** WHERE clause used to identify partial unique indexes.
3464 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
3465 ** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING. The
3466 ** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the
3467 ** WHERE clause is omitted.
3470 ExprList
*pUpsertTarget
; /* Optional description of conflict target */
3471 Expr
*pUpsertTargetWhere
; /* WHERE clause for partial index targets */
3472 ExprList
*pUpsertSet
; /* The SET clause from an ON CONFLICT UPDATE */
3473 Expr
*pUpsertWhere
; /* WHERE clause for the ON CONFLICT UPDATE */
3474 Upsert
*pNextUpsert
; /* Next ON CONFLICT clause in the list */
3475 u8 isDoUpdate
; /* True for DO UPDATE. False for DO NOTHING */
3476 /* Above this point is the parse tree for the ON CONFLICT clauses.
3477 ** The next group of fields stores intermediate data. */
3478 void *pToFree
; /* Free memory when deleting the Upsert object */
3479 /* All fields above are owned by the Upsert object and must be freed
3480 ** when the Upsert is destroyed. The fields below are used to transfer
3481 ** information from the INSERT processing down into the UPDATE processing
3482 ** while generating code. The fields below are owned by the INSERT
3483 ** statement and will be freed by INSERT processing. */
3484 Index
*pUpsertIdx
; /* UNIQUE constraint specified by pUpsertTarget */
3485 SrcList
*pUpsertSrc
; /* Table to be updated */
3486 int regData
; /* First register holding array of VALUES */
3487 int iDataCur
; /* Index of the data cursor */
3488 int iIdxCur
; /* Index of the first index cursor */
3492 ** An instance of the following structure contains all information
3493 ** needed to generate code for a single SELECT statement.
3495 ** See the header comment on the computeLimitRegisters() routine for a
3496 ** detailed description of the meaning of the iLimit and iOffset fields.
3498 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
3499 ** These addresses must be stored so that we can go back and fill in
3500 ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
3501 ** the number of columns in P2 can be computed at the same time
3502 ** as the OP_OpenEphm instruction is coded because not
3503 ** enough information about the compound query is known at that point.
3504 ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
3505 ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
3506 ** sequences for the ORDER BY clause.
3509 u8 op
; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
3510 LogEst nSelectRow
; /* Estimated number of result rows */
3511 u32 selFlags
; /* Various SF_* values */
3512 int iLimit
, iOffset
; /* Memory registers holding LIMIT & OFFSET counters */
3513 u32 selId
; /* Unique identifier number for this SELECT */
3514 int addrOpenEphm
[2]; /* OP_OpenEphem opcodes related to this select */
3515 ExprList
*pEList
; /* The fields of the result */
3516 SrcList
*pSrc
; /* The FROM clause */
3517 Expr
*pWhere
; /* The WHERE clause */
3518 ExprList
*pGroupBy
; /* The GROUP BY clause */
3519 Expr
*pHaving
; /* The HAVING clause */
3520 ExprList
*pOrderBy
; /* The ORDER BY clause */
3521 Select
*pPrior
; /* Prior select in a compound select statement */
3522 Select
*pNext
; /* Next select to the left in a compound */
3523 Expr
*pLimit
; /* LIMIT expression. NULL means not used. */
3524 With
*pWith
; /* WITH clause attached to this select. Or NULL. */
3525 #ifndef SQLITE_OMIT_WINDOWFUNC
3526 Window
*pWin
; /* List of window functions */
3527 Window
*pWinDefn
; /* List of named window definitions */
3532 ** Allowed values for Select.selFlags. The "SF" prefix stands for
3535 ** Value constraints (all checked via assert())
3536 ** SF_HasAgg == NC_HasAgg
3537 ** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX
3538 ** SF_OrderByReqd == NC_OrderAgg == SQLITE_FUNC_ANYORDER
3539 ** SF_FixedLimit == WHERE_USE_LIMIT
3541 #define SF_Distinct 0x0000001 /* Output should be DISTINCT */
3542 #define SF_All 0x0000002 /* Includes the ALL keyword */
3543 #define SF_Resolved 0x0000004 /* Identifiers have been resolved */
3544 #define SF_Aggregate 0x0000008 /* Contains agg functions or a GROUP BY */
3545 #define SF_HasAgg 0x0000010 /* Contains aggregate functions */
3546 #define SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */
3547 #define SF_Expanded 0x0000040 /* sqlite3SelectExpand() called on this */
3548 #define SF_HasTypeInfo 0x0000080 /* FROM subqueries have Table metadata */
3549 #define SF_Compound 0x0000100 /* Part of a compound query */
3550 #define SF_Values 0x0000200 /* Synthesized from VALUES clause */
3551 #define SF_MultiValue 0x0000400 /* Single VALUES term with multiple rows */
3552 #define SF_NestedFrom 0x0000800 /* Part of a parenthesized FROM clause */
3553 #define SF_MinMaxAgg 0x0001000 /* Aggregate containing min() or max() */
3554 #define SF_Recursive 0x0002000 /* The recursive part of a recursive CTE */
3555 #define SF_FixedLimit 0x0004000 /* nSelectRow set by a constant LIMIT */
3556 #define SF_MaybeConvert 0x0008000 /* Need convertCompoundSelectToSubquery() */
3557 #define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */
3558 #define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */
3559 #define SF_ComplexResult 0x0040000 /* Result contains subquery or function */
3560 #define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */
3561 #define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */
3562 #define SF_View 0x0200000 /* SELECT statement is a view */
3563 #define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */
3564 #define SF_UFSrcCheck 0x0800000 /* Check pSrc as required by UPDATE...FROM */
3565 #define SF_PushDown 0x1000000 /* SELECT has be modified by push-down opt */
3566 #define SF_MultiPart 0x2000000 /* Has multiple incompatible PARTITIONs */
3567 #define SF_CopyCte 0x4000000 /* SELECT statement is a copy of a CTE */
3568 #define SF_OrderByReqd 0x8000000 /* The ORDER BY clause may not be omitted */
3569 #define SF_UpdateFrom 0x10000000 /* Query originates with UPDATE FROM */
3571 /* True if S exists and has SF_NestedFrom */
3572 #define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)
3575 ** The results of a SELECT can be distributed in several ways, as defined
3576 ** by one of the following macros. The "SRT" prefix means "SELECT Result
3579 ** SRT_Union Store results as a key in a temporary index
3580 ** identified by pDest->iSDParm.
3582 ** SRT_Except Remove results from the temporary index pDest->iSDParm.
3584 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
3585 ** set is not empty.
3587 ** SRT_Discard Throw the results away. This is used by SELECT
3588 ** statements within triggers whose only purpose is
3589 ** the side-effects of functions.
3591 ** SRT_Output Generate a row of output (using the OP_ResultRow
3592 ** opcode) for each row in the result set.
3594 ** SRT_Mem Only valid if the result is a single column.
3595 ** Store the first column of the first result row
3596 ** in register pDest->iSDParm then abandon the rest
3597 ** of the query. This destination implies "LIMIT 1".
3599 ** SRT_Set The result must be a single column. Store each
3600 ** row of result as the key in table pDest->iSDParm.
3601 ** Apply the affinity pDest->affSdst before storing
3602 ** results. Used to implement "IN (SELECT ...)".
3604 ** SRT_EphemTab Create an temporary table pDest->iSDParm and store
3605 ** the result there. The cursor is left open after
3606 ** returning. This is like SRT_Table except that
3607 ** this destination uses OP_OpenEphemeral to create
3610 ** SRT_Coroutine Generate a co-routine that returns a new row of
3611 ** results each time it is invoked. The entry point
3612 ** of the co-routine is stored in register pDest->iSDParm
3613 ** and the result row is stored in pDest->nDest registers
3614 ** starting with pDest->iSdst.
3616 ** SRT_Table Store results in temporary table pDest->iSDParm.
3617 ** SRT_Fifo This is like SRT_EphemTab except that the table
3618 ** is assumed to already be open. SRT_Fifo has
3619 ** the additional property of being able to ignore
3620 ** the ORDER BY clause.
3622 ** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
3623 ** But also use temporary table pDest->iSDParm+1 as
3624 ** a record of all prior results and ignore any duplicate
3625 ** rows. Name means: "Distinct Fifo".
3627 ** SRT_Queue Store results in priority queue pDest->iSDParm (really
3628 ** an index). Append a sequence number so that all entries
3631 ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
3632 ** the same record has never been stored before. The
3633 ** index at pDest->iSDParm+1 hold all prior stores.
3635 ** SRT_Upfrom Store results in the temporary table already opened by
3636 ** pDest->iSDParm. If (pDest->iSDParm<0), then the temp
3637 ** table is an intkey table - in this case the first
3638 ** column returned by the SELECT is used as the integer
3639 ** key. If (pDest->iSDParm>0), then the table is an index
3640 ** table. (pDest->iSDParm) is the number of key columns in
3641 ** each index record in this case.
3643 #define SRT_Union 1 /* Store result as keys in an index */
3644 #define SRT_Except 2 /* Remove result from a UNION index */
3645 #define SRT_Exists 3 /* Store 1 if the result is not empty */
3646 #define SRT_Discard 4 /* Do not save the results anywhere */
3647 #define SRT_DistFifo 5 /* Like SRT_Fifo, but unique results only */
3648 #define SRT_DistQueue 6 /* Like SRT_Queue, but unique results only */
3650 /* The DISTINCT clause is ignored for all of the above. Not that
3651 ** IgnorableDistinct() implies IgnorableOrderby() */
3652 #define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue)
3654 #define SRT_Queue 7 /* Store result in an queue */
3655 #define SRT_Fifo 8 /* Store result as data with an automatic rowid */
3657 /* The ORDER BY clause is ignored for all of the above */
3658 #define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo)
3660 #define SRT_Output 9 /* Output each row of result */
3661 #define SRT_Mem 10 /* Store result in a memory cell */
3662 #define SRT_Set 11 /* Store results as keys in an index */
3663 #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */
3664 #define SRT_Coroutine 13 /* Generate a single row of result */
3665 #define SRT_Table 14 /* Store result as data with an automatic rowid */
3666 #define SRT_Upfrom 15 /* Store result as data with rowid */
3669 ** An instance of this object describes where to put of the results of
3670 ** a SELECT statement.
3673 u8 eDest
; /* How to dispose of the results. One of SRT_* above. */
3674 int iSDParm
; /* A parameter used by the eDest disposal method */
3675 int iSDParm2
; /* A second parameter for the eDest disposal method */
3676 int iSdst
; /* Base register where results are written */
3677 int nSdst
; /* Number of registers allocated */
3678 char *zAffSdst
; /* Affinity used for SRT_Set */
3679 ExprList
*pOrderBy
; /* Key columns for SRT_Queue and SRT_DistQueue */
3683 ** During code generation of statements that do inserts into AUTOINCREMENT
3684 ** tables, the following information is attached to the Table.u.autoInc.p
3685 ** pointer of each autoincrement table to record some side information that
3686 ** the code generator needs. We have to keep per-table autoincrement
3687 ** information in case inserts are done within triggers. Triggers do not
3688 ** normally coordinate their activities, but we do need to coordinate the
3689 ** loading and saving of autoincrement information.
3691 struct AutoincInfo
{
3692 AutoincInfo
*pNext
; /* Next info block in a list of them all */
3693 Table
*pTab
; /* Table this info block refers to */
3694 int iDb
; /* Index in sqlite3.aDb[] of database holding pTab */
3695 int regCtr
; /* Memory register holding the rowid counter */
3699 ** At least one instance of the following structure is created for each
3700 ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
3701 ** statement. All such objects are stored in the linked list headed at
3702 ** Parse.pTriggerPrg and deleted once statement compilation has been
3705 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
3706 ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
3707 ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
3708 ** The Parse.pTriggerPrg list never contains two entries with the same
3709 ** values for both pTrigger and orconf.
3711 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
3712 ** accessed (or set to 0 for triggers fired as a result of INSERT
3713 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
3714 ** a mask of new.* columns used by the program.
3717 Trigger
*pTrigger
; /* Trigger this program was coded from */
3718 TriggerPrg
*pNext
; /* Next entry in Parse.pTriggerPrg list */
3719 SubProgram
*pProgram
; /* Program implementing pTrigger/orconf */
3720 int orconf
; /* Default ON CONFLICT policy */
3721 u32 aColmask
[2]; /* Masks of old.*, new.* columns accessed */
3725 ** The yDbMask datatype for the bitmask of all attached databases.
3727 #if SQLITE_MAX_ATTACHED>30
3728 typedef unsigned char yDbMask
[(SQLITE_MAX_ATTACHED
+9)/8];
3729 # define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0)
3730 # define DbMaskZero(M) memset((M),0,sizeof(M))
3731 # define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7))
3732 # define DbMaskAllZero(M) sqlite3DbMaskAllZero(M)
3733 # define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0)
3735 typedef unsigned int yDbMask
;
3736 # define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0)
3737 # define DbMaskZero(M) ((M)=0)
3738 # define DbMaskSet(M,I) ((M)|=(((yDbMask)1)<<(I)))
3739 # define DbMaskAllZero(M) ((M)==0)
3740 # define DbMaskNonZero(M) ((M)!=0)
3744 ** For each index X that has as one of its arguments either an expression
3745 ** or the name of a virtual generated column, and if X is in scope such that
3746 ** the value of the expression can simply be read from the index, then
3747 ** there is an instance of this object on the Parse.pIdxExpr list.
3749 ** During code generation, while generating code to evaluate expressions,
3750 ** this list is consulted and if a matching expression is found, the value
3751 ** is read from the index rather than being recomputed.
3753 struct IndexedExpr
{
3754 Expr
*pExpr
; /* The expression contained in the index */
3755 int iDataCur
; /* The data cursor associated with the index */
3756 int iIdxCur
; /* The index cursor */
3757 int iIdxCol
; /* The index column that contains value of pExpr */
3758 u8 bMaybeNullRow
; /* True if we need an OP_IfNullRow check */
3759 u8 aff
; /* Affinity of the pExpr expression */
3760 IndexedExpr
*pIENext
; /* Next in a list of all indexed expressions */
3761 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3762 const char *zIdxName
; /* Name of index, used only for bytecode comments */
3767 ** An instance of the ParseCleanup object specifies an operation that
3768 ** should be performed after parsing to deallocation resources obtained
3769 ** during the parse and which are no longer needed.
3771 struct ParseCleanup
{
3772 ParseCleanup
*pNext
; /* Next cleanup task */
3773 void *pPtr
; /* Pointer to object to deallocate */
3774 void (*xCleanup
)(sqlite3
*,void*); /* Deallocation routine */
3778 ** An SQL parser context. A copy of this structure is passed through
3779 ** the parser and down into all the parser action routine in order to
3780 ** carry around information that is global to the entire parse.
3782 ** The structure is divided into two parts. When the parser and code
3783 ** generate call themselves recursively, the first part of the structure
3784 ** is constant but the second part is reset at the beginning and end of
3787 ** The nTableLock and aTableLock variables are only used if the shared-cache
3788 ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
3789 ** used to store the set of table-locks required by the statement being
3790 ** compiled. Function sqlite3TableLock() is used to add entries to the
3794 sqlite3
*db
; /* The main database structure */
3795 char *zErrMsg
; /* An error message */
3796 Vdbe
*pVdbe
; /* An engine for executing database bytecode */
3797 int rc
; /* Return code from execution */
3798 u8 colNamesSet
; /* TRUE after OP_ColumnName has been issued to pVdbe */
3799 u8 checkSchema
; /* Causes schema cookie check after an error */
3800 u8 nested
; /* Number of nested calls to the parser/code generator */
3801 u8 nTempReg
; /* Number of temporary registers in aTempReg[] */
3802 u8 isMultiWrite
; /* True if statement may modify/insert multiple rows */
3803 u8 mayAbort
; /* True if statement may throw an ABORT exception */
3804 u8 hasCompound
; /* Need to invoke convertCompoundSelectToSubquery() */
3805 u8 okConstFactor
; /* OK to factor out constants */
3806 u8 disableLookaside
; /* Number of times lookaside has been disabled */
3807 u8 prepFlags
; /* SQLITE_PREPARE_* flags */
3808 u8 withinRJSubrtn
; /* Nesting level for RIGHT JOIN body subroutines */
3809 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
3810 u8 earlyCleanup
; /* OOM inside sqlite3ParserAddCleanup() */
3813 u8 ifNotExists
; /* Might be true if IF NOT EXISTS. Assert()s only */
3815 int nRangeReg
; /* Size of the temporary register block */
3816 int iRangeReg
; /* First register in temporary register block */
3817 int nErr
; /* Number of errors seen */
3818 int nTab
; /* Number of previously allocated VDBE cursors */
3819 int nMem
; /* Number of memory cells used so far */
3820 int szOpAlloc
; /* Bytes of memory space allocated for Vdbe.aOp[] */
3821 int iSelfTab
; /* Table associated with an index on expr, or negative
3822 ** of the base register during check-constraint eval */
3823 int nLabel
; /* The *negative* of the number of labels used */
3824 int nLabelAlloc
; /* Number of slots in aLabel */
3825 int *aLabel
; /* Space to hold the labels */
3826 ExprList
*pConstExpr
;/* Constant expressions */
3827 IndexedExpr
*pIdxEpr
;/* List of expressions used by active indexes */
3828 IndexedExpr
*pIdxPartExpr
; /* Exprs constrained by index WHERE clauses */
3829 Token constraintName
;/* Name of the constraint currently being parsed */
3830 yDbMask writeMask
; /* Start a write transaction on these databases */
3831 yDbMask cookieMask
; /* Bitmask of schema verified databases */
3832 int regRowid
; /* Register holding rowid of CREATE TABLE entry */
3833 int regRoot
; /* Register holding root page number for new objects */
3834 int nMaxArg
; /* Max args passed to user function by sub-program */
3835 int nSelect
; /* Number of SELECT stmts. Counter for Select.selId */
3836 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
3837 u32 nProgressSteps
; /* xProgress steps taken during sqlite3_prepare() */
3839 #ifndef SQLITE_OMIT_SHARED_CACHE
3840 int nTableLock
; /* Number of locks in aTableLock */
3841 TableLock
*aTableLock
; /* Required table locks for shared-cache mode */
3843 AutoincInfo
*pAinc
; /* Information about AUTOINCREMENT counters */
3844 Parse
*pToplevel
; /* Parse structure for main program (or NULL) */
3845 Table
*pTriggerTab
; /* Table triggers are being coded for */
3846 TriggerPrg
*pTriggerPrg
; /* Linked list of coded triggers */
3847 ParseCleanup
*pCleanup
; /* List of cleanup operations to run after parse */
3849 int addrCrTab
; /* Address of OP_CreateBtree on CREATE TABLE */
3850 Returning
*pReturning
; /* The RETURNING clause */
3852 u32 oldmask
; /* Mask of old.* columns referenced */
3853 u32 newmask
; /* Mask of new.* columns referenced */
3854 LogEst nQueryLoop
; /* Est number of iterations of a query (10*log2(N)) */
3855 u8 eTriggerOp
; /* TK_UPDATE, TK_INSERT or TK_DELETE */
3856 u8 bReturning
; /* Coding a RETURNING trigger */
3857 u8 eOrconf
; /* Default ON CONFLICT policy for trigger steps */
3858 u8 disableTriggers
; /* True to disable triggers */
3860 /**************************************************************************
3861 ** Fields above must be initialized to zero. The fields that follow,
3862 ** down to the beginning of the recursive section, do not need to be
3863 ** initialized as they will be set before being used. The boundary is
3864 ** determined by offsetof(Parse,aTempReg).
3865 **************************************************************************/
3867 int aTempReg
[8]; /* Holding area for temporary registers */
3868 Parse
*pOuterParse
; /* Outer Parse object when nested */
3869 Token sNameToken
; /* Token with unqualified schema object name */
3871 /************************************************************************
3872 ** Above is constant between recursions. Below is reset before and after
3873 ** each recursion. The boundary between these two regions is determined
3874 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
3875 ** first field in the recursive region.
3876 ************************************************************************/
3878 Token sLastToken
; /* The last token parsed */
3879 ynVar nVar
; /* Number of '?' variables seen in the SQL so far */
3880 u8 iPkSortOrder
; /* ASC or DESC for INTEGER PRIMARY KEY */
3881 u8 explain
; /* True if the EXPLAIN flag is found on the query */
3882 u8 eParseMode
; /* PARSE_MODE_XXX constant */
3883 #ifndef SQLITE_OMIT_VIRTUALTABLE
3884 int nVtabLock
; /* Number of virtual tables to lock */
3886 int nHeight
; /* Expression tree height of current sub-select */
3887 #ifndef SQLITE_OMIT_EXPLAIN
3888 int addrExplain
; /* Address of current OP_Explain opcode */
3890 VList
*pVList
; /* Mapping between variable names and numbers */
3891 Vdbe
*pReprepare
; /* VM being reprepared (sqlite3Reprepare()) */
3892 const char *zTail
; /* All SQL text past the last semicolon parsed */
3893 Table
*pNewTable
; /* A table being constructed by CREATE TABLE */
3894 Index
*pNewIndex
; /* An index being constructed by CREATE INDEX.
3895 ** Also used to hold redundant UNIQUE constraints
3896 ** during a RENAME COLUMN */
3897 Trigger
*pNewTrigger
; /* Trigger under construct by a CREATE TRIGGER */
3898 const char *zAuthContext
; /* The 6th parameter to db->xAuth callbacks */
3899 #ifndef SQLITE_OMIT_VIRTUALTABLE
3900 Token sArg
; /* Complete text of a module argument */
3901 Table
**apVtabLock
; /* Pointer to virtual tables needing locking */
3903 With
*pWith
; /* Current WITH clause, or NULL */
3904 #ifndef SQLITE_OMIT_ALTERTABLE
3905 RenameToken
*pRename
; /* Tokens subject to renaming by ALTER TABLE */
3909 /* Allowed values for Parse.eParseMode
3911 #define PARSE_MODE_NORMAL 0
3912 #define PARSE_MODE_DECLARE_VTAB 1
3913 #define PARSE_MODE_RENAME 2
3914 #define PARSE_MODE_UNMAP 3
3917 ** Sizes and pointers of various parts of the Parse object.
3919 #define PARSE_HDR(X) (((char*)(X))+offsetof(Parse,zErrMsg))
3920 #define PARSE_HDR_SZ (offsetof(Parse,aTempReg)-offsetof(Parse,zErrMsg)) /* Recursive part w/o aColCache*/
3921 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
3922 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
3923 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
3926 ** Return true if currently inside an sqlite3_declare_vtab() call.
3928 #ifdef SQLITE_OMIT_VIRTUALTABLE
3929 #define IN_DECLARE_VTAB 0
3931 #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)
3934 #if defined(SQLITE_OMIT_ALTERTABLE)
3935 #define IN_RENAME_OBJECT 0
3937 #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)
3940 #if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE)
3941 #define IN_SPECIAL_PARSE 0
3943 #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)
3947 ** An instance of the following structure can be declared on a stack and used
3948 ** to save the Parse.zAuthContext value so that it can be restored later.
3950 struct AuthContext
{
3951 const char *zAuthContext
; /* Put saved Parse.zAuthContext here */
3952 Parse
*pParse
; /* The Parse structure */
3956 ** Bitfield flags for P5 value in various opcodes.
3958 ** Value constraints (enforced via assert()):
3959 ** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH
3960 ** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF
3961 ** OPFLAG_BULKCSR == BTREE_BULKLOAD
3962 ** OPFLAG_SEEKEQ == BTREE_SEEK_EQ
3963 ** OPFLAG_FORDELETE == BTREE_FORDELETE
3964 ** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
3965 ** OPFLAG_AUXDELETE == BTREE_AUXDELETE
3967 #define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
3968 /* Also used in P2 (not P5) of OP_Delete */
3969 #define OPFLAG_NOCHNG 0x01 /* OP_VColumn nochange for UPDATE */
3970 #define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
3971 #define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
3972 #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
3973 #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
3974 #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
3975 #define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
3976 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
3977 #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
3978 #define OPFLAG_BYTELENARG 0xc0 /* OP_Column only for octet_length() */
3979 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
3980 #define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
3981 #define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
3982 #define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
3983 #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
3984 #define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */
3985 #define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */
3986 #define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */
3987 #define OPFLAG_PREFORMAT 0x80 /* OP_Insert uses preformatted cell */
3990 ** Each trigger present in the database schema is stored as an instance of
3993 ** Pointers to instances of struct Trigger are stored in two ways.
3994 ** 1. In the "trigHash" hash table (part of the sqlite3* that represents the
3995 ** database). This allows Trigger structures to be retrieved by name.
3996 ** 2. All triggers associated with a single table form a linked list, using the
3997 ** pNext member of struct Trigger. A pointer to the first element of the
3998 ** linked list is stored as the "pTrigger" member of the associated
4001 ** The "step_list" member points to the first element of a linked list
4002 ** containing the SQL statements specified as the trigger program.
4005 char *zName
; /* The name of the trigger */
4006 char *table
; /* The table or view to which the trigger applies */
4007 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
4008 u8 tr_tm
; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
4009 u8 bReturning
; /* This trigger implements a RETURNING clause */
4010 Expr
*pWhen
; /* The WHEN clause of the expression (may be NULL) */
4011 IdList
*pColumns
; /* If this is an UPDATE OF <column-list> trigger,
4012 the <column-list> is stored here */
4013 Schema
*pSchema
; /* Schema containing the trigger */
4014 Schema
*pTabSchema
; /* Schema containing the table */
4015 TriggerStep
*step_list
; /* Link list of trigger program steps */
4016 Trigger
*pNext
; /* Next trigger associated with the table */
4020 ** A trigger is either a BEFORE or an AFTER trigger. The following constants
4023 ** If there are multiple triggers, you might of some BEFORE and some AFTER.
4024 ** In that cases, the constants below can be ORed together.
4026 #define TRIGGER_BEFORE 1
4027 #define TRIGGER_AFTER 2
4030 ** An instance of struct TriggerStep is used to store a single SQL statement
4031 ** that is a part of a trigger-program.
4033 ** Instances of struct TriggerStep are stored in a singly linked list (linked
4034 ** using the "pNext" member) referenced by the "step_list" member of the
4035 ** associated struct Trigger instance. The first element of the linked list is
4036 ** the first step of the trigger-program.
4038 ** The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
4039 ** "SELECT" statement. The meanings of the other members is determined by the
4040 ** value of "op" as follows:
4042 ** (op == TK_INSERT)
4043 ** orconf -> stores the ON CONFLICT algorithm
4044 ** pSelect -> The content to be inserted - either a SELECT statement or
4046 ** zTarget -> Dequoted name of the table to insert into.
4047 ** pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
4048 ** statement, then this stores the column-names to be
4050 ** pUpsert -> The ON CONFLICT clauses for an Upsert
4052 ** (op == TK_DELETE)
4053 ** zTarget -> Dequoted name of the table to delete from.
4054 ** pWhere -> The WHERE clause of the DELETE statement if one is specified.
4057 ** (op == TK_UPDATE)
4058 ** zTarget -> Dequoted name of the table to update.
4059 ** pWhere -> The WHERE clause of the UPDATE statement if one is specified.
4061 ** pExprList -> A list of the columns to update and the expressions to update
4062 ** them to. See sqlite3Update() documentation of "pChanges"
4065 ** (op == TK_SELECT)
4066 ** pSelect -> The SELECT statement
4068 ** (op == TK_RETURNING)
4069 ** pExprList -> The list of expressions that follow the RETURNING keyword.
4072 struct TriggerStep
{
4073 u8 op
; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT,
4074 ** or TK_RETURNING */
4075 u8 orconf
; /* OE_Rollback etc. */
4076 Trigger
*pTrig
; /* The trigger that this step is a part of */
4077 Select
*pSelect
; /* SELECT statement or RHS of INSERT INTO SELECT ... */
4078 char *zTarget
; /* Target table for DELETE, UPDATE, INSERT */
4079 SrcList
*pFrom
; /* FROM clause for UPDATE statement (if any) */
4080 Expr
*pWhere
; /* The WHERE clause for DELETE or UPDATE steps */
4081 ExprList
*pExprList
; /* SET clause for UPDATE, or RETURNING clause */
4082 IdList
*pIdList
; /* Column names for INSERT */
4083 Upsert
*pUpsert
; /* Upsert clauses on an INSERT */
4084 char *zSpan
; /* Original SQL text of this command */
4085 TriggerStep
*pNext
; /* Next in the link-list */
4086 TriggerStep
*pLast
; /* Last element in link-list. Valid for 1st elem only */
4090 ** Information about a RETURNING clause
4093 Parse
*pParse
; /* The parse that includes the RETURNING clause */
4094 ExprList
*pReturnEL
; /* List of expressions to return */
4095 Trigger retTrig
; /* The transient trigger that implements RETURNING */
4096 TriggerStep retTStep
; /* The trigger step */
4097 int iRetCur
; /* Transient table holding RETURNING results */
4098 int nRetCol
; /* Number of in pReturnEL after expansion */
4099 int iRetReg
; /* Register array for holding a row of RETURNING */
4100 char zName
[40]; /* Name of trigger: "sqlite_returning_%p" */
4104 ** An objected used to accumulate the text of a string where we
4105 ** do not necessarily know how big the string will be in the end.
4107 struct sqlite3_str
{
4108 sqlite3
*db
; /* Optional database for lookaside. Can be NULL */
4109 char *zText
; /* The string collected so far */
4110 u32 nAlloc
; /* Amount of space allocated in zText */
4111 u32 mxAlloc
; /* Maximum allowed allocation. 0 for no malloc usage */
4112 u32 nChar
; /* Length of the string so far */
4113 u8 accError
; /* SQLITE_NOMEM or SQLITE_TOOBIG */
4114 u8 printfFlags
; /* SQLITE_PRINTF flags below */
4116 #define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
4117 #define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */
4118 #define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */
4120 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
4123 ** The following object is the header for an "RCStr" or "reference-counted
4124 ** string". An RCStr is passed around and used like any other char*
4125 ** that has been dynamically allocated. The important interface
4128 ** 1. RCStr strings are reference counted. They are deallocated
4129 ** when the reference count reaches zero.
4131 ** 2. Use sqlite3RCStrUnref() to free an RCStr string rather than
4134 ** 3. Make a (read-only) copy of a read-only RCStr string using
4135 ** sqlite3RCStrRef().
4137 ** "String" is in the name, but an RCStr object can also be used to hold
4141 u64 nRCRef
; /* Number of references */
4142 /* Total structure size should be a multiple of 8 bytes for alignment */
4146 ** A pointer to this structure is used to communicate information
4147 ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
4150 sqlite3
*db
; /* The database being initialized */
4151 char **pzErrMsg
; /* Error message stored here */
4152 int iDb
; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
4153 int rc
; /* Result code stored here */
4154 u32 mInitFlags
; /* Flags controlling error messages */
4155 u32 nInitRow
; /* Number of rows processed */
4156 Pgno mxPage
; /* Maximum page number. 0 for no limit. */
4160 ** Allowed values for mInitFlags
4162 #define INITFLAG_AlterMask 0x0003 /* Types of ALTER */
4163 #define INITFLAG_AlterRename 0x0001 /* Reparse after a RENAME */
4164 #define INITFLAG_AlterDrop 0x0002 /* Reparse after a DROP COLUMN */
4165 #define INITFLAG_AlterAdd 0x0003 /* Reparse after an ADD COLUMN */
4167 /* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
4168 ** on debug-builds of the CLI using ".testctrl tune ID VALUE". Tuning
4169 ** parameters are for temporary use during development, to help find
4170 ** optimal values for parameters in the query planner. The should not
4171 ** be used on trunk check-ins. They are a temporary mechanism available
4172 ** for transient development builds only.
4174 ** Tuning parameters are numbered starting with 1.
4176 #define SQLITE_NTUNE 6 /* Should be zero for all trunk check-ins */
4178 # define Tuning(X) (sqlite3Config.aTune[(X)-1])
4180 # define Tuning(X) 0
4184 ** Structure containing global configuration data for the SQLite library.
4186 ** This structure also contains some state information.
4188 struct Sqlite3Config
{
4189 int bMemstat
; /* True to enable memory status */
4190 u8 bCoreMutex
; /* True to enable core mutexing */
4191 u8 bFullMutex
; /* True to enable full mutexing */
4192 u8 bOpenUri
; /* True to interpret filenames as URIs */
4193 u8 bUseCis
; /* Use covering indices for full-scans */
4194 u8 bSmallMalloc
; /* Avoid large memory allocations if true */
4195 u8 bExtraSchemaChecks
; /* Verify type,name,tbl_name in schema */
4196 u8 bUseLongDouble
; /* Make use of long double */
4198 u8 bJsonSelfcheck
; /* Double-check JSON parsing */
4200 int mxStrlen
; /* Maximum string length */
4201 int neverCorrupt
; /* Database is always well-formed */
4202 int szLookaside
; /* Default lookaside buffer size */
4203 int nLookaside
; /* Default lookaside buffer count */
4204 int nStmtSpill
; /* Stmt-journal spill-to-disk threshold */
4205 sqlite3_mem_methods m
; /* Low-level memory allocation interface */
4206 sqlite3_mutex_methods mutex
; /* Low-level mutex interface */
4207 sqlite3_pcache_methods2 pcache2
; /* Low-level page-cache interface */
4208 void *pHeap
; /* Heap storage space */
4209 int nHeap
; /* Size of pHeap[] */
4210 int mnReq
, mxReq
; /* Min and max heap requests sizes */
4211 sqlite3_int64 szMmap
; /* mmap() space per open file */
4212 sqlite3_int64 mxMmap
; /* Maximum value for szMmap */
4213 void *pPage
; /* Page cache memory */
4214 int szPage
; /* Size of each page in pPage[] */
4215 int nPage
; /* Number of pages in pPage[] */
4216 int mxParserStack
; /* maximum depth of the parser stack */
4217 int sharedCacheEnabled
; /* true if shared-cache mode enabled */
4218 u32 szPma
; /* Maximum Sorter PMA size */
4219 /* The above might be initialized to non-zero. The following need to always
4220 ** initially be zero, however. */
4221 int isInit
; /* True after initialization has finished */
4222 int inProgress
; /* True while initialization in progress */
4223 int isMutexInit
; /* True after mutexes are initialized */
4224 int isMallocInit
; /* True after malloc is initialized */
4225 int isPCacheInit
; /* True after malloc is initialized */
4226 int nRefInitMutex
; /* Number of users of pInitMutex */
4227 sqlite3_mutex
*pInitMutex
; /* Mutex used by sqlite3_initialize() */
4228 void (*xLog
)(void*,int,const char*); /* Function for logging */
4229 void *pLogArg
; /* First argument to xLog() */
4230 #ifdef SQLITE_ENABLE_SQLLOG
4231 void(*xSqllog
)(void*,sqlite3
*,const char*, int);
4234 #ifdef SQLITE_VDBE_COVERAGE
4235 /* The following callback (if not NULL) is invoked on every VDBE branch
4236 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
4238 void (*xVdbeBranch
)(void*,unsigned iSrcLine
,u8 eThis
,u8 eMx
); /* Callback */
4239 void *pVdbeBranchArg
; /* 1st argument */
4241 #ifndef SQLITE_OMIT_DESERIALIZE
4242 sqlite3_int64 mxMemdbSize
; /* Default max memdb size */
4244 #ifndef SQLITE_UNTESTABLE
4245 int (*xTestCallback
)(int); /* Invoked by sqlite3FaultSim() */
4247 int bLocaltimeFault
; /* True to fail localtime() calls */
4248 int (*xAltLocaltime
)(const void*,void*); /* Alternative localtime() routine */
4249 int iOnceResetThreshold
; /* When to reset OP_Once counters */
4250 u32 szSorterRef
; /* Min size in bytes to use sorter-refs */
4251 unsigned int iPrngSeed
; /* Alternative fixed seed for the PRNG */
4252 /* vvvv--- must be last ---vvv */
4254 sqlite3_int64 aTune
[SQLITE_NTUNE
]; /* Tuning parameters */
4259 ** This macro is used inside of assert() statements to indicate that
4260 ** the assert is only valid on a well-formed database. Instead of:
4266 ** assert( X || CORRUPT_DB );
4268 ** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate
4269 ** that the database is definitely corrupt, only that it might be corrupt.
4270 ** For most test cases, CORRUPT_DB is set to false using a special
4271 ** sqlite3_test_control(). This enables assert() statements to prove
4272 ** things that are always true for well-formed databases.
4274 #define CORRUPT_DB (sqlite3Config.neverCorrupt==0)
4277 ** Context pointer passed down through the tree-walk.
4280 Parse
*pParse
; /* Parser context. */
4281 int (*xExprCallback
)(Walker
*, Expr
*); /* Callback for expressions */
4282 int (*xSelectCallback
)(Walker
*,Select
*); /* Callback for SELECTs */
4283 void (*xSelectCallback2
)(Walker
*,Select
*);/* Second callback for SELECTs */
4284 int walkerDepth
; /* Number of subqueries */
4285 u16 eCode
; /* A small processing code */
4286 u16 mWFlags
; /* Use-dependent flags */
4287 union { /* Extra data for callback */
4288 NameContext
*pNC
; /* Naming context */
4289 int n
; /* A counter */
4290 int iCur
; /* A cursor number */
4291 SrcList
*pSrcList
; /* FROM clause */
4292 struct CCurHint
*pCCurHint
; /* Used by codeCursorHint() */
4293 struct RefSrcList
*pRefSrcList
; /* sqlite3ReferencesSrcList() */
4294 int *aiCol
; /* array of column indexes */
4295 struct IdxCover
*pIdxCover
; /* Check for index coverage */
4296 ExprList
*pGroupBy
; /* GROUP BY clause */
4297 Select
*pSelect
; /* HAVING to WHERE clause ctx */
4298 struct WindowRewrite
*pRewrite
; /* Window rewrite context */
4299 struct WhereConst
*pConst
; /* WHERE clause constants */
4300 struct RenameCtx
*pRename
; /* RENAME COLUMN context */
4301 struct Table
*pTab
; /* Table of generated column */
4302 struct CoveringIndexCheck
*pCovIdxCk
; /* Check for covering index */
4303 SrcItem
*pSrcItem
; /* A single FROM clause item */
4304 DbFixer
*pFix
; /* See sqlite3FixSelect() */
4305 Mem
*aMem
; /* See sqlite3BtreeCursorHint() */
4310 ** The following structure contains information used by the sqliteFix...
4311 ** routines as they walk the parse tree to make database references
4315 Parse
*pParse
; /* The parsing context. Error messages written here */
4316 Walker w
; /* Walker object */
4317 Schema
*pSchema
; /* Fix items to this schema */
4318 u8 bTemp
; /* True for TEMP schema entries */
4319 const char *zDb
; /* Make sure all objects are contained in this database */
4320 const char *zType
; /* Type of the container - used for error messages */
4321 const Token
*pName
; /* Name of the container - used for error messages */
4324 /* Forward declarations */
4325 int sqlite3WalkExpr(Walker
*, Expr
*);
4326 int sqlite3WalkExprNN(Walker
*, Expr
*);
4327 int sqlite3WalkExprList(Walker
*, ExprList
*);
4328 int sqlite3WalkSelect(Walker
*, Select
*);
4329 int sqlite3WalkSelectExpr(Walker
*, Select
*);
4330 int sqlite3WalkSelectFrom(Walker
*, Select
*);
4331 int sqlite3ExprWalkNoop(Walker
*, Expr
*);
4332 int sqlite3SelectWalkNoop(Walker
*, Select
*);
4333 int sqlite3SelectWalkFail(Walker
*, Select
*);
4334 int sqlite3WalkerDepthIncrease(Walker
*,Select
*);
4335 void sqlite3WalkerDepthDecrease(Walker
*,Select
*);
4336 void sqlite3WalkWinDefnDummyCallback(Walker
*,Select
*);
4339 void sqlite3SelectWalkAssert2(Walker
*, Select
*);
4342 #ifndef SQLITE_OMIT_CTE
4343 void sqlite3SelectPopWith(Walker
*, Select
*);
4345 # define sqlite3SelectPopWith 0
4349 ** Return code from the parse-tree walking primitives and their
4352 #define WRC_Continue 0 /* Continue down into children */
4353 #define WRC_Prune 1 /* Omit children but continue walking siblings */
4354 #define WRC_Abort 2 /* Abandon the tree walk */
4357 ** A single common table expression
4360 char *zName
; /* Name of this CTE */
4361 ExprList
*pCols
; /* List of explicit column names, or NULL */
4362 Select
*pSelect
; /* The definition of this CTE */
4363 const char *zCteErr
; /* Error message for circular references */
4364 CteUse
*pUse
; /* Usage information for this CTE */
4365 u8 eM10d
; /* The MATERIALIZED flag */
4369 ** Allowed values for the materialized flag (eM10d):
4371 #define M10d_Yes 0 /* AS MATERIALIZED */
4372 #define M10d_Any 1 /* Not specified. Query planner's choice */
4373 #define M10d_No 2 /* AS NOT MATERIALIZED */
4376 ** An instance of the With object represents a WITH clause containing
4377 ** one or more CTEs (common table expressions).
4380 int nCte
; /* Number of CTEs in the WITH clause */
4381 int bView
; /* Belongs to the outermost Select of a view */
4382 With
*pOuter
; /* Containing WITH clause, or NULL */
4383 Cte a
[1]; /* For each CTE in the WITH clause.... */
4387 ** The Cte object is not guaranteed to persist for the entire duration
4388 ** of code generation. (The query flattener or other parser tree
4389 ** edits might delete it.) The following object records information
4390 ** about each Common Table Expression that must be preserved for the
4391 ** duration of the parse.
4393 ** The CteUse objects are freed using sqlite3ParserAddCleanup() rather
4394 ** than sqlite3SelectDelete(), which is what enables them to persist
4395 ** until the end of code generation.
4398 int nUse
; /* Number of users of this CTE */
4399 int addrM9e
; /* Start of subroutine to compute materialization */
4400 int regRtn
; /* Return address register for addrM9e subroutine */
4401 int iCur
; /* Ephemeral table holding the materialization */
4402 LogEst nRowEst
; /* Estimated number of rows in the table */
4403 u8 eM10d
; /* The MATERIALIZED flag */
4407 /* Client data associated with sqlite3_set_clientdata() and
4408 ** sqlite3_get_clientdata().
4410 struct DbClientData
{
4411 DbClientData
*pNext
; /* Next in a linked list */
4412 void *pData
; /* The data */
4413 void (*xDestructor
)(void*); /* Destructor. Might be NULL */
4414 char zName
[1]; /* Name of this client data. MUST BE LAST */
4419 ** An instance of the TreeView object is used for printing the content of
4420 ** data structures on sqlite3DebugPrintf() using a tree-like view.
4423 int iLevel
; /* Which level of the tree we are on */
4424 u8 bLine
[100]; /* Draw vertical in column i if bLine[i] is true */
4426 #endif /* SQLITE_DEBUG */
4429 ** This object is used in various ways, most (but not all) related to window
4432 ** (1) A single instance of this structure is attached to the
4433 ** the Expr.y.pWin field for each window function in an expression tree.
4434 ** This object holds the information contained in the OVER clause,
4435 ** plus additional fields used during code generation.
4437 ** (2) All window functions in a single SELECT form a linked-list
4438 ** attached to Select.pWin. The Window.pFunc and Window.pExpr
4439 ** fields point back to the expression that is the window function.
4441 ** (3) The terms of the WINDOW clause of a SELECT are instances of this
4442 ** object on a linked list attached to Select.pWinDefn.
4444 ** (4) For an aggregate function with a FILTER clause, an instance
4445 ** of this object is stored in Expr.y.pWin with eFrmType set to
4446 ** TK_FILTER. In this case the only field used is Window.pFilter.
4448 ** The uses (1) and (2) are really the same Window object that just happens
4449 ** to be accessible in two different ways. Use case (3) are separate objects.
4452 char *zName
; /* Name of window (may be NULL) */
4453 char *zBase
; /* Name of base window for chaining (may be NULL) */
4454 ExprList
*pPartition
; /* PARTITION BY clause */
4455 ExprList
*pOrderBy
; /* ORDER BY clause */
4456 u8 eFrmType
; /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */
4457 u8 eStart
; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
4458 u8 eEnd
; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
4459 u8 bImplicitFrame
; /* True if frame was implicitly specified */
4460 u8 eExclude
; /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */
4461 Expr
*pStart
; /* Expression for "<expr> PRECEDING" */
4462 Expr
*pEnd
; /* Expression for "<expr> FOLLOWING" */
4463 Window
**ppThis
; /* Pointer to this object in Select.pWin list */
4464 Window
*pNextWin
; /* Next window function belonging to this SELECT */
4465 Expr
*pFilter
; /* The FILTER expression */
4466 FuncDef
*pWFunc
; /* The function */
4467 int iEphCsr
; /* Partition buffer or Peer buffer */
4468 int regAccum
; /* Accumulator */
4469 int regResult
; /* Interim result */
4470 int csrApp
; /* Function cursor (used by min/max) */
4471 int regApp
; /* Function register (also used by min/max) */
4472 int regPart
; /* Array of registers for PARTITION BY values */
4473 Expr
*pOwner
; /* Expression object this window is attached to */
4474 int nBufferCol
; /* Number of columns in buffer table */
4475 int iArgCol
; /* Offset of first argument for this function */
4476 int regOne
; /* Register containing constant value 1 */
4479 u8 bExprArgs
; /* Defer evaluation of window function arguments
4480 ** due to the SQLITE_SUBTYPE flag */
4483 #ifndef SQLITE_OMIT_WINDOWFUNC
4484 void sqlite3WindowDelete(sqlite3
*, Window
*);
4485 void sqlite3WindowUnlinkFromSelect(Window
*);
4486 void sqlite3WindowListDelete(sqlite3
*db
, Window
*p
);
4487 Window
*sqlite3WindowAlloc(Parse
*, int, int, Expr
*, int , Expr
*, u8
);
4488 void sqlite3WindowAttach(Parse
*, Expr
*, Window
*);
4489 void sqlite3WindowLink(Select
*pSel
, Window
*pWin
);
4490 int sqlite3WindowCompare(const Parse
*, const Window
*, const Window
*, int);
4491 void sqlite3WindowCodeInit(Parse
*, Select
*);
4492 void sqlite3WindowCodeStep(Parse
*, Select
*, WhereInfo
*, int, int);
4493 int sqlite3WindowRewrite(Parse
*, Select
*);
4494 void sqlite3WindowUpdate(Parse
*, Window
*, Window
*, FuncDef
*);
4495 Window
*sqlite3WindowDup(sqlite3
*db
, Expr
*pOwner
, Window
*p
);
4496 Window
*sqlite3WindowListDup(sqlite3
*db
, Window
*p
);
4497 void sqlite3WindowFunctions(void);
4498 void sqlite3WindowChain(Parse
*, Window
*, Window
*);
4499 Window
*sqlite3WindowAssemble(Parse
*, Window
*, ExprList
*, ExprList
*, Token
*);
4501 # define sqlite3WindowDelete(a,b)
4502 # define sqlite3WindowFunctions()
4503 # define sqlite3WindowAttach(a,b,c)
4507 ** Assuming zIn points to the first byte of a UTF-8 character,
4508 ** advance zIn to point to the first byte of the next UTF-8 character.
4510 #define SQLITE_SKIP_UTF8(zIn) { \
4511 if( (*(zIn++))>=0xc0 ){ \
4512 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
4517 ** The SQLITE_*_BKPT macros are substitutes for the error codes with
4518 ** the same name but without the _BKPT suffix. These macros invoke
4519 ** routines that report the line-number on which the error originated
4520 ** using sqlite3_log(). The routines also provide a convenient place
4521 ** to set a debugger breakpoint.
4523 int sqlite3ReportError(int iErr
, int lineno
, const char *zType
);
4524 int sqlite3CorruptError(int);
4525 int sqlite3MisuseError(int);
4526 int sqlite3CantopenError(int);
4527 #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
4528 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
4529 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
4531 int sqlite3NomemError(int);
4532 int sqlite3IoerrnomemError(int);
4533 # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
4534 # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
4536 # define SQLITE_NOMEM_BKPT SQLITE_NOMEM
4537 # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
4539 #if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO)
4540 int sqlite3CorruptPgnoError(int,Pgno
);
4541 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P))
4543 # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__)
4547 ** FTS3 and FTS4 both require virtual table support
4549 #if defined(SQLITE_OMIT_VIRTUALTABLE)
4550 # undef SQLITE_ENABLE_FTS3
4551 # undef SQLITE_ENABLE_FTS4
4555 ** FTS4 is really an extension for FTS3. It is enabled using the
4556 ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call
4557 ** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
4559 #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
4560 # define SQLITE_ENABLE_FTS3 1
4564 ** The ctype.h header is needed for non-ASCII systems. It is also
4565 ** needed by FTS3 when FTS3 is included in the amalgamation.
4567 #if !defined(SQLITE_ASCII) || \
4568 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
4573 ** The following macros mimic the standard library functions toupper(),
4574 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
4575 ** sqlite versions only work for ASCII characters, regardless of locale.
4578 # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
4579 # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
4580 # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
4581 # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
4582 # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
4583 # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
4584 # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
4585 # define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
4586 # define sqlite3JsonId1(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x42)
4587 # define sqlite3JsonId2(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x46)
4589 # define sqlite3Toupper(x) toupper((unsigned char)(x))
4590 # define sqlite3Isspace(x) isspace((unsigned char)(x))
4591 # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
4592 # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
4593 # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
4594 # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
4595 # define sqlite3Tolower(x) tolower((unsigned char)(x))
4596 # define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
4597 # define sqlite3JsonId1(x) (sqlite3IsIdChar(x)&&(x)<'0')
4598 # define sqlite3JsonId2(x) sqlite3IsIdChar(x)
4600 int sqlite3IsIdChar(u8
);
4603 ** Internal function prototypes
4605 int sqlite3StrICmp(const char*,const char*);
4606 int sqlite3Strlen30(const char*);
4607 #define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff)
4608 char *sqlite3ColumnType(Column
*,char*);
4609 #define sqlite3StrNICmp sqlite3_strnicmp
4611 int sqlite3MallocInit(void);
4612 void sqlite3MallocEnd(void);
4613 void *sqlite3Malloc(u64
);
4614 void *sqlite3MallocZero(u64
);
4615 void *sqlite3DbMallocZero(sqlite3
*, u64
);
4616 void *sqlite3DbMallocRaw(sqlite3
*, u64
);
4617 void *sqlite3DbMallocRawNN(sqlite3
*, u64
);
4618 char *sqlite3DbStrDup(sqlite3
*,const char*);
4619 char *sqlite3DbStrNDup(sqlite3
*,const char*, u64
);
4620 char *sqlite3DbSpanDup(sqlite3
*,const char*,const char*);
4621 void *sqlite3Realloc(void*, u64
);
4622 void *sqlite3DbReallocOrFree(sqlite3
*, void *, u64
);
4623 void *sqlite3DbRealloc(sqlite3
*, void *, u64
);
4624 void sqlite3DbFree(sqlite3
*, void*);
4625 void sqlite3DbFreeNN(sqlite3
*, void*);
4626 void sqlite3DbNNFreeNN(sqlite3
*, void*);
4627 int sqlite3MallocSize(const void*);
4628 int sqlite3DbMallocSize(sqlite3
*, const void*);
4629 void *sqlite3PageMalloc(int);
4630 void sqlite3PageFree(void*);
4631 void sqlite3MemSetDefault(void);
4632 #ifndef SQLITE_UNTESTABLE
4633 void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
4635 int sqlite3HeapNearlyFull(void);
4638 ** On systems with ample stack space and that support alloca(), make
4639 ** use of alloca() to obtain space for large automatic objects. By default,
4640 ** obtain space from malloc().
4642 ** The alloca() routine never returns NULL. This will cause code paths
4643 ** that deal with sqlite3StackAlloc() failures to be unreachable.
4645 #ifdef SQLITE_USE_ALLOCA
4646 # define sqlite3StackAllocRaw(D,N) alloca(N)
4647 # define sqlite3StackAllocRawNN(D,N) alloca(N)
4648 # define sqlite3StackFree(D,P)
4649 # define sqlite3StackFreeNN(D,P)
4651 # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
4652 # define sqlite3StackAllocRawNN(D,N) sqlite3DbMallocRawNN(D,N)
4653 # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
4654 # define sqlite3StackFreeNN(D,P) sqlite3DbFreeNN(D,P)
4657 /* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they
4658 ** are, disable MEMSYS3
4660 #ifdef SQLITE_ENABLE_MEMSYS5
4661 const sqlite3_mem_methods
*sqlite3MemGetMemsys5(void);
4662 #undef SQLITE_ENABLE_MEMSYS3
4664 #ifdef SQLITE_ENABLE_MEMSYS3
4665 const sqlite3_mem_methods
*sqlite3MemGetMemsys3(void);
4669 #ifndef SQLITE_MUTEX_OMIT
4670 sqlite3_mutex_methods
const *sqlite3DefaultMutex(void);
4671 sqlite3_mutex_methods
const *sqlite3NoopMutex(void);
4672 sqlite3_mutex
*sqlite3MutexAlloc(int);
4673 int sqlite3MutexInit(void);
4674 int sqlite3MutexEnd(void);
4676 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
4677 void sqlite3MemoryBarrier(void);
4679 # define sqlite3MemoryBarrier()
4682 sqlite3_int64
sqlite3StatusValue(int);
4683 void sqlite3StatusUp(int, int);
4684 void sqlite3StatusDown(int, int);
4685 void sqlite3StatusHighwater(int, int);
4686 int sqlite3LookasideUsed(sqlite3
*,int*);
4688 /* Access to mutexes used by sqlite3_status() */
4689 sqlite3_mutex
*sqlite3Pcache1Mutex(void);
4690 sqlite3_mutex
*sqlite3MallocMutex(void);
4692 #if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT)
4693 void sqlite3MutexWarnOnContention(sqlite3_mutex
*);
4695 # define sqlite3MutexWarnOnContention(x)
4698 #ifndef SQLITE_OMIT_FLOATING_POINT
4699 # define EXP754 (((u64)0x7ff)<<52)
4700 # define MAN754 ((((u64)1)<<52)-1)
4701 # define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)
4702 int sqlite3IsNaN(double);
4705 # define sqlite3IsNaN(X) 0
4709 ** An instance of the following structure holds information about SQL
4710 ** functions arguments that are the parameters to the printf() function.
4712 struct PrintfArguments
{
4713 int nArg
; /* Total number of arguments */
4714 int nUsed
; /* Number of arguments used so far */
4715 sqlite3_value
**apArg
; /* The argument values */
4719 ** An instance of this object receives the decoding of a floating point
4720 ** value into an approximate decimal representation.
4723 char sign
; /* '+' or '-' */
4724 char isSpecial
; /* 1: Infinity 2: NaN */
4725 int n
; /* Significant digits in the decode */
4726 int iDP
; /* Location of the decimal point */
4727 char *z
; /* Start of significant digits */
4728 char zBuf
[24]; /* Storage for significant digits */
4731 void sqlite3FpDecode(FpDecode
*,double,int,int);
4732 char *sqlite3MPrintf(sqlite3
*,const char*, ...);
4733 char *sqlite3VMPrintf(sqlite3
*,const char*, va_list);
4734 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
4735 void sqlite3DebugPrintf(const char*, ...);
4737 #if defined(SQLITE_TEST)
4738 void *sqlite3TestTextToPtr(const char*);
4741 #if defined(SQLITE_DEBUG)
4742 void sqlite3TreeViewLine(TreeView
*, const char *zFormat
, ...);
4743 void sqlite3TreeViewExpr(TreeView
*, const Expr
*, u8
);
4744 void sqlite3TreeViewBareExprList(TreeView
*, const ExprList
*, const char*);
4745 void sqlite3TreeViewExprList(TreeView
*, const ExprList
*, u8
, const char*);
4746 void sqlite3TreeViewBareIdList(TreeView
*, const IdList
*, const char*);
4747 void sqlite3TreeViewIdList(TreeView
*, const IdList
*, u8
, const char*);
4748 void sqlite3TreeViewColumnList(TreeView
*, const Column
*, int, u8
);
4749 void sqlite3TreeViewSrcList(TreeView
*, const SrcList
*);
4750 void sqlite3TreeViewSelect(TreeView
*, const Select
*, u8
);
4751 void sqlite3TreeViewWith(TreeView
*, const With
*, u8
);
4752 void sqlite3TreeViewUpsert(TreeView
*, const Upsert
*, u8
);
4753 #if TREETRACE_ENABLED
4754 void sqlite3TreeViewDelete(const With
*, const SrcList
*, const Expr
*,
4755 const ExprList
*,const Expr
*, const Trigger
*);
4756 void sqlite3TreeViewInsert(const With
*, const SrcList
*,
4757 const IdList
*, const Select
*, const ExprList
*,
4758 int, const Upsert
*, const Trigger
*);
4759 void sqlite3TreeViewUpdate(const With
*, const SrcList
*, const ExprList
*,
4760 const Expr
*, int, const ExprList
*, const Expr
*,
4761 const Upsert
*, const Trigger
*);
4763 #ifndef SQLITE_OMIT_TRIGGER
4764 void sqlite3TreeViewTriggerStep(TreeView
*, const TriggerStep
*, u8
, u8
);
4765 void sqlite3TreeViewTrigger(TreeView
*, const Trigger
*, u8
, u8
);
4767 #ifndef SQLITE_OMIT_WINDOWFUNC
4768 void sqlite3TreeViewWindow(TreeView
*, const Window
*, u8
);
4769 void sqlite3TreeViewWinFunc(TreeView
*, const Window
*, u8
);
4771 void sqlite3ShowExpr(const Expr
*);
4772 void sqlite3ShowExprList(const ExprList
*);
4773 void sqlite3ShowIdList(const IdList
*);
4774 void sqlite3ShowSrcList(const SrcList
*);
4775 void sqlite3ShowSelect(const Select
*);
4776 void sqlite3ShowWith(const With
*);
4777 void sqlite3ShowUpsert(const Upsert
*);
4778 #ifndef SQLITE_OMIT_TRIGGER
4779 void sqlite3ShowTriggerStep(const TriggerStep
*);
4780 void sqlite3ShowTriggerStepList(const TriggerStep
*);
4781 void sqlite3ShowTrigger(const Trigger
*);
4782 void sqlite3ShowTriggerList(const Trigger
*);
4784 #ifndef SQLITE_OMIT_WINDOWFUNC
4785 void sqlite3ShowWindow(const Window
*);
4786 void sqlite3ShowWinFunc(const Window
*);
4790 void sqlite3SetString(char **, sqlite3
*, const char*);
4791 void sqlite3ProgressCheck(Parse
*);
4792 void sqlite3ErrorMsg(Parse
*, const char*, ...);
4793 int sqlite3ErrorToParser(sqlite3
*,int);
4794 void sqlite3Dequote(char*);
4795 void sqlite3DequoteExpr(Expr
*);
4796 void sqlite3DequoteToken(Token
*);
4797 void sqlite3DequoteNumber(Parse
*, Expr
*);
4798 void sqlite3TokenInit(Token
*,char*);
4799 int sqlite3KeywordCode(const unsigned char*, int);
4800 int sqlite3RunParser(Parse
*, const char*);
4801 void sqlite3FinishCoding(Parse
*);
4802 int sqlite3GetTempReg(Parse
*);
4803 void sqlite3ReleaseTempReg(Parse
*,int);
4804 int sqlite3GetTempRange(Parse
*,int);
4805 void sqlite3ReleaseTempRange(Parse
*,int,int);
4806 void sqlite3ClearTempRegCache(Parse
*);
4807 void sqlite3TouchRegister(Parse
*,int);
4808 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
4809 int sqlite3FirstAvailableRegister(Parse
*,int);
4812 int sqlite3NoTempsInRange(Parse
*,int,int);
4814 Expr
*sqlite3ExprAlloc(sqlite3
*,int,const Token
*,int);
4815 Expr
*sqlite3Expr(sqlite3
*,int,const char*);
4816 void sqlite3ExprAttachSubtrees(sqlite3
*,Expr
*,Expr
*,Expr
*);
4817 Expr
*sqlite3PExpr(Parse
*, int, Expr
*, Expr
*);
4818 void sqlite3PExprAddSelect(Parse
*, Expr
*, Select
*);
4819 Expr
*sqlite3ExprAnd(Parse
*,Expr
*, Expr
*);
4820 Expr
*sqlite3ExprSimplifiedAndOr(Expr
*);
4821 Expr
*sqlite3ExprFunction(Parse
*,ExprList
*, const Token
*, int);
4822 void sqlite3ExprAddFunctionOrderBy(Parse
*,Expr
*,ExprList
*);
4823 void sqlite3ExprOrderByAggregateError(Parse
*,Expr
*);
4824 void sqlite3ExprFunctionUsable(Parse
*,const Expr
*,const FuncDef
*);
4825 void sqlite3ExprAssignVarNumber(Parse
*, Expr
*, u32
);
4826 void sqlite3ExprDelete(sqlite3
*, Expr
*);
4827 void sqlite3ExprDeleteGeneric(sqlite3
*,void*);
4828 void sqlite3ExprDeferredDelete(Parse
*, Expr
*);
4829 void sqlite3ExprUnmapAndDelete(Parse
*, Expr
*);
4830 ExprList
*sqlite3ExprListAppend(Parse
*,ExprList
*,Expr
*);
4831 ExprList
*sqlite3ExprListAppendVector(Parse
*,ExprList
*,IdList
*,Expr
*);
4832 Select
*sqlite3ExprListToValues(Parse
*, int, ExprList
*);
4833 void sqlite3ExprListSetSortOrder(ExprList
*,int,int);
4834 void sqlite3ExprListSetName(Parse
*,ExprList
*,const Token
*,int);
4835 void sqlite3ExprListSetSpan(Parse
*,ExprList
*,const char*,const char*);
4836 void sqlite3ExprListDelete(sqlite3
*, ExprList
*);
4837 void sqlite3ExprListDeleteGeneric(sqlite3
*,void*);
4838 u32
sqlite3ExprListFlags(const ExprList
*);
4839 int sqlite3IndexHasDuplicateRootPage(Index
*);
4840 int sqlite3Init(sqlite3
*, char**);
4841 int sqlite3InitCallback(void*, int, char**, char**);
4842 int sqlite3InitOne(sqlite3
*, int, char**, u32
);
4843 void sqlite3Pragma(Parse
*,Token
*,Token
*,Token
*,int);
4844 #ifndef SQLITE_OMIT_VIRTUALTABLE
4845 Module
*sqlite3PragmaVtabRegister(sqlite3
*,const char *zName
);
4847 void sqlite3ResetAllSchemasOfConnection(sqlite3
*);
4848 void sqlite3ResetOneSchema(sqlite3
*,int);
4849 void sqlite3CollapseDatabaseArray(sqlite3
*);
4850 void sqlite3CommitInternalChanges(sqlite3
*);
4851 void sqlite3ColumnSetExpr(Parse
*,Table
*,Column
*,Expr
*);
4852 Expr
*sqlite3ColumnExpr(Table
*,Column
*);
4853 void sqlite3ColumnSetColl(sqlite3
*,Column
*,const char*zColl
);
4854 const char *sqlite3ColumnColl(Column
*);
4855 void sqlite3DeleteColumnNames(sqlite3
*,Table
*);
4856 void sqlite3GenerateColumnNames(Parse
*pParse
, Select
*pSelect
);
4857 int sqlite3ColumnsFromExprList(Parse
*,ExprList
*,i16
*,Column
**);
4858 void sqlite3SubqueryColumnTypes(Parse
*,Table
*,Select
*,char);
4859 Table
*sqlite3ResultSetOfSelect(Parse
*,Select
*,char);
4860 void sqlite3OpenSchemaTable(Parse
*, int);
4861 Index
*sqlite3PrimaryKeyIndex(Table
*);
4862 i16
sqlite3TableColumnToIndex(Index
*, i16
);
4863 #ifdef SQLITE_OMIT_GENERATED_COLUMNS
4864 # define sqlite3TableColumnToStorage(T,X) (X) /* No-op pass-through */
4865 # define sqlite3StorageColumnToTable(T,X) (X) /* No-op pass-through */
4867 i16
sqlite3TableColumnToStorage(Table
*, i16
);
4868 i16
sqlite3StorageColumnToTable(Table
*, i16
);
4870 void sqlite3StartTable(Parse
*,Token
*,Token
*,int,int,int,int);
4871 #if SQLITE_ENABLE_HIDDEN_COLUMNS
4872 void sqlite3ColumnPropertiesFromName(Table
*, Column
*);
4874 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
4876 void sqlite3AddColumn(Parse
*,Token
,Token
);
4877 void sqlite3AddNotNull(Parse
*, int);
4878 void sqlite3AddPrimaryKey(Parse
*, ExprList
*, int, int, int);
4879 void sqlite3AddCheckConstraint(Parse
*, Expr
*, const char*, const char*);
4880 void sqlite3AddDefaultValue(Parse
*,Expr
*,const char*,const char*);
4881 void sqlite3AddCollateType(Parse
*, Token
*);
4882 void sqlite3AddGenerated(Parse
*,Expr
*,Token
*);
4883 void sqlite3EndTable(Parse
*,Token
*,Token
*,u32
,Select
*);
4884 void sqlite3AddReturning(Parse
*,ExprList
*);
4885 int sqlite3ParseUri(const char*,const char*,unsigned int*,
4886 sqlite3_vfs
**,char**,char **);
4887 #define sqlite3CodecQueryParameters(A,B,C) 0
4888 Btree
*sqlite3DbNameToBtree(sqlite3
*,const char*);
4890 #ifdef SQLITE_UNTESTABLE
4891 # define sqlite3FaultSim(X) SQLITE_OK
4893 int sqlite3FaultSim(int);
4896 Bitvec
*sqlite3BitvecCreate(u32
);
4897 int sqlite3BitvecTest(Bitvec
*, u32
);
4898 int sqlite3BitvecTestNotNull(Bitvec
*, u32
);
4899 int sqlite3BitvecSet(Bitvec
*, u32
);
4900 void sqlite3BitvecClear(Bitvec
*, u32
, void*);
4901 void sqlite3BitvecDestroy(Bitvec
*);
4902 u32
sqlite3BitvecSize(Bitvec
*);
4903 #ifndef SQLITE_UNTESTABLE
4904 int sqlite3BitvecBuiltinTest(int,int*);
4907 RowSet
*sqlite3RowSetInit(sqlite3
*);
4908 void sqlite3RowSetDelete(void*);
4909 void sqlite3RowSetClear(void*);
4910 void sqlite3RowSetInsert(RowSet
*, i64
);
4911 int sqlite3RowSetTest(RowSet
*, int iBatch
, i64
);
4912 int sqlite3RowSetNext(RowSet
*, i64
*);
4914 void sqlite3CreateView(Parse
*,Token
*,Token
*,Token
*,ExprList
*,Select
*,int,int);
4916 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
4917 int sqlite3ViewGetColumnNames(Parse
*,Table
*);
4919 # define sqlite3ViewGetColumnNames(A,B) 0
4922 #if SQLITE_MAX_ATTACHED>30
4923 int sqlite3DbMaskAllZero(yDbMask
);
4925 void sqlite3DropTable(Parse
*, SrcList
*, int, int);
4926 void sqlite3CodeDropTable(Parse
*, Table
*, int, int);
4927 void sqlite3DeleteTable(sqlite3
*, Table
*);
4928 void sqlite3DeleteTableGeneric(sqlite3
*, void*);
4929 void sqlite3FreeIndex(sqlite3
*, Index
*);
4930 #ifndef SQLITE_OMIT_AUTOINCREMENT
4931 void sqlite3AutoincrementBegin(Parse
*pParse
);
4932 void sqlite3AutoincrementEnd(Parse
*pParse
);
4934 # define sqlite3AutoincrementBegin(X)
4935 # define sqlite3AutoincrementEnd(X)
4937 void sqlite3Insert(Parse
*, SrcList
*, Select
*, IdList
*, int, Upsert
*);
4938 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4939 void sqlite3ComputeGeneratedColumns(Parse
*, int, Table
*);
4941 void *sqlite3ArrayAllocate(sqlite3
*,void*,int,int*,int*);
4942 IdList
*sqlite3IdListAppend(Parse
*, IdList
*, Token
*);
4943 int sqlite3IdListIndex(IdList
*,const char*);
4944 SrcList
*sqlite3SrcListEnlarge(Parse
*, SrcList
*, int, int);
4945 SrcList
*sqlite3SrcListAppendList(Parse
*pParse
, SrcList
*p1
, SrcList
*p2
);
4946 SrcList
*sqlite3SrcListAppend(Parse
*, SrcList
*, Token
*, Token
*);
4947 SrcList
*sqlite3SrcListAppendFromTerm(Parse
*, SrcList
*, Token
*, Token
*,
4948 Token
*, Select
*, OnOrUsing
*);
4949 void sqlite3SrcListIndexedBy(Parse
*, SrcList
*, Token
*);
4950 void sqlite3SrcListFuncArgs(Parse
*, SrcList
*, ExprList
*);
4951 int sqlite3IndexedByLookup(Parse
*, SrcItem
*);
4952 void sqlite3SrcListShiftJoinType(Parse
*,SrcList
*);
4953 void sqlite3SrcListAssignCursors(Parse
*, SrcList
*);
4954 void sqlite3IdListDelete(sqlite3
*, IdList
*);
4955 void sqlite3ClearOnOrUsing(sqlite3
*, OnOrUsing
*);
4956 void sqlite3SrcListDelete(sqlite3
*, SrcList
*);
4957 Index
*sqlite3AllocateIndexObject(sqlite3
*,i16
,int,char**);
4958 void sqlite3CreateIndex(Parse
*,Token
*,Token
*,SrcList
*,ExprList
*,int,Token
*,
4959 Expr
*, int, int, u8
);
4960 void sqlite3DropIndex(Parse
*, SrcList
*, int);
4961 int sqlite3Select(Parse
*, Select
*, SelectDest
*);
4962 Select
*sqlite3SelectNew(Parse
*,ExprList
*,SrcList
*,Expr
*,ExprList
*,
4963 Expr
*,ExprList
*,u32
,Expr
*);
4964 void sqlite3SelectDelete(sqlite3
*, Select
*);
4965 void sqlite3SelectDeleteGeneric(sqlite3
*,void*);
4966 Table
*sqlite3SrcListLookup(Parse
*, SrcList
*);
4967 int sqlite3IsReadOnly(Parse
*, Table
*, Trigger
*);
4968 void sqlite3OpenTable(Parse
*, int iCur
, int iDb
, Table
*, int);
4969 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
4970 Expr
*sqlite3LimitWhere(Parse
*,SrcList
*,Expr
*,ExprList
*,Expr
*,char*);
4972 void sqlite3CodeChangeCount(Vdbe
*,int,const char*);
4973 void sqlite3DeleteFrom(Parse
*, SrcList
*, Expr
*, ExprList
*, Expr
*);
4974 void sqlite3Update(Parse
*, SrcList
*, ExprList
*,Expr
*,int,ExprList
*,Expr
*,
4976 WhereInfo
*sqlite3WhereBegin(Parse
*,SrcList
*,Expr
*,ExprList
*,
4977 ExprList
*,Select
*,u16
,int);
4978 void sqlite3WhereEnd(WhereInfo
*);
4979 LogEst
sqlite3WhereOutputRowCount(WhereInfo
*);
4980 int sqlite3WhereIsDistinct(WhereInfo
*);
4981 int sqlite3WhereIsOrdered(WhereInfo
*);
4982 int sqlite3WhereOrderByLimitOptLabel(WhereInfo
*);
4983 void sqlite3WhereMinMaxOptEarlyOut(Vdbe
*,WhereInfo
*);
4984 int sqlite3WhereIsSorted(WhereInfo
*);
4985 int sqlite3WhereContinueLabel(WhereInfo
*);
4986 int sqlite3WhereBreakLabel(WhereInfo
*);
4987 int sqlite3WhereOkOnePass(WhereInfo
*, int*);
4988 #define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */
4989 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
4990 #define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */
4991 int sqlite3WhereUsesDeferredSeek(WhereInfo
*);
4992 void sqlite3ExprCodeLoadIndexColumn(Parse
*, Index
*, int, int, int);
4993 int sqlite3ExprCodeGetColumn(Parse
*, Table
*, int, int, int, u8
);
4994 void sqlite3ExprCodeGetColumnOfTable(Vdbe
*, Table
*, int, int, int);
4995 void sqlite3ExprCodeMove(Parse
*, int, int, int);
4996 void sqlite3ExprCode(Parse
*, Expr
*, int);
4997 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4998 void sqlite3ExprCodeGeneratedColumn(Parse
*, Table
*, Column
*, int);
5000 void sqlite3ExprCodeCopy(Parse
*, Expr
*, int);
5001 void sqlite3ExprCodeFactorable(Parse
*, Expr
*, int);
5002 int sqlite3ExprCodeRunJustOnce(Parse
*, Expr
*, int);
5003 int sqlite3ExprCodeTemp(Parse
*, Expr
*, int*);
5004 int sqlite3ExprCodeTarget(Parse
*, Expr
*, int);
5005 int sqlite3ExprCodeExprList(Parse
*, ExprList
*, int, int, u8
);
5006 #define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
5007 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
5008 #define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */
5009 #define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */
5010 void sqlite3ExprIfTrue(Parse
*, Expr
*, int, int);
5011 void sqlite3ExprIfFalse(Parse
*, Expr
*, int, int);
5012 void sqlite3ExprIfFalseDup(Parse
*, Expr
*, int, int);
5013 Table
*sqlite3FindTable(sqlite3
*,const char*, const char*);
5014 #define LOCATE_VIEW 0x01
5015 #define LOCATE_NOERR 0x02
5016 Table
*sqlite3LocateTable(Parse
*,u32 flags
,const char*, const char*);
5017 const char *sqlite3PreferredTableName(const char*);
5018 Table
*sqlite3LocateTableItem(Parse
*,u32 flags
,SrcItem
*);
5019 Index
*sqlite3FindIndex(sqlite3
*,const char*, const char*);
5020 void sqlite3UnlinkAndDeleteTable(sqlite3
*,int,const char*);
5021 void sqlite3UnlinkAndDeleteIndex(sqlite3
*,int,const char*);
5022 void sqlite3Vacuum(Parse
*,Token
*,Expr
*);
5023 int sqlite3RunVacuum(char**, sqlite3
*, int, sqlite3_value
*);
5024 char *sqlite3NameFromToken(sqlite3
*, const Token
*);
5025 int sqlite3ExprCompare(const Parse
*,const Expr
*,const Expr
*, int);
5026 int sqlite3ExprCompareSkip(Expr
*,Expr
*,int);
5027 int sqlite3ExprListCompare(const ExprList
*,const ExprList
*, int);
5028 int sqlite3ExprImpliesExpr(const Parse
*,const Expr
*,const Expr
*, int);
5029 int sqlite3ExprImpliesNonNullRow(Expr
*,int,int);
5030 void sqlite3AggInfoPersistWalkerInit(Walker
*,Parse
*);
5031 void sqlite3ExprAnalyzeAggregates(NameContext
*, Expr
*);
5032 void sqlite3ExprAnalyzeAggList(NameContext
*,ExprList
*);
5033 int sqlite3ExprCoveredByIndex(Expr
*, int iCur
, Index
*pIdx
);
5034 int sqlite3ReferencesSrcList(Parse
*, Expr
*, SrcList
*);
5035 Vdbe
*sqlite3GetVdbe(Parse
*);
5036 #ifndef SQLITE_UNTESTABLE
5037 void sqlite3PrngSaveState(void);
5038 void sqlite3PrngRestoreState(void);
5040 void sqlite3RollbackAll(sqlite3
*,int);
5041 void sqlite3CodeVerifySchema(Parse
*, int);
5042 void sqlite3CodeVerifyNamedSchema(Parse
*, const char *zDb
);
5043 void sqlite3BeginTransaction(Parse
*, int);
5044 void sqlite3EndTransaction(Parse
*,int);
5045 void sqlite3Savepoint(Parse
*, int, Token
*);
5046 void sqlite3CloseSavepoints(sqlite3
*);
5047 void sqlite3LeaveMutexAndCloseZombie(sqlite3
*);
5048 u32
sqlite3IsTrueOrFalse(const char*);
5049 int sqlite3ExprIdToTrueFalse(Expr
*);
5050 int sqlite3ExprTruthValue(const Expr
*);
5051 int sqlite3ExprIsConstant(Expr
*);
5052 int sqlite3ExprIsConstantNotJoin(Expr
*);
5053 int sqlite3ExprIsConstantOrFunction(Expr
*, u8
);
5054 int sqlite3ExprIsConstantOrGroupBy(Parse
*, Expr
*, ExprList
*);
5055 int sqlite3ExprIsTableConstant(Expr
*,int);
5056 int sqlite3ExprIsSingleTableConstraint(Expr
*,const SrcList
*,int);
5057 #ifdef SQLITE_ENABLE_CURSOR_HINTS
5058 int sqlite3ExprContainsSubquery(Expr
*);
5060 int sqlite3ExprIsInteger(const Expr
*, int*);
5061 int sqlite3ExprCanBeNull(const Expr
*);
5062 int sqlite3ExprNeedsNoAffinityChange(const Expr
*, char);
5063 int sqlite3IsRowid(const char*);
5064 const char *sqlite3RowidAlias(Table
*pTab
);
5065 void sqlite3GenerateRowDelete(
5066 Parse
*,Table
*,Trigger
*,int,int,int,i16
,u8
,u8
,u8
,int);
5067 void sqlite3GenerateRowIndexDelete(Parse
*, Table
*, int, int, int*, int);
5068 int sqlite3GenerateIndexKey(Parse
*, Index
*, int, int, int, int*,Index
*,int);
5069 void sqlite3ResolvePartIdxLabel(Parse
*,int);
5070 int sqlite3ExprReferencesUpdatedColumn(Expr
*,int*,int);
5071 void sqlite3GenerateConstraintChecks(Parse
*,Table
*,int*,int,int,int,int,
5072 u8
,u8
,int,int*,int*,Upsert
*);
5073 #ifdef SQLITE_ENABLE_NULL_TRIM
5074 void sqlite3SetMakeRecordP5(Vdbe
*,Table
*);
5076 # define sqlite3SetMakeRecordP5(A,B)
5078 void sqlite3CompleteInsertion(Parse
*,Table
*,int,int,int,int*,int,int,int);
5079 int sqlite3OpenTableAndIndices(Parse
*, Table
*, int, u8
, int, u8
*, int*, int*);
5080 void sqlite3BeginWriteOperation(Parse
*, int, int);
5081 void sqlite3MultiWrite(Parse
*);
5082 void sqlite3MayAbort(Parse
*);
5083 void sqlite3HaltConstraint(Parse
*, int, int, char*, i8
, u8
);
5084 void sqlite3UniqueConstraint(Parse
*, int, Index
*);
5085 void sqlite3RowidConstraint(Parse
*, int, Table
*);
5086 Expr
*sqlite3ExprDup(sqlite3
*,const Expr
*,int);
5087 ExprList
*sqlite3ExprListDup(sqlite3
*,const ExprList
*,int);
5088 SrcList
*sqlite3SrcListDup(sqlite3
*,const SrcList
*,int);
5089 IdList
*sqlite3IdListDup(sqlite3
*,const IdList
*);
5090 Select
*sqlite3SelectDup(sqlite3
*,const Select
*,int);
5091 FuncDef
*sqlite3FunctionSearch(int,const char*);
5092 void sqlite3InsertBuiltinFuncs(FuncDef
*,int);
5093 FuncDef
*sqlite3FindFunction(sqlite3
*,const char*,int,u8
,u8
);
5094 void sqlite3QuoteValue(StrAccum
*,sqlite3_value
*);
5095 void sqlite3RegisterBuiltinFunctions(void);
5096 void sqlite3RegisterDateTimeFunctions(void);
5097 void sqlite3RegisterJsonFunctions(void);
5098 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3
*);
5099 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON)
5100 int sqlite3JsonTableFunctions(sqlite3
*);
5102 int sqlite3SafetyCheckOk(sqlite3
*);
5103 int sqlite3SafetyCheckSickOrOk(sqlite3
*);
5104 void sqlite3ChangeCookie(Parse
*, int);
5105 With
*sqlite3WithDup(sqlite3
*db
, With
*p
);
5107 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
5108 void sqlite3MaterializeView(Parse
*, Table
*, Expr
*, ExprList
*,Expr
*,int);
5111 #ifndef SQLITE_OMIT_TRIGGER
5112 void sqlite3BeginTrigger(Parse
*, Token
*,Token
*,int,int,IdList
*,SrcList
*,
5114 void sqlite3FinishTrigger(Parse
*, TriggerStep
*, Token
*);
5115 void sqlite3DropTrigger(Parse
*, SrcList
*, int);
5116 void sqlite3DropTriggerPtr(Parse
*, Trigger
*);
5117 Trigger
*sqlite3TriggersExist(Parse
*, Table
*, int, ExprList
*, int *pMask
);
5118 Trigger
*sqlite3TriggerList(Parse
*, Table
*);
5119 void sqlite3CodeRowTrigger(Parse
*, Trigger
*, int, ExprList
*, int, Table
*,
5121 void sqlite3CodeRowTriggerDirect(Parse
*, Trigger
*, Table
*, int, int, int);
5122 void sqliteViewTriggers(Parse
*, Table
*, Expr
*, int, ExprList
*);
5123 void sqlite3DeleteTriggerStep(sqlite3
*, TriggerStep
*);
5124 TriggerStep
*sqlite3TriggerSelectStep(sqlite3
*,Select
*,
5125 const char*,const char*);
5126 TriggerStep
*sqlite3TriggerInsertStep(Parse
*,Token
*, IdList
*,
5128 const char*,const char*);
5129 TriggerStep
*sqlite3TriggerUpdateStep(Parse
*,Token
*,SrcList
*,ExprList
*,
5130 Expr
*, u8
, const char*,const char*);
5131 TriggerStep
*sqlite3TriggerDeleteStep(Parse
*,Token
*, Expr
*,
5132 const char*,const char*);
5133 void sqlite3DeleteTrigger(sqlite3
*, Trigger
*);
5134 void sqlite3UnlinkAndDeleteTrigger(sqlite3
*,int,const char*);
5135 u32
sqlite3TriggerColmask(Parse
*,Trigger
*,ExprList
*,int,int,Table
*,int);
5136 SrcList
*sqlite3TriggerStepSrc(Parse
*, TriggerStep
*);
5137 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
5138 # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
5140 # define sqlite3TriggersExist(B,C,D,E,F) 0
5141 # define sqlite3DeleteTrigger(A,B)
5142 # define sqlite3DropTriggerPtr(A,B)
5143 # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
5144 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
5145 # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
5146 # define sqlite3TriggerList(X, Y) 0
5147 # define sqlite3ParseToplevel(p) p
5148 # define sqlite3IsToplevel(p) 1
5149 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
5150 # define sqlite3TriggerStepSrc(A,B) 0
5153 int sqlite3JoinType(Parse
*, Token
*, Token
*, Token
*);
5154 int sqlite3ColumnIndex(Table
*pTab
, const char *zCol
);
5155 void sqlite3SrcItemColumnUsed(SrcItem
*,int);
5156 void sqlite3SetJoinExpr(Expr
*,int,u32
);
5157 void sqlite3CreateForeignKey(Parse
*, ExprList
*, Token
*, ExprList
*, int);
5158 void sqlite3DeferForeignKey(Parse
*, int);
5159 #ifndef SQLITE_OMIT_AUTHORIZATION
5160 void sqlite3AuthRead(Parse
*,Expr
*,Schema
*,SrcList
*);
5161 int sqlite3AuthCheck(Parse
*,int, const char*, const char*, const char*);
5162 void sqlite3AuthContextPush(Parse
*, AuthContext
*, const char*);
5163 void sqlite3AuthContextPop(AuthContext
*);
5164 int sqlite3AuthReadCol(Parse
*, const char *, const char *, int);
5166 # define sqlite3AuthRead(a,b,c,d)
5167 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
5168 # define sqlite3AuthContextPush(a,b,c)
5169 # define sqlite3AuthContextPop(a) ((void)(a))
5171 int sqlite3DbIsNamed(sqlite3
*db
, int iDb
, const char *zName
);
5172 void sqlite3Attach(Parse
*, Expr
*, Expr
*, Expr
*);
5173 void sqlite3Detach(Parse
*, Expr
*);
5174 void sqlite3FixInit(DbFixer
*, Parse
*, int, const char*, const Token
*);
5175 int sqlite3FixSrcList(DbFixer
*, SrcList
*);
5176 int sqlite3FixSelect(DbFixer
*, Select
*);
5177 int sqlite3FixExpr(DbFixer
*, Expr
*);
5178 int sqlite3FixTriggerStep(DbFixer
*, TriggerStep
*);
5180 int sqlite3RealSameAsInt(double,sqlite3_int64
);
5181 i64
sqlite3RealToI64(double);
5182 int sqlite3Int64ToText(i64
,char*);
5183 int sqlite3AtoF(const char *z
, double*, int, u8
);
5184 int sqlite3GetInt32(const char *, int*);
5185 int sqlite3GetUInt32(const char*, u32
*);
5186 int sqlite3Atoi(const char*);
5187 #ifndef SQLITE_OMIT_UTF16
5188 int sqlite3Utf16ByteLen(const void *pData
, int nChar
);
5190 int sqlite3Utf8CharLen(const char *pData
, int nByte
);
5191 u32
sqlite3Utf8Read(const u8
**);
5192 int sqlite3Utf8ReadLimited(const u8
*, int, u32
*);
5193 LogEst
sqlite3LogEst(u64
);
5194 LogEst
sqlite3LogEstAdd(LogEst
,LogEst
);
5195 LogEst
sqlite3LogEstFromDouble(double);
5196 u64
sqlite3LogEstToInt(LogEst
);
5197 VList
*sqlite3VListAdd(sqlite3
*,VList
*,const char*,int,int);
5198 const char *sqlite3VListNumToName(VList
*,int);
5199 int sqlite3VListNameToNum(VList
*,const char*,int);
5202 ** Routines to read and write variable-length integers. These used to
5203 ** be defined locally, but now we use the varint routines in the util.c
5206 int sqlite3PutVarint(unsigned char*, u64
);
5207 u8
sqlite3GetVarint(const unsigned char *, u64
*);
5208 u8
sqlite3GetVarint32(const unsigned char *, u32
*);
5209 int sqlite3VarintLen(u64 v
);
5212 ** The common case is for a varint to be a single byte. They following
5213 ** macros handle the common case without a procedure call, but then call
5214 ** the procedure for larger varints.
5216 #define getVarint32(A,B) \
5217 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
5218 #define getVarint32NR(A,B) \
5219 B=(u32)*(A);if(B>=0x80)sqlite3GetVarint32((A),(u32*)&(B))
5220 #define putVarint32(A,B) \
5221 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
5222 sqlite3PutVarint((A),(B)))
5223 #define getVarint sqlite3GetVarint
5224 #define putVarint sqlite3PutVarint
5227 const char *sqlite3IndexAffinityStr(sqlite3
*, Index
*);
5228 char *sqlite3TableAffinityStr(sqlite3
*,const Table
*);
5229 void sqlite3TableAffinity(Vdbe
*, Table
*, int);
5230 char sqlite3CompareAffinity(const Expr
*pExpr
, char aff2
);
5231 int sqlite3IndexAffinityOk(const Expr
*pExpr
, char idx_affinity
);
5232 char sqlite3TableColumnAffinity(const Table
*,int);
5233 char sqlite3ExprAffinity(const Expr
*pExpr
);
5234 int sqlite3ExprDataType(const Expr
*pExpr
);
5235 int sqlite3Atoi64(const char*, i64
*, int, u8
);
5236 int sqlite3DecOrHexToI64(const char*, i64
*);
5237 void sqlite3ErrorWithMsg(sqlite3
*, int, const char*,...);
5238 void sqlite3Error(sqlite3
*,int);
5239 void sqlite3ErrorClear(sqlite3
*);
5240 void sqlite3SystemError(sqlite3
*,int);
5241 void *sqlite3HexToBlob(sqlite3
*, const char *z
, int n
);
5242 u8
sqlite3HexToInt(int h
);
5243 int sqlite3TwoPartName(Parse
*, Token
*, Token
*, Token
**);
5245 #if defined(SQLITE_NEED_ERR_NAME)
5246 const char *sqlite3ErrName(int);
5249 #ifndef SQLITE_OMIT_DESERIALIZE
5250 int sqlite3MemdbInit(void);
5251 int sqlite3IsMemdb(const sqlite3_vfs
*);
5253 # define sqlite3IsMemdb(X) 0
5256 const char *sqlite3ErrStr(int);
5257 int sqlite3ReadSchema(Parse
*pParse
);
5258 CollSeq
*sqlite3FindCollSeq(sqlite3
*,u8 enc
, const char*,int);
5259 int sqlite3IsBinary(const CollSeq
*);
5260 CollSeq
*sqlite3LocateCollSeq(Parse
*pParse
, const char*zName
);
5261 void sqlite3SetTextEncoding(sqlite3
*db
, u8
);
5262 CollSeq
*sqlite3ExprCollSeq(Parse
*pParse
, const Expr
*pExpr
);
5263 CollSeq
*sqlite3ExprNNCollSeq(Parse
*pParse
, const Expr
*pExpr
);
5264 int sqlite3ExprCollSeqMatch(Parse
*,const Expr
*,const Expr
*);
5265 Expr
*sqlite3ExprAddCollateToken(const Parse
*pParse
, Expr
*, const Token
*, int);
5266 Expr
*sqlite3ExprAddCollateString(const Parse
*,Expr
*,const char*);
5267 Expr
*sqlite3ExprSkipCollate(Expr
*);
5268 Expr
*sqlite3ExprSkipCollateAndLikely(Expr
*);
5269 int sqlite3CheckCollSeq(Parse
*, CollSeq
*);
5270 int sqlite3WritableSchema(sqlite3
*);
5271 int sqlite3CheckObjectName(Parse
*, const char*,const char*,const char*);
5272 void sqlite3VdbeSetChanges(sqlite3
*, i64
);
5273 int sqlite3AddInt64(i64
*,i64
);
5274 int sqlite3SubInt64(i64
*,i64
);
5275 int sqlite3MulInt64(i64
*,i64
);
5276 int sqlite3AbsInt32(int);
5277 #ifdef SQLITE_ENABLE_8_3_NAMES
5278 void sqlite3FileSuffix3(const char*, char*);
5280 # define sqlite3FileSuffix3(X,Y)
5282 u8
sqlite3GetBoolean(const char *z
,u8
);
5284 const void *sqlite3ValueText(sqlite3_value
*, u8
);
5285 int sqlite3ValueIsOfClass(const sqlite3_value
*, void(*)(void*));
5286 int sqlite3ValueBytes(sqlite3_value
*, u8
);
5287 void sqlite3ValueSetStr(sqlite3_value
*, int, const void *,u8
,
5289 void sqlite3ValueSetNull(sqlite3_value
*);
5290 void sqlite3ValueFree(sqlite3_value
*);
5291 #ifndef SQLITE_UNTESTABLE
5292 void sqlite3ResultIntReal(sqlite3_context
*);
5294 sqlite3_value
*sqlite3ValueNew(sqlite3
*);
5295 #ifndef SQLITE_OMIT_UTF16
5296 char *sqlite3Utf16to8(sqlite3
*, const void*, int, u8
);
5298 int sqlite3ValueFromExpr(sqlite3
*, const Expr
*, u8
, u8
, sqlite3_value
**);
5299 void sqlite3ValueApplyAffinity(sqlite3_value
*, u8
, u8
);
5300 #ifndef SQLITE_AMALGAMATION
5301 extern const unsigned char sqlite3OpcodeProperty
[];
5302 extern const char sqlite3StrBINARY
[];
5303 extern const unsigned char sqlite3StdTypeLen
[];
5304 extern const char sqlite3StdTypeAffinity
[];
5305 extern const char *sqlite3StdType
[];
5306 extern const unsigned char sqlite3UpperToLower
[];
5307 extern const unsigned char *sqlite3aLTb
;
5308 extern const unsigned char *sqlite3aEQb
;
5309 extern const unsigned char *sqlite3aGTb
;
5310 extern const unsigned char sqlite3CtypeMap
[];
5311 extern SQLITE_WSD
struct Sqlite3Config sqlite3Config
;
5312 extern FuncDefHash sqlite3BuiltinFunctions
;
5313 #ifndef SQLITE_OMIT_WSD
5314 extern int sqlite3PendingByte
;
5316 #endif /* SQLITE_AMALGAMATION */
5318 extern sqlite3_uint64 sqlite3NProfileCnt
;
5320 void sqlite3RootPageMoved(sqlite3
*, int, Pgno
, Pgno
);
5321 void sqlite3Reindex(Parse
*, Token
*, Token
*);
5322 void sqlite3AlterFunctions(void);
5323 void sqlite3AlterRenameTable(Parse
*, SrcList
*, Token
*);
5324 void sqlite3AlterRenameColumn(Parse
*, SrcList
*, Token
*, Token
*);
5325 int sqlite3GetToken(const unsigned char *, int *);
5326 void sqlite3NestedParse(Parse
*, const char*, ...);
5327 void sqlite3ExpirePreparedStatements(sqlite3
*, int);
5328 void sqlite3CodeRhsOfIN(Parse
*, Expr
*, int);
5329 int sqlite3CodeSubselect(Parse
*, Expr
*);
5330 void sqlite3SelectPrep(Parse
*, Select
*, NameContext
*);
5331 int sqlite3ExpandSubquery(Parse
*, SrcItem
*);
5332 void sqlite3SelectWrongNumTermsError(Parse
*pParse
, Select
*p
);
5333 int sqlite3MatchEName(
5334 const struct ExprList_item
*,
5340 Bitmask
sqlite3ExprColUsed(Expr
*);
5341 u8
sqlite3StrIHash(const char*);
5342 int sqlite3ResolveExprNames(NameContext
*, Expr
*);
5343 int sqlite3ResolveExprListNames(NameContext
*, ExprList
*);
5344 void sqlite3ResolveSelectNames(Parse
*, Select
*, NameContext
*);
5345 int sqlite3ResolveSelfReference(Parse
*,Table
*,int,Expr
*,ExprList
*);
5346 int sqlite3ResolveOrderGroupBy(Parse
*, Select
*, ExprList
*, const char*);
5347 void sqlite3ColumnDefault(Vdbe
*, Table
*, int, int);
5348 void sqlite3AlterFinishAddColumn(Parse
*, Token
*);
5349 void sqlite3AlterBeginAddColumn(Parse
*, SrcList
*);
5350 void sqlite3AlterDropColumn(Parse
*, SrcList
*, const Token
*);
5351 const void *sqlite3RenameTokenMap(Parse
*, const void*, const Token
*);
5352 void sqlite3RenameTokenRemap(Parse
*, const void *pTo
, const void *pFrom
);
5353 void sqlite3RenameExprUnmap(Parse
*, Expr
*);
5354 void sqlite3RenameExprlistUnmap(Parse
*, ExprList
*);
5355 CollSeq
*sqlite3GetCollSeq(Parse
*, u8
, CollSeq
*, const char*);
5356 char sqlite3AffinityType(const char*, Column
*);
5357 void sqlite3Analyze(Parse
*, Token
*, Token
*);
5358 int sqlite3InvokeBusyHandler(BusyHandler
*);
5359 int sqlite3FindDb(sqlite3
*, Token
*);
5360 int sqlite3FindDbName(sqlite3
*, const char *);
5361 int sqlite3AnalysisLoad(sqlite3
*,int iDB
);
5362 void sqlite3DeleteIndexSamples(sqlite3
*,Index
*);
5363 void sqlite3DefaultRowEst(Index
*);
5364 void sqlite3RegisterLikeFunctions(sqlite3
*, int);
5365 int sqlite3IsLikeFunction(sqlite3
*,Expr
*,int*,char*);
5366 void sqlite3SchemaClear(void *);
5367 Schema
*sqlite3SchemaGet(sqlite3
*, Btree
*);
5368 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*);
5369 KeyInfo
*sqlite3KeyInfoAlloc(sqlite3
*,int,int);
5370 void sqlite3KeyInfoUnref(KeyInfo
*);
5371 KeyInfo
*sqlite3KeyInfoRef(KeyInfo
*);
5372 KeyInfo
*sqlite3KeyInfoOfIndex(Parse
*, Index
*);
5373 KeyInfo
*sqlite3KeyInfoFromExprList(Parse
*, ExprList
*, int, int);
5374 const char *sqlite3SelectOpName(int);
5375 int sqlite3HasExplicitNulls(Parse
*, ExprList
*);
5378 int sqlite3KeyInfoIsWriteable(KeyInfo
*);
5380 int sqlite3CreateFunc(sqlite3
*, const char *, int, int, void *,
5381 void (*)(sqlite3_context
*,int,sqlite3_value
**),
5382 void (*)(sqlite3_context
*,int,sqlite3_value
**),
5383 void (*)(sqlite3_context
*),
5384 void (*)(sqlite3_context
*),
5385 void (*)(sqlite3_context
*,int,sqlite3_value
**),
5386 FuncDestructor
*pDestructor
5388 void sqlite3NoopDestructor(void*);
5389 void *sqlite3OomFault(sqlite3
*);
5390 void sqlite3OomClear(sqlite3
*);
5391 int sqlite3ApiExit(sqlite3
*db
, int);
5392 int sqlite3OpenTempDatabase(Parse
*);
5394 char *sqlite3RCStrRef(char*);
5395 void sqlite3RCStrUnref(void*);
5396 char *sqlite3RCStrNew(u64
);
5397 char *sqlite3RCStrResize(char*,u64
);
5399 void sqlite3StrAccumInit(StrAccum
*, sqlite3
*, char*, int, int);
5400 int sqlite3StrAccumEnlarge(StrAccum
*, i64
);
5401 char *sqlite3StrAccumFinish(StrAccum
*);
5402 void sqlite3StrAccumSetError(StrAccum
*, u8
);
5403 void sqlite3ResultStrAccum(sqlite3_context
*,StrAccum
*);
5404 void sqlite3SelectDestInit(SelectDest
*,int,int);
5405 Expr
*sqlite3CreateColumnExpr(sqlite3
*, SrcList
*, int, int);
5406 void sqlite3RecordErrorByteOffset(sqlite3
*,const char*);
5407 void sqlite3RecordErrorOffsetOfExpr(sqlite3
*,const Expr
*);
5409 void sqlite3BackupRestart(sqlite3_backup
*);
5410 void sqlite3BackupUpdate(sqlite3_backup
*, Pgno
, const u8
*);
5412 #ifndef SQLITE_OMIT_SUBQUERY
5413 int sqlite3ExprCheckIN(Parse
*, Expr
*);
5415 # define sqlite3ExprCheckIN(x,y) SQLITE_OK
5418 #ifdef SQLITE_ENABLE_STAT4
5419 int sqlite3Stat4ProbeSetValue(
5420 Parse
*,Index
*,UnpackedRecord
**,Expr
*,int,int,int*);
5421 int sqlite3Stat4ValueFromExpr(Parse
*, Expr
*, u8
, sqlite3_value
**);
5422 void sqlite3Stat4ProbeFree(UnpackedRecord
*);
5423 int sqlite3Stat4Column(sqlite3
*, const void*, int, int, sqlite3_value
**);
5424 char sqlite3IndexColumnAffinity(sqlite3
*, Index
*, int);
5428 ** The interface to the LEMON-generated parser
5430 #ifndef SQLITE_AMALGAMATION
5431 void *sqlite3ParserAlloc(void*(*)(u64
), Parse
*);
5432 void sqlite3ParserFree(void*, void(*)(void*));
5434 void sqlite3Parser(void*, int, Token
);
5435 int sqlite3ParserFallback(int);
5436 #ifdef YYTRACKMAXSTACKDEPTH
5437 int sqlite3ParserStackPeak(void*);
5440 void sqlite3AutoLoadExtensions(sqlite3
*);
5441 #ifndef SQLITE_OMIT_LOAD_EXTENSION
5442 void sqlite3CloseExtensions(sqlite3
*);
5444 # define sqlite3CloseExtensions(X)
5447 #ifndef SQLITE_OMIT_SHARED_CACHE
5448 void sqlite3TableLock(Parse
*, int, Pgno
, u8
, const char *);
5450 #define sqlite3TableLock(v,w,x,y,z)
5454 int sqlite3Utf8To8(unsigned char*);
5457 #ifdef SQLITE_OMIT_VIRTUALTABLE
5458 # define sqlite3VtabClear(D,T)
5459 # define sqlite3VtabSync(X,Y) SQLITE_OK
5460 # define sqlite3VtabRollback(X)
5461 # define sqlite3VtabCommit(X)
5462 # define sqlite3VtabInSync(db) 0
5463 # define sqlite3VtabLock(X)
5464 # define sqlite3VtabUnlock(X)
5465 # define sqlite3VtabModuleUnref(D,X)
5466 # define sqlite3VtabUnlockList(X)
5467 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
5468 # define sqlite3GetVTable(X,Y) ((VTable*)0)
5470 void sqlite3VtabClear(sqlite3
*db
, Table
*);
5471 void sqlite3VtabDisconnect(sqlite3
*db
, Table
*p
);
5472 int sqlite3VtabSync(sqlite3
*db
, Vdbe
*);
5473 int sqlite3VtabRollback(sqlite3
*db
);
5474 int sqlite3VtabCommit(sqlite3
*db
);
5475 void sqlite3VtabLock(VTable
*);
5476 void sqlite3VtabUnlock(VTable
*);
5477 void sqlite3VtabModuleUnref(sqlite3
*,Module
*);
5478 void sqlite3VtabUnlockList(sqlite3
*);
5479 int sqlite3VtabSavepoint(sqlite3
*, int, int);
5480 void sqlite3VtabImportErrmsg(Vdbe
*, sqlite3_vtab
*);
5481 VTable
*sqlite3GetVTable(sqlite3
*, Table
*);
5482 Module
*sqlite3VtabCreateModule(
5485 const sqlite3_module
*,
5489 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
5491 int sqlite3ReadOnlyShadowTables(sqlite3
*db
);
5492 #ifndef SQLITE_OMIT_VIRTUALTABLE
5493 int sqlite3ShadowTableName(sqlite3
*db
, const char *zName
);
5494 int sqlite3IsShadowTableOf(sqlite3
*,Table
*,const char*);
5495 void sqlite3MarkAllShadowTablesOf(sqlite3
*, Table
*);
5497 # define sqlite3ShadowTableName(A,B) 0
5498 # define sqlite3IsShadowTableOf(A,B,C) 0
5499 # define sqlite3MarkAllShadowTablesOf(A,B)
5501 int sqlite3VtabEponymousTableInit(Parse
*,Module
*);
5502 void sqlite3VtabEponymousTableClear(sqlite3
*,Module
*);
5503 void sqlite3VtabMakeWritable(Parse
*,Table
*);
5504 void sqlite3VtabBeginParse(Parse
*, Token
*, Token
*, Token
*, int);
5505 void sqlite3VtabFinishParse(Parse
*, Token
*);
5506 void sqlite3VtabArgInit(Parse
*);
5507 void sqlite3VtabArgExtend(Parse
*, Token
*);
5508 int sqlite3VtabCallCreate(sqlite3
*, int, const char *, char **);
5509 int sqlite3VtabCallConnect(Parse
*, Table
*);
5510 int sqlite3VtabCallDestroy(sqlite3
*, int, const char *);
5511 int sqlite3VtabBegin(sqlite3
*, VTable
*);
5513 FuncDef
*sqlite3VtabOverloadFunction(sqlite3
*,FuncDef
*, int nArg
, Expr
*);
5514 void sqlite3VtabUsesAllSchemas(Parse
*);
5515 sqlite3_int64
sqlite3StmtCurrentTime(sqlite3_context
*);
5516 int sqlite3VdbeParameterIndex(Vdbe
*, const char*, int);
5517 int sqlite3TransferBindings(sqlite3_stmt
*, sqlite3_stmt
*);
5518 void sqlite3ParseObjectInit(Parse
*,sqlite3
*);
5519 void sqlite3ParseObjectReset(Parse
*);
5520 void *sqlite3ParserAddCleanup(Parse
*,void(*)(sqlite3
*,void*),void*);
5521 #ifdef SQLITE_ENABLE_NORMALIZE
5522 char *sqlite3Normalize(Vdbe
*, const char*);
5524 int sqlite3Reprepare(Vdbe
*);
5525 void sqlite3ExprListCheckLength(Parse
*, ExprList
*, const char*);
5526 CollSeq
*sqlite3ExprCompareCollSeq(Parse
*,const Expr
*);
5527 CollSeq
*sqlite3BinaryCompareCollSeq(Parse
*, const Expr
*, const Expr
*);
5528 int sqlite3TempInMemory(const sqlite3
*);
5529 const char *sqlite3JournalModename(int);
5530 #ifndef SQLITE_OMIT_WAL
5531 int sqlite3Checkpoint(sqlite3
*, int, int, int*, int*);
5532 int sqlite3WalDefaultHook(void*,sqlite3
*,const char*,int);
5534 #ifndef SQLITE_OMIT_CTE
5535 Cte
*sqlite3CteNew(Parse
*,Token
*,ExprList
*,Select
*,u8
);
5536 void sqlite3CteDelete(sqlite3
*,Cte
*);
5537 With
*sqlite3WithAdd(Parse
*,With
*,Cte
*);
5538 void sqlite3WithDelete(sqlite3
*,With
*);
5539 void sqlite3WithDeleteGeneric(sqlite3
*,void*);
5540 With
*sqlite3WithPush(Parse
*, With
*, u8
);
5542 # define sqlite3CteNew(P,T,E,S) ((void*)0)
5543 # define sqlite3CteDelete(D,C)
5544 # define sqlite3CteWithAdd(P,W,C) ((void*)0)
5545 # define sqlite3WithDelete(x,y)
5546 # define sqlite3WithPush(x,y,z) ((void*)0)
5548 #ifndef SQLITE_OMIT_UPSERT
5549 Upsert
*sqlite3UpsertNew(sqlite3
*,ExprList
*,Expr
*,ExprList
*,Expr
*,Upsert
*);
5550 void sqlite3UpsertDelete(sqlite3
*,Upsert
*);
5551 Upsert
*sqlite3UpsertDup(sqlite3
*,Upsert
*);
5552 int sqlite3UpsertAnalyzeTarget(Parse
*,SrcList
*,Upsert
*);
5553 void sqlite3UpsertDoUpdate(Parse
*,Upsert
*,Table
*,Index
*,int);
5554 Upsert
*sqlite3UpsertOfIndex(Upsert
*,Index
*);
5555 int sqlite3UpsertNextIsIPK(Upsert
*);
5557 #define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0)
5558 #define sqlite3UpsertDelete(x,y)
5559 #define sqlite3UpsertDup(x,y) ((Upsert*)0)
5560 #define sqlite3UpsertOfIndex(x,y) ((Upsert*)0)
5561 #define sqlite3UpsertNextIsIPK(x) 0
5565 /* Declarations for functions in fkey.c. All of these are replaced by
5566 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
5567 ** key functionality is available. If OMIT_TRIGGER is defined but
5568 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
5569 ** this case foreign keys are parsed, but no other functionality is
5570 ** provided (enforcement of FK constraints requires the triggers sub-system).
5572 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
5573 void sqlite3FkCheck(Parse
*, Table
*, int, int, int*, int);
5574 void sqlite3FkDropTable(Parse
*, SrcList
*, Table
*);
5575 void sqlite3FkActions(Parse
*, Table
*, ExprList
*, int, int*, int);
5576 int sqlite3FkRequired(Parse
*, Table
*, int*, int);
5577 u32
sqlite3FkOldmask(Parse
*, Table
*);
5578 FKey
*sqlite3FkReferences(Table
*);
5579 void sqlite3FkClearTriggerCache(sqlite3
*,int);
5581 #define sqlite3FkActions(a,b,c,d,e,f)
5582 #define sqlite3FkCheck(a,b,c,d,e,f)
5583 #define sqlite3FkDropTable(a,b,c)
5584 #define sqlite3FkOldmask(a,b) 0
5585 #define sqlite3FkRequired(a,b,c,d) 0
5586 #define sqlite3FkReferences(a) 0
5587 #define sqlite3FkClearTriggerCache(a,b)
5589 #ifndef SQLITE_OMIT_FOREIGN_KEY
5590 void sqlite3FkDelete(sqlite3
*, Table
*);
5591 int sqlite3FkLocateIndex(Parse
*,Table
*,FKey
*,Index
**,int**);
5593 #define sqlite3FkDelete(a,b)
5594 #define sqlite3FkLocateIndex(a,b,c,d,e)
5599 ** Available fault injectors. Should be numbered beginning with 0.
5601 #define SQLITE_FAULTINJECTOR_MALLOC 0
5602 #define SQLITE_FAULTINJECTOR_COUNT 1
5605 ** The interface to the code in fault.c used for identifying "benign"
5606 ** malloc failures. This is only present if SQLITE_UNTESTABLE
5609 #ifndef SQLITE_UNTESTABLE
5610 void sqlite3BeginBenignMalloc(void);
5611 void sqlite3EndBenignMalloc(void);
5613 #define sqlite3BeginBenignMalloc()
5614 #define sqlite3EndBenignMalloc()
5618 ** Allowed return values from sqlite3FindInIndex()
5620 #define IN_INDEX_ROWID 1 /* Search the rowid of the table */
5621 #define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
5622 #define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */
5623 #define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */
5624 #define IN_INDEX_NOOP 5 /* No table available. Use comparisons */
5626 ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
5628 #define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
5629 #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
5630 #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
5631 int sqlite3FindInIndex(Parse
*, Expr
*, u32
, int*, int*, int*);
5633 int sqlite3JournalOpen(sqlite3_vfs
*, const char *, sqlite3_file
*, int, int);
5634 int sqlite3JournalSize(sqlite3_vfs
*);
5635 #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
5636 || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
5637 int sqlite3JournalCreate(sqlite3_file
*);
5640 int sqlite3JournalIsInMemory(sqlite3_file
*p
);
5641 void sqlite3MemJournalOpen(sqlite3_file
*);
5643 void sqlite3ExprSetHeightAndFlags(Parse
*pParse
, Expr
*p
);
5644 #if SQLITE_MAX_EXPR_DEPTH>0
5645 int sqlite3SelectExprHeight(const Select
*);
5646 int sqlite3ExprCheckHeight(Parse
*, int);
5648 #define sqlite3SelectExprHeight(x) 0
5649 #define sqlite3ExprCheckHeight(x,y)
5651 void sqlite3ExprSetErrorOffset(Expr
*,int);
5653 u32
sqlite3Get4byte(const u8
*);
5654 void sqlite3Put4byte(u8
*, u32
);
5656 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
5657 void sqlite3ConnectionBlocked(sqlite3
*, sqlite3
*);
5658 void sqlite3ConnectionUnlocked(sqlite3
*db
);
5659 void sqlite3ConnectionClosed(sqlite3
*db
);
5661 #define sqlite3ConnectionBlocked(x,y)
5662 #define sqlite3ConnectionUnlocked(x)
5663 #define sqlite3ConnectionClosed(x)
5667 void sqlite3ParserTrace(FILE*, char *);
5669 #if defined(YYCOVERAGE)
5670 int sqlite3ParserCoverage(FILE*);
5674 ** If the SQLITE_ENABLE IOTRACE exists then the global variable
5675 ** sqlite3IoTrace is a pointer to a printf-like routine used to
5676 ** print I/O tracing messages.
5678 #ifdef SQLITE_ENABLE_IOTRACE
5679 # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
5680 void sqlite3VdbeIOTraceSql(Vdbe
*);
5681 SQLITE_API SQLITE_EXTERN
void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*,...);
5684 # define sqlite3VdbeIOTraceSql(X)
5688 ** These routines are available for the mem2.c debugging memory allocator
5689 ** only. They are used to verify that different "types" of memory
5690 ** allocations are properly tracked by the system.
5692 ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
5693 ** the MEMTYPE_* macros defined below. The type must be a bitmask with
5694 ** a single bit set.
5696 ** sqlite3MemdebugHasType() returns true if any of the bits in its second
5697 ** argument match the type set by the previous sqlite3MemdebugSetType().
5698 ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
5700 ** sqlite3MemdebugNoType() returns true if none of the bits in its second
5701 ** argument match the type set by the previous sqlite3MemdebugSetType().
5703 ** Perhaps the most important point is the difference between MEMTYPE_HEAP
5704 ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
5705 ** it might have been allocated by lookaside, except the allocation was
5706 ** too large or lookaside was already full. It is important to verify
5707 ** that allocations that might have been satisfied by lookaside are not
5708 ** passed back to non-lookaside free() routines. Asserts such as the
5709 ** example above are placed on the non-lookaside free() routines to verify
5712 ** All of this is no-op for a production build. It only comes into
5713 ** play when the SQLITE_MEMDEBUG compile-time option is used.
5715 #ifdef SQLITE_MEMDEBUG
5716 void sqlite3MemdebugSetType(void*,u8
);
5717 int sqlite3MemdebugHasType(const void*,u8
);
5718 int sqlite3MemdebugNoType(const void*,u8
);
5720 # define sqlite3MemdebugSetType(X,Y) /* no-op */
5721 # define sqlite3MemdebugHasType(X,Y) 1
5722 # define sqlite3MemdebugNoType(X,Y) 1
5724 #define MEMTYPE_HEAP 0x01 /* General heap allocations */
5725 #define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */
5726 #define MEMTYPE_PCACHE 0x04 /* Page cache allocations */
5729 ** Threading interface
5731 #if SQLITE_MAX_WORKER_THREADS>0
5732 int sqlite3ThreadCreate(SQLiteThread
**,void*(*)(void*),void*);
5733 int sqlite3ThreadJoin(SQLiteThread
*, void**);
5736 #if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)
5737 int sqlite3DbpageRegister(sqlite3
*);
5739 #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
5740 int sqlite3DbstatRegister(sqlite3
*);
5743 int sqlite3ExprVectorSize(const Expr
*pExpr
);
5744 int sqlite3ExprIsVector(const Expr
*pExpr
);
5745 Expr
*sqlite3VectorFieldSubexpr(Expr
*, int);
5746 Expr
*sqlite3ExprForVectorField(Parse
*,Expr
*,int,int);
5747 void sqlite3VectorErrorMsg(Parse
*, Expr
*);
5749 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
5750 const char **sqlite3CompileOptions(int *pnOpt
);
5753 #if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL)
5754 int sqlite3KvvfsInit(void);
5757 #if defined(VDBE_PROFILE) \
5758 || defined(SQLITE_PERFORMANCE_TRACE) \
5759 || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
5760 sqlite3_uint64
sqlite3Hwtime(void);
5763 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
5764 # define IS_STMT_SCANSTATUS(db) (db->flags & SQLITE_StmtScanStatus)
5766 # define IS_STMT_SCANSTATUS(db) 0
5769 #endif /* SQLITEINT_H */