000001  /*
000002  ** 2001 September 15
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  ** Internal interface definitions for SQLite.
000013  **
000014  */
000015  #ifndef SQLITEINT_H
000016  #define SQLITEINT_H
000017  
000018  /* Special Comments:
000019  **
000020  ** Some comments have special meaning to the tools that measure test
000021  ** coverage:
000022  **
000023  **    NO_TEST                     - The branches on this line are not
000024  **                                  measured by branch coverage.  This is
000025  **                                  used on lines of code that actually
000026  **                                  implement parts of coverage testing.
000027  **
000028  **    OPTIMIZATION-IF-TRUE        - This branch is allowed to always be false
000029  **                                  and the correct answer is still obtained,
000030  **                                  though perhaps more slowly.
000031  **
000032  **    OPTIMIZATION-IF-FALSE       - This branch is allowed to always be true
000033  **                                  and the correct answer is still obtained,
000034  **                                  though perhaps more slowly.
000035  **
000036  **    PREVENTS-HARMLESS-OVERREAD  - This branch prevents a buffer overread
000037  **                                  that would be harmless and undetectable
000038  **                                  if it did occur.
000039  **
000040  ** In all cases, the special comment must be enclosed in the usual
000041  ** slash-asterisk...asterisk-slash comment marks, with no spaces between the
000042  ** asterisks and the comment text.
000043  */
000044  
000045  /*
000046  ** Make sure the Tcl calling convention macro is defined.  This macro is
000047  ** only used by test code and Tcl integration code.
000048  */
000049  #ifndef SQLITE_TCLAPI
000050  #  define SQLITE_TCLAPI
000051  #endif
000052  
000053  /*
000054  ** Include the header file used to customize the compiler options for MSVC.
000055  ** This should be done first so that it can successfully prevent spurious
000056  ** compiler warnings due to subsequent content in this file and other files
000057  ** that are included by this file.
000058  */
000059  #include "msvc.h"
000060  
000061  /*
000062  ** Special setup for VxWorks
000063  */
000064  #include "vxworks.h"
000065  
000066  /*
000067  ** These #defines should enable >2GB file support on POSIX if the
000068  ** underlying operating system supports it.  If the OS lacks
000069  ** large file support, or if the OS is windows, these should be no-ops.
000070  **
000071  ** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
000072  ** system #includes.  Hence, this block of code must be the very first
000073  ** code in all source files.
000074  **
000075  ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
000076  ** on the compiler command line.  This is necessary if you are compiling
000077  ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
000078  ** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2
000079  ** without this option, LFS is enable.  But LFS does not exist in the kernel
000080  ** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary
000081  ** portability you should omit LFS.
000082  **
000083  ** The previous paragraph was written in 2005.  (This paragraph is written
000084  ** on 2008-11-28.) These days, all Linux kernels support large files, so
000085  ** you should probably leave LFS enabled.  But some embedded platforms might
000086  ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
000087  **
000088  ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
000089  */
000090  #ifndef SQLITE_DISABLE_LFS
000091  # define _LARGE_FILE       1
000092  # ifndef _FILE_OFFSET_BITS
000093  #   define _FILE_OFFSET_BITS 64
000094  # endif
000095  # define _LARGEFILE_SOURCE 1
000096  #endif
000097  
000098  /* The GCC_VERSION and MSVC_VERSION macros are used to
000099  ** conditionally include optimizations for each of these compilers.  A
000100  ** value of 0 means that compiler is not being used.  The
000101  ** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
000102  ** optimizations, and hence set all compiler macros to 0
000103  **
000104  ** There was once also a CLANG_VERSION macro.  However, we learn that the
000105  ** version numbers in clang are for "marketing" only and are inconsistent
000106  ** and unreliable.  Fortunately, all versions of clang also recognize the
000107  ** gcc version numbers and have reasonable settings for gcc version numbers,
000108  ** so the GCC_VERSION macro will be set to a correct non-zero value even
000109  ** when compiling with clang.
000110  */
000111  #if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)
000112  # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
000113  #else
000114  # define GCC_VERSION 0
000115  #endif
000116  #if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
000117  # define MSVC_VERSION _MSC_VER
000118  #else
000119  # define MSVC_VERSION 0
000120  #endif
000121  
000122  /*
000123  ** Some C99 functions in "math.h" are only present for MSVC when its version
000124  ** is associated with Visual Studio 2013 or higher.
000125  */
000126  #ifndef SQLITE_HAVE_C99_MATH_FUNCS
000127  # if MSVC_VERSION==0 || MSVC_VERSION>=1800
000128  #  define SQLITE_HAVE_C99_MATH_FUNCS (1)
000129  # else
000130  #  define SQLITE_HAVE_C99_MATH_FUNCS (0)
000131  # endif
000132  #endif
000133  
000134  /* Needed for various definitions... */
000135  #if defined(__GNUC__) && !defined(_GNU_SOURCE)
000136  # define _GNU_SOURCE
000137  #endif
000138  
000139  #if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
000140  # define _BSD_SOURCE
000141  #endif
000142  
000143  /*
000144  ** Macro to disable warnings about missing "break" at the end of a "case".
000145  */
000146  #if GCC_VERSION>=7000000
000147  # define deliberate_fall_through __attribute__((fallthrough));
000148  #else
000149  # define deliberate_fall_through
000150  #endif
000151  
000152  /*
000153  ** For MinGW, check to see if we can include the header file containing its
000154  ** version information, among other things.  Normally, this internal MinGW
000155  ** header file would [only] be included automatically by other MinGW header
000156  ** files; however, the contained version information is now required by this
000157  ** header file to work around binary compatibility issues (see below) and
000158  ** this is the only known way to reliably obtain it.  This entire #if block
000159  ** would be completely unnecessary if there was any other way of detecting
000160  ** MinGW via their preprocessor (e.g. if they customized their GCC to define
000161  ** some MinGW-specific macros).  When compiling for MinGW, either the
000162  ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
000163  ** defined; otherwise, detection of conditions specific to MinGW will be
000164  ** disabled.
000165  */
000166  #if defined(_HAVE_MINGW_H)
000167  # include "mingw.h"
000168  #elif defined(_HAVE__MINGW_H)
000169  # include "_mingw.h"
000170  #endif
000171  
000172  /*
000173  ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
000174  ** define is required to maintain binary compatibility with the MSVC runtime
000175  ** library in use (e.g. for Windows XP).
000176  */
000177  #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
000178      defined(_WIN32) && !defined(_WIN64) && \
000179      defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
000180      defined(__MSVCRT__)
000181  # define _USE_32BIT_TIME_T
000182  #endif
000183  
000184  /* Optionally #include a user-defined header, whereby compilation options
000185  ** may be set prior to where they take effect, but after platform setup.
000186  ** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include
000187  ** file.
000188  */
000189  #ifdef SQLITE_CUSTOM_INCLUDE
000190  # define INC_STRINGIFY_(f) #f
000191  # define INC_STRINGIFY(f) INC_STRINGIFY_(f)
000192  # include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE)
000193  #endif
000194  
000195  /* The public SQLite interface.  The _FILE_OFFSET_BITS macro must appear
000196  ** first in QNX.  Also, the _USE_32BIT_TIME_T macro must appear first for
000197  ** MinGW.
000198  */
000199  #include "sqlite3.h"
000200  
000201  /*
000202  ** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory.
000203  */
000204  #define SQLITE_MUTEX_STATIC_TEMPDIR SQLITE_MUTEX_STATIC_VFS1
000205  
000206  /*
000207  ** Include the configuration header output by 'configure' if we're using the
000208  ** autoconf-based build
000209  */
000210  #if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
000211  #include "sqlite_cfg.h"
000212  #define SQLITECONFIG_H 1
000213  #endif
000214  
000215  #include "sqliteLimit.h"
000216  
000217  /* Disable nuisance warnings on Borland compilers */
000218  #if defined(__BORLANDC__)
000219  #pragma warn -rch /* unreachable code */
000220  #pragma warn -ccc /* Condition is always true or false */
000221  #pragma warn -aus /* Assigned value is never used */
000222  #pragma warn -csu /* Comparing signed and unsigned */
000223  #pragma warn -spa /* Suspicious pointer arithmetic */
000224  #endif
000225  
000226  /*
000227  ** A few places in the code require atomic load/store of aligned
000228  ** integer values.
000229  */
000230  #ifndef __has_extension
000231  # define __has_extension(x) 0     /* compatibility with non-clang compilers */
000232  #endif
000233  #if GCC_VERSION>=4007000 || __has_extension(c_atomic)
000234  # define SQLITE_ATOMIC_INTRINSICS 1
000235  # define AtomicLoad(PTR)       __atomic_load_n((PTR),__ATOMIC_RELAXED)
000236  # define AtomicStore(PTR,VAL)  __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED)
000237  #else
000238  # define SQLITE_ATOMIC_INTRINSICS 0
000239  # define AtomicLoad(PTR)       (*(PTR))
000240  # define AtomicStore(PTR,VAL)  (*(PTR) = (VAL))
000241  #endif
000242  
000243  /*
000244  ** Include standard header files as necessary
000245  */
000246  #ifdef HAVE_STDINT_H
000247  #include <stdint.h>
000248  #endif
000249  #ifdef HAVE_INTTYPES_H
000250  #include <inttypes.h>
000251  #endif
000252  
000253  /*
000254  ** The following macros are used to cast pointers to integers and
000255  ** integers to pointers.  The way you do this varies from one compiler
000256  ** to the next, so we have developed the following set of #if statements
000257  ** to generate appropriate macros for a wide range of compilers.
000258  **
000259  ** The correct "ANSI" way to do this is to use the intptr_t type.
000260  ** Unfortunately, that typedef is not available on all compilers, or
000261  ** if it is available, it requires an #include of specific headers
000262  ** that vary from one machine to the next.
000263  **
000264  ** Ticket #3860:  The llvm-gcc-4.2 compiler from Apple chokes on
000265  ** the ((void*)&((char*)0)[X]) construct.  But MSVC chokes on ((void*)(X)).
000266  ** So we have to define the macros in different ways depending on the
000267  ** compiler.
000268  */
000269  #if defined(HAVE_STDINT_H)   /* Use this case if we have ANSI headers */
000270  # define SQLITE_INT_TO_PTR(X)  ((void*)(intptr_t)(X))
000271  # define SQLITE_PTR_TO_INT(X)  ((int)(intptr_t)(X))
000272  #elif defined(__PTRDIFF_TYPE__)  /* This case should work for GCC */
000273  # define SQLITE_INT_TO_PTR(X)  ((void*)(__PTRDIFF_TYPE__)(X))
000274  # define SQLITE_PTR_TO_INT(X)  ((int)(__PTRDIFF_TYPE__)(X))
000275  #elif !defined(__GNUC__)       /* Works for compilers other than LLVM */
000276  # define SQLITE_INT_TO_PTR(X)  ((void*)&((char*)0)[X])
000277  # define SQLITE_PTR_TO_INT(X)  ((int)(((char*)X)-(char*)0))
000278  #else                          /* Generates a warning - but it always works */
000279  # define SQLITE_INT_TO_PTR(X)  ((void*)(X))
000280  # define SQLITE_PTR_TO_INT(X)  ((int)(X))
000281  #endif
000282  
000283  /*
000284  ** Macros to hint to the compiler that a function should or should not be
000285  ** inlined.
000286  */
000287  #if defined(__GNUC__)
000288  #  define SQLITE_NOINLINE  __attribute__((noinline))
000289  #  define SQLITE_INLINE    __attribute__((always_inline)) inline
000290  #elif defined(_MSC_VER) && _MSC_VER>=1310
000291  #  define SQLITE_NOINLINE  __declspec(noinline)
000292  #  define SQLITE_INLINE    __forceinline
000293  #else
000294  #  define SQLITE_NOINLINE
000295  #  define SQLITE_INLINE
000296  #endif
000297  #if defined(SQLITE_COVERAGE_TEST) || defined(__STRICT_ANSI__)
000298  # undef SQLITE_INLINE
000299  # define SQLITE_INLINE
000300  #endif
000301  
000302  /*
000303  ** Make sure that the compiler intrinsics we desire are enabled when
000304  ** compiling with an appropriate version of MSVC unless prevented by
000305  ** the SQLITE_DISABLE_INTRINSIC define.
000306  */
000307  #if !defined(SQLITE_DISABLE_INTRINSIC)
000308  #  if defined(_MSC_VER) && _MSC_VER>=1400
000309  #    if !defined(_WIN32_WCE)
000310  #      include <intrin.h>
000311  #      pragma intrinsic(_byteswap_ushort)
000312  #      pragma intrinsic(_byteswap_ulong)
000313  #      pragma intrinsic(_byteswap_uint64)
000314  #      pragma intrinsic(_ReadWriteBarrier)
000315  #    else
000316  #      include <cmnintrin.h>
000317  #    endif
000318  #  endif
000319  #endif
000320  
000321  /*
000322  ** Enable SQLITE_USE_SEH by default on MSVC builds.  Only omit
000323  ** SEH support if the -DSQLITE_OMIT_SEH option is given.
000324  */
000325  #if defined(_MSC_VER) && !defined(SQLITE_OMIT_SEH)
000326  # define SQLITE_USE_SEH 1
000327  #else
000328  # undef SQLITE_USE_SEH
000329  #endif
000330  
000331  /*
000332  ** Enable SQLITE_DIRECT_OVERFLOW_READ, unless the build explicitly
000333  ** disables it using -DSQLITE_DIRECT_OVERFLOW_READ=0
000334  */
000335  #if defined(SQLITE_DIRECT_OVERFLOW_READ) && SQLITE_DIRECT_OVERFLOW_READ+1==1
000336    /* Disable if -DSQLITE_DIRECT_OVERFLOW_READ=0 */
000337  # undef SQLITE_DIRECT_OVERFLOW_READ
000338  #else
000339    /* In all other cases, enable */
000340  # define SQLITE_DIRECT_OVERFLOW_READ 1
000341  #endif
000342  
000343  
000344  /*
000345  ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
000346  ** 0 means mutexes are permanently disable and the library is never
000347  ** threadsafe.  1 means the library is serialized which is the highest
000348  ** level of threadsafety.  2 means the library is multithreaded - multiple
000349  ** threads can use SQLite as long as no two threads try to use the same
000350  ** database connection at the same time.
000351  **
000352  ** Older versions of SQLite used an optional THREADSAFE macro.
000353  ** We support that for legacy.
000354  **
000355  ** To ensure that the correct value of "THREADSAFE" is reported when querying
000356  ** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this
000357  ** logic is partially replicated in ctime.c. If it is updated here, it should
000358  ** also be updated there.
000359  */
000360  #if !defined(SQLITE_THREADSAFE)
000361  # if defined(THREADSAFE)
000362  #   define SQLITE_THREADSAFE THREADSAFE
000363  # else
000364  #   define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
000365  # endif
000366  #endif
000367  
000368  /*
000369  ** Powersafe overwrite is on by default.  But can be turned off using
000370  ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
000371  */
000372  #ifndef SQLITE_POWERSAFE_OVERWRITE
000373  # define SQLITE_POWERSAFE_OVERWRITE 1
000374  #endif
000375  
000376  /*
000377  ** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
000378  ** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in
000379  ** which case memory allocation statistics are disabled by default.
000380  */
000381  #if !defined(SQLITE_DEFAULT_MEMSTATUS)
000382  # define SQLITE_DEFAULT_MEMSTATUS 1
000383  #endif
000384  
000385  /*
000386  ** Exactly one of the following macros must be defined in order to
000387  ** specify which memory allocation subsystem to use.
000388  **
000389  **     SQLITE_SYSTEM_MALLOC          // Use normal system malloc()
000390  **     SQLITE_WIN32_MALLOC           // Use Win32 native heap API
000391  **     SQLITE_ZERO_MALLOC            // Use a stub allocator that always fails
000392  **     SQLITE_MEMDEBUG               // Debugging version of system malloc()
000393  **
000394  ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
000395  ** assert() macro is enabled, each call into the Win32 native heap subsystem
000396  ** will cause HeapValidate to be called.  If heap validation should fail, an
000397  ** assertion will be triggered.
000398  **
000399  ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
000400  ** the default.
000401  */
000402  #if defined(SQLITE_SYSTEM_MALLOC) \
000403    + defined(SQLITE_WIN32_MALLOC) \
000404    + defined(SQLITE_ZERO_MALLOC) \
000405    + defined(SQLITE_MEMDEBUG)>1
000406  # error "Two or more of the following compile-time configuration options\
000407   are defined but at most one is allowed:\
000408   SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\
000409   SQLITE_ZERO_MALLOC"
000410  #endif
000411  #if defined(SQLITE_SYSTEM_MALLOC) \
000412    + defined(SQLITE_WIN32_MALLOC) \
000413    + defined(SQLITE_ZERO_MALLOC) \
000414    + defined(SQLITE_MEMDEBUG)==0
000415  # define SQLITE_SYSTEM_MALLOC 1
000416  #endif
000417  
000418  /*
000419  ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
000420  ** sizes of memory allocations below this value where possible.
000421  */
000422  #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
000423  # define SQLITE_MALLOC_SOFT_LIMIT 1024
000424  #endif
000425  
000426  /*
000427  ** We need to define _XOPEN_SOURCE as follows in order to enable
000428  ** recursive mutexes on most Unix systems and fchmod() on OpenBSD.
000429  ** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
000430  ** it.
000431  */
000432  #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
000433  #  define _XOPEN_SOURCE 600
000434  #endif
000435  
000436  /*
000437  ** NDEBUG and SQLITE_DEBUG are opposites.  It should always be true that
000438  ** defined(NDEBUG)==!defined(SQLITE_DEBUG).  If this is not currently true,
000439  ** make it true by defining or undefining NDEBUG.
000440  **
000441  ** Setting NDEBUG makes the code smaller and faster by disabling the
000442  ** assert() statements in the code.  So we want the default action
000443  ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
000444  ** is set.  Thus NDEBUG becomes an opt-in rather than an opt-out
000445  ** feature.
000446  */
000447  #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
000448  # define NDEBUG 1
000449  #endif
000450  #if defined(NDEBUG) && defined(SQLITE_DEBUG)
000451  # undef NDEBUG
000452  #endif
000453  
000454  /*
000455  ** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
000456  */
000457  #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
000458  # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
000459  #endif
000460  
000461  /*
000462  ** The testcase() macro is used to aid in coverage testing.  When
000463  ** doing coverage testing, the condition inside the argument to
000464  ** testcase() must be evaluated both true and false in order to
000465  ** get full branch coverage.  The testcase() macro is inserted
000466  ** to help ensure adequate test coverage in places where simple
000467  ** condition/decision coverage is inadequate.  For example, testcase()
000468  ** can be used to make sure boundary values are tested.  For
000469  ** bitmask tests, testcase() can be used to make sure each bit
000470  ** is significant and used at least once.  On switch statements
000471  ** where multiple cases go to the same block of code, testcase()
000472  ** can insure that all cases are evaluated.
000473  */
000474  #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
000475  # ifndef SQLITE_AMALGAMATION
000476      extern unsigned int sqlite3CoverageCounter;
000477  # endif
000478  # define testcase(X)  if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; }
000479  #else
000480  # define testcase(X)
000481  #endif
000482  
000483  /*
000484  ** The TESTONLY macro is used to enclose variable declarations or
000485  ** other bits of code that are needed to support the arguments
000486  ** within testcase() and assert() macros.
000487  */
000488  #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
000489  # define TESTONLY(X)  X
000490  #else
000491  # define TESTONLY(X)
000492  #endif
000493  
000494  /*
000495  ** Sometimes we need a small amount of code such as a variable initialization
000496  ** to setup for a later assert() statement.  We do not want this code to
000497  ** appear when assert() is disabled.  The following macro is therefore
000498  ** used to contain that setup code.  The "VVA" acronym stands for
000499  ** "Verification, Validation, and Accreditation".  In other words, the
000500  ** code within VVA_ONLY() will only run during verification processes.
000501  */
000502  #ifndef NDEBUG
000503  # define VVA_ONLY(X)  X
000504  #else
000505  # define VVA_ONLY(X)
000506  #endif
000507  
000508  /*
000509  ** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage
000510  ** and mutation testing
000511  */
000512  #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
000513  # define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS  1
000514  #endif
000515  
000516  /*
000517  ** The ALWAYS and NEVER macros surround boolean expressions which
000518  ** are intended to always be true or false, respectively.  Such
000519  ** expressions could be omitted from the code completely.  But they
000520  ** are included in a few cases in order to enhance the resilience
000521  ** of SQLite to unexpected behavior - to make the code "self-healing"
000522  ** or "ductile" rather than being "brittle" and crashing at the first
000523  ** hint of unplanned behavior.
000524  **
000525  ** In other words, ALWAYS and NEVER are added for defensive code.
000526  **
000527  ** When doing coverage testing ALWAYS and NEVER are hard-coded to
000528  ** be true and false so that the unreachable code they specify will
000529  ** not be counted as untested code.
000530  */
000531  #if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
000532  # define ALWAYS(X)      (1)
000533  # define NEVER(X)       (0)
000534  #elif !defined(NDEBUG)
000535  # define ALWAYS(X)      ((X)?1:(assert(0),0))
000536  # define NEVER(X)       ((X)?(assert(0),1):0)
000537  #else
000538  # define ALWAYS(X)      (X)
000539  # define NEVER(X)       (X)
000540  #endif
000541  
000542  /*
000543  ** Some conditionals are optimizations only.  In other words, if the
000544  ** conditionals are replaced with a constant 1 (true) or 0 (false) then
000545  ** the correct answer is still obtained, though perhaps not as quickly.
000546  **
000547  ** The following macros mark these optimizations conditionals.
000548  */
000549  #if defined(SQLITE_MUTATION_TEST)
000550  # define OK_IF_ALWAYS_TRUE(X)  (1)
000551  # define OK_IF_ALWAYS_FALSE(X) (0)
000552  #else
000553  # define OK_IF_ALWAYS_TRUE(X)  (X)
000554  # define OK_IF_ALWAYS_FALSE(X) (X)
000555  #endif
000556  
000557  /*
000558  ** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
000559  ** defined.  We need to defend against those failures when testing with
000560  ** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
000561  ** during a normal build.  The following macro can be used to disable tests
000562  ** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
000563  */
000564  #if defined(SQLITE_TEST_REALLOC_STRESS)
000565  # define ONLY_IF_REALLOC_STRESS(X)  (X)
000566  #elif !defined(NDEBUG)
000567  # define ONLY_IF_REALLOC_STRESS(X)  ((X)?(assert(0),1):0)
000568  #else
000569  # define ONLY_IF_REALLOC_STRESS(X)  (0)
000570  #endif
000571  
000572  /*
000573  ** Declarations used for tracing the operating system interfaces.
000574  */
000575  #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \
000576      (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
000577    extern int sqlite3OSTrace;
000578  # define OSTRACE(X)          if( sqlite3OSTrace ) sqlite3DebugPrintf X
000579  # define SQLITE_HAVE_OS_TRACE
000580  #else
000581  # define OSTRACE(X)
000582  # undef  SQLITE_HAVE_OS_TRACE
000583  #endif
000584  
000585  /*
000586  ** Is the sqlite3ErrName() function needed in the build?  Currently,
000587  ** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when
000588  ** OSTRACE is enabled), and by several "test*.c" files (which are
000589  ** compiled using SQLITE_TEST).
000590  */
000591  #if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \
000592      (defined(SQLITE_DEBUG) && SQLITE_OS_WIN)
000593  # define SQLITE_NEED_ERR_NAME
000594  #else
000595  # undef  SQLITE_NEED_ERR_NAME
000596  #endif
000597  
000598  /*
000599  ** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN
000600  */
000601  #ifdef SQLITE_OMIT_EXPLAIN
000602  # undef SQLITE_ENABLE_EXPLAIN_COMMENTS
000603  #endif
000604  
000605  /*
000606  ** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE
000607  */
000608  #if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE)
000609  # define SQLITE_OMIT_ALTERTABLE
000610  #endif
000611  
000612  /*
000613  ** Return true (non-zero) if the input is an integer that is too large
000614  ** to fit in 32-bits.  This macro is used inside of various testcase()
000615  ** macros to verify that we have tested SQLite for large-file support.
000616  */
000617  #define IS_BIG_INT(X)  (((X)&~(i64)0xffffffff)!=0)
000618  
000619  /*
000620  ** The macro unlikely() is a hint that surrounds a boolean
000621  ** expression that is usually false.  Macro likely() surrounds
000622  ** a boolean expression that is usually true.  These hints could,
000623  ** in theory, be used by the compiler to generate better code, but
000624  ** currently they are just comments for human readers.
000625  */
000626  #define likely(X)    (X)
000627  #define unlikely(X)  (X)
000628  
000629  #include "hash.h"
000630  #include "parse.h"
000631  #include <stdio.h>
000632  #include <stdlib.h>
000633  #include <string.h>
000634  #include <assert.h>
000635  #include <stddef.h>
000636  
000637  /*
000638  ** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
000639  ** This allows better measurements of where memcpy() is used when running
000640  ** cachegrind.  But this macro version of memcpy() is very slow so it
000641  ** should not be used in production.  This is a performance measurement
000642  ** hack only.
000643  */
000644  #ifdef SQLITE_INLINE_MEMCPY
000645  # define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
000646                          int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
000647  #endif
000648  
000649  /*
000650  ** If compiling for a processor that lacks floating point support,
000651  ** substitute integer for floating-point
000652  */
000653  #ifdef SQLITE_OMIT_FLOATING_POINT
000654  # define double sqlite_int64
000655  # define float sqlite_int64
000656  # define LONGDOUBLE_TYPE sqlite_int64
000657  # ifndef SQLITE_BIG_DBL
000658  #   define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
000659  # endif
000660  # define SQLITE_OMIT_DATETIME_FUNCS 1
000661  # define SQLITE_OMIT_TRACE 1
000662  # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
000663  # undef SQLITE_HAVE_ISNAN
000664  #endif
000665  #ifndef SQLITE_BIG_DBL
000666  # define SQLITE_BIG_DBL (1e99)
000667  #endif
000668  
000669  /*
000670  ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
000671  ** afterward. Having this macro allows us to cause the C compiler
000672  ** to omit code used by TEMP tables without messy #ifndef statements.
000673  */
000674  #ifdef SQLITE_OMIT_TEMPDB
000675  #define OMIT_TEMPDB 1
000676  #else
000677  #define OMIT_TEMPDB 0
000678  #endif
000679  
000680  /*
000681  ** The "file format" number is an integer that is incremented whenever
000682  ** the VDBE-level file format changes.  The following macros define the
000683  ** the default file format for new databases and the maximum file format
000684  ** that the library can read.
000685  */
000686  #define SQLITE_MAX_FILE_FORMAT 4
000687  #ifndef SQLITE_DEFAULT_FILE_FORMAT
000688  # define SQLITE_DEFAULT_FILE_FORMAT 4
000689  #endif
000690  
000691  /*
000692  ** Determine whether triggers are recursive by default.  This can be
000693  ** changed at run-time using a pragma.
000694  */
000695  #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
000696  # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
000697  #endif
000698  
000699  /*
000700  ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
000701  ** on the command-line
000702  */
000703  #ifndef SQLITE_TEMP_STORE
000704  # define SQLITE_TEMP_STORE 1
000705  #endif
000706  
000707  /*
000708  ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
000709  ** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
000710  ** to zero.
000711  */
000712  #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
000713  # undef SQLITE_MAX_WORKER_THREADS
000714  # define SQLITE_MAX_WORKER_THREADS 0
000715  #endif
000716  #ifndef SQLITE_MAX_WORKER_THREADS
000717  # define SQLITE_MAX_WORKER_THREADS 8
000718  #endif
000719  #ifndef SQLITE_DEFAULT_WORKER_THREADS
000720  # define SQLITE_DEFAULT_WORKER_THREADS 0
000721  #endif
000722  #if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS
000723  # undef SQLITE_MAX_WORKER_THREADS
000724  # define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS
000725  #endif
000726  
000727  /*
000728  ** The default initial allocation for the pagecache when using separate
000729  ** pagecaches for each database connection.  A positive number is the
000730  ** number of pages.  A negative number N translations means that a buffer
000731  ** of -1024*N bytes is allocated and used for as many pages as it will hold.
000732  **
000733  ** The default value of "20" was chosen to minimize the run-time of the
000734  ** speedtest1 test program with options: --shrink-memory --reprepare
000735  */
000736  #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
000737  # define SQLITE_DEFAULT_PCACHE_INITSZ 20
000738  #endif
000739  
000740  /*
000741  ** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.
000742  */
000743  #ifndef SQLITE_DEFAULT_SORTERREF_SIZE
000744  # define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff
000745  #endif
000746  
000747  /*
000748  ** The compile-time options SQLITE_MMAP_READWRITE and
000749  ** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.
000750  ** You must choose one or the other (or neither) but not both.
000751  */
000752  #if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
000753  #error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE
000754  #endif
000755  
000756  /*
000757  ** GCC does not define the offsetof() macro so we'll have to do it
000758  ** ourselves.
000759  */
000760  #ifndef offsetof
000761  #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
000762  #endif
000763  
000764  /*
000765  ** Macros to compute minimum and maximum of two numbers.
000766  */
000767  #ifndef MIN
000768  # define MIN(A,B) ((A)<(B)?(A):(B))
000769  #endif
000770  #ifndef MAX
000771  # define MAX(A,B) ((A)>(B)?(A):(B))
000772  #endif
000773  
000774  /*
000775  ** Swap two objects of type TYPE.
000776  */
000777  #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
000778  
000779  /*
000780  ** Check to see if this machine uses EBCDIC.  (Yes, believe it or
000781  ** not, there are still machines out there that use EBCDIC.)
000782  */
000783  #if 'A' == '\301'
000784  # define SQLITE_EBCDIC 1
000785  #else
000786  # define SQLITE_ASCII 1
000787  #endif
000788  
000789  /*
000790  ** Integers of known sizes.  These typedefs might change for architectures
000791  ** where the sizes very.  Preprocessor macros are available so that the
000792  ** types can be conveniently redefined at compile-type.  Like this:
000793  **
000794  **         cc '-DUINTPTR_TYPE=long long int' ...
000795  */
000796  #ifndef UINT32_TYPE
000797  # ifdef HAVE_UINT32_T
000798  #  define UINT32_TYPE uint32_t
000799  # else
000800  #  define UINT32_TYPE unsigned int
000801  # endif
000802  #endif
000803  #ifndef UINT16_TYPE
000804  # ifdef HAVE_UINT16_T
000805  #  define UINT16_TYPE uint16_t
000806  # else
000807  #  define UINT16_TYPE unsigned short int
000808  # endif
000809  #endif
000810  #ifndef INT16_TYPE
000811  # ifdef HAVE_INT16_T
000812  #  define INT16_TYPE int16_t
000813  # else
000814  #  define INT16_TYPE short int
000815  # endif
000816  #endif
000817  #ifndef UINT8_TYPE
000818  # ifdef HAVE_UINT8_T
000819  #  define UINT8_TYPE uint8_t
000820  # else
000821  #  define UINT8_TYPE unsigned char
000822  # endif
000823  #endif
000824  #ifndef INT8_TYPE
000825  # ifdef HAVE_INT8_T
000826  #  define INT8_TYPE int8_t
000827  # else
000828  #  define INT8_TYPE signed char
000829  # endif
000830  #endif
000831  #ifndef LONGDOUBLE_TYPE
000832  # define LONGDOUBLE_TYPE long double
000833  #endif
000834  typedef sqlite_int64 i64;          /* 8-byte signed integer */
000835  typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */
000836  typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */
000837  typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
000838  typedef INT16_TYPE i16;            /* 2-byte signed integer */
000839  typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */
000840  typedef INT8_TYPE i8;              /* 1-byte signed integer */
000841  
000842  /*
000843  ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
000844  ** that can be stored in a u32 without loss of data.  The value
000845  ** is 0x00000000ffffffff.  But because of quirks of some compilers, we
000846  ** have to specify the value in the less intuitive manner shown:
000847  */
000848  #define SQLITE_MAX_U32  ((((u64)1)<<32)-1)
000849  
000850  /*
000851  ** The datatype used to store estimates of the number of rows in a
000852  ** table or index.
000853  */
000854  typedef u64 tRowcnt;
000855  
000856  /*
000857  ** Estimated quantities used for query planning are stored as 16-bit
000858  ** logarithms.  For quantity X, the value stored is 10*log2(X).  This
000859  ** gives a possible range of values of approximately 1.0e986 to 1e-986.
000860  ** But the allowed values are "grainy".  Not every value is representable.
000861  ** For example, quantities 16 and 17 are both represented by a LogEst
000862  ** of 40.  However, since LogEst quantities are suppose to be estimates,
000863  ** not exact values, this imprecision is not a problem.
000864  **
000865  ** "LogEst" is short for "Logarithmic Estimate".
000866  **
000867  ** Examples:
000868  **      1 -> 0              20 -> 43          10000 -> 132
000869  **      2 -> 10             25 -> 46          25000 -> 146
000870  **      3 -> 16            100 -> 66        1000000 -> 199
000871  **      4 -> 20           1000 -> 99        1048576 -> 200
000872  **     10 -> 33           1024 -> 100    4294967296 -> 320
000873  **
000874  ** The LogEst can be negative to indicate fractional values.
000875  ** Examples:
000876  **
000877  **    0.5 -> -10           0.1 -> -33        0.0625 -> -40
000878  */
000879  typedef INT16_TYPE LogEst;
000880  
000881  /*
000882  ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
000883  */
000884  #ifndef SQLITE_PTRSIZE
000885  # if defined(__SIZEOF_POINTER__)
000886  #   define SQLITE_PTRSIZE __SIZEOF_POINTER__
000887  # elif defined(i386)     || defined(__i386__)   || defined(_M_IX86) ||    \
000888         defined(_M_ARM)   || defined(__arm__)    || defined(__x86)   ||    \
000889        (defined(__APPLE__) && defined(__POWERPC__)) ||                     \
000890        (defined(__TOS_AIX__) && !defined(__64BIT__))
000891  #   define SQLITE_PTRSIZE 4
000892  # else
000893  #   define SQLITE_PTRSIZE 8
000894  # endif
000895  #endif
000896  
000897  /* The uptr type is an unsigned integer large enough to hold a pointer
000898  */
000899  #if defined(HAVE_STDINT_H)
000900    typedef uintptr_t uptr;
000901  #elif SQLITE_PTRSIZE==4
000902    typedef u32 uptr;
000903  #else
000904    typedef u64 uptr;
000905  #endif
000906  
000907  /*
000908  ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
000909  ** something between S (inclusive) and E (exclusive).
000910  **
000911  ** In other words, S is a buffer and E is a pointer to the first byte after
000912  ** the end of buffer S.  This macro returns true if P points to something
000913  ** contained within the buffer S.
000914  */
000915  #define SQLITE_WITHIN(P,S,E)   (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
000916  
000917  /*
000918  ** P is one byte past the end of a large buffer. Return true if a span of bytes
000919  ** between S..E crosses the end of that buffer.  In other words, return true
000920  ** if the sub-buffer S..E-1 overflows the buffer whose last byte is P-1.
000921  **
000922  ** S is the start of the span.  E is one byte past the end of end of span.
000923  **
000924  **                        P
000925  **     |-----------------|                FALSE
000926  **               |-------|
000927  **               S        E
000928  **
000929  **                        P
000930  **     |-----------------|
000931  **                    |-------|           TRUE
000932  **                    S        E
000933  **
000934  **                        P
000935  **     |-----------------|               
000936  **                        |-------|       FALSE
000937  **                        S        E
000938  */
000939  #define SQLITE_OVERFLOW(P,S,E) (((uptr)(S)<(uptr)(P))&&((uptr)(E)>(uptr)(P)))
000940  
000941  /*
000942  ** Macros to determine whether the machine is big or little endian,
000943  ** and whether or not that determination is run-time or compile-time.
000944  **
000945  ** For best performance, an attempt is made to guess at the byte-order
000946  ** using C-preprocessor macros.  If that is unsuccessful, or if
000947  ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
000948  ** at run-time.
000949  **
000950  ** If you are building SQLite on some obscure platform for which the
000951  ** following ifdef magic does not work, you can always include either:
000952  **
000953  **    -DSQLITE_BYTEORDER=1234
000954  **
000955  ** or
000956  **
000957  **    -DSQLITE_BYTEORDER=4321
000958  **
000959  ** to cause the build to work for little-endian or big-endian processors,
000960  ** respectively.
000961  */
000962  #ifndef SQLITE_BYTEORDER  /* Replicate changes at tag-20230904a */
000963  # if defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
000964  #   define SQLITE_BYTEORDER 4321
000965  # elif defined(__BYTE_ORDER__) && __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
000966  #   define SQLITE_BYTEORDER 1234
000967  # elif defined(__BIG_ENDIAN__) && __BIG_ENDIAN__==1
000968  #   define SQLITE_BYTEORDER 4321
000969  # elif defined(i386)    || defined(__i386__)      || defined(_M_IX86) ||    \
000970       defined(__x86_64)  || defined(__x86_64__)    || defined(_M_X64)  ||    \
000971       defined(_M_AMD64)  || defined(_M_ARM)        || defined(__x86)   ||    \
000972       defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64)
000973  #   define SQLITE_BYTEORDER 1234
000974  # elif defined(sparc)   || defined(__ARMEB__)     || defined(__AARCH64EB__)
000975  #   define SQLITE_BYTEORDER 4321
000976  # else
000977  #   define SQLITE_BYTEORDER 0
000978  # endif
000979  #endif
000980  #if SQLITE_BYTEORDER==4321
000981  # define SQLITE_BIGENDIAN    1
000982  # define SQLITE_LITTLEENDIAN 0
000983  # define SQLITE_UTF16NATIVE  SQLITE_UTF16BE
000984  #elif SQLITE_BYTEORDER==1234
000985  # define SQLITE_BIGENDIAN    0
000986  # define SQLITE_LITTLEENDIAN 1
000987  # define SQLITE_UTF16NATIVE  SQLITE_UTF16LE
000988  #else
000989  # ifdef SQLITE_AMALGAMATION
000990    const int sqlite3one = 1;
000991  # else
000992    extern const int sqlite3one;
000993  # endif
000994  # define SQLITE_BIGENDIAN    (*(char *)(&sqlite3one)==0)
000995  # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
000996  # define SQLITE_UTF16NATIVE  (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
000997  #endif
000998  
000999  /*
001000  ** Constants for the largest and smallest possible 64-bit signed integers.
001001  ** These macros are designed to work correctly on both 32-bit and 64-bit
001002  ** compilers.
001003  */
001004  #define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
001005  #define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32))
001006  #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
001007  
001008  /*
001009  ** Round up a number to the next larger multiple of 8.  This is used
001010  ** to force 8-byte alignment on 64-bit architectures.
001011  **
001012  ** ROUND8() always does the rounding, for any argument.
001013  **
001014  ** ROUND8P() assumes that the argument is already an integer number of
001015  ** pointers in size, and so it is a no-op on systems where the pointer
001016  ** size is 8.
001017  */
001018  #define ROUND8(x)     (((x)+7)&~7)
001019  #if SQLITE_PTRSIZE==8
001020  # define ROUND8P(x)   (x)
001021  #else
001022  # define ROUND8P(x)   (((x)+7)&~7)
001023  #endif
001024  
001025  /*
001026  ** Round down to the nearest multiple of 8
001027  */
001028  #define ROUNDDOWN8(x) ((x)&~7)
001029  
001030  /*
001031  ** Assert that the pointer X is aligned to an 8-byte boundary.  This
001032  ** macro is used only within assert() to verify that the code gets
001033  ** all alignment restrictions correct.
001034  **
001035  ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
001036  ** underlying malloc() implementation might return us 4-byte aligned
001037  ** pointers.  In that case, only verify 4-byte alignment.
001038  */
001039  #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
001040  # define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&3)==0)
001041  #else
001042  # define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&7)==0)
001043  #endif
001044  
001045  /*
001046  ** Disable MMAP on platforms where it is known to not work
001047  */
001048  #if defined(__OpenBSD__) || defined(__QNXNTO__)
001049  # undef SQLITE_MAX_MMAP_SIZE
001050  # define SQLITE_MAX_MMAP_SIZE 0
001051  #endif
001052  
001053  /*
001054  ** Default maximum size of memory used by memory-mapped I/O in the VFS
001055  */
001056  #ifdef __APPLE__
001057  # include <TargetConditionals.h>
001058  #endif
001059  #ifndef SQLITE_MAX_MMAP_SIZE
001060  # if defined(__linux__) \
001061    || defined(_WIN32) \
001062    || (defined(__APPLE__) && defined(__MACH__)) \
001063    || defined(__sun) \
001064    || defined(__FreeBSD__) \
001065    || defined(__DragonFly__)
001066  #   define SQLITE_MAX_MMAP_SIZE 0x7fff0000  /* 2147418112 */
001067  # else
001068  #   define SQLITE_MAX_MMAP_SIZE 0
001069  # endif
001070  #endif
001071  
001072  /*
001073  ** The default MMAP_SIZE is zero on all platforms.  Or, even if a larger
001074  ** default MMAP_SIZE is specified at compile-time, make sure that it does
001075  ** not exceed the maximum mmap size.
001076  */
001077  #ifndef SQLITE_DEFAULT_MMAP_SIZE
001078  # define SQLITE_DEFAULT_MMAP_SIZE 0
001079  #endif
001080  #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
001081  # undef SQLITE_DEFAULT_MMAP_SIZE
001082  # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
001083  #endif
001084  
001085  /*
001086  ** TREETRACE_ENABLED will be either 1 or 0 depending on whether or not
001087  ** the Abstract Syntax Tree tracing logic is turned on.
001088  */
001089  #if !defined(SQLITE_AMALGAMATION)
001090  extern u32 sqlite3TreeTrace;
001091  #endif
001092  #if defined(SQLITE_DEBUG) \
001093      && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE) \
001094                               || defined(SQLITE_ENABLE_TREETRACE))
001095  # define TREETRACE_ENABLED 1
001096  # define TREETRACE(K,P,S,X)  \
001097    if(sqlite3TreeTrace&(K))   \
001098      sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
001099      sqlite3DebugPrintf X
001100  #else
001101  # define TREETRACE(K,P,S,X)
001102  # define TREETRACE_ENABLED 0
001103  #endif
001104  
001105  /* TREETRACE flag meanings:
001106  **
001107  **   0x00000001     Beginning and end of SELECT processing
001108  **   0x00000002     WHERE clause processing
001109  **   0x00000004     Query flattener
001110  **   0x00000008     Result-set wildcard expansion
001111  **   0x00000010     Query name resolution
001112  **   0x00000020     Aggregate analysis
001113  **   0x00000040     Window functions
001114  **   0x00000080     Generated column names
001115  **   0x00000100     Move HAVING terms into WHERE
001116  **   0x00000200     Count-of-view optimization
001117  **   0x00000400     Compound SELECT processing
001118  **   0x00000800     Drop superfluous ORDER BY
001119  **   0x00001000     LEFT JOIN simplifies to JOIN
001120  **   0x00002000     Constant propagation
001121  **   0x00004000     Push-down optimization
001122  **   0x00008000     After all FROM-clause analysis
001123  **   0x00010000     Beginning of DELETE/INSERT/UPDATE processing
001124  **   0x00020000     Transform DISTINCT into GROUP BY
001125  **   0x00040000     SELECT tree dump after all code has been generated
001126  **   0x00080000     NOT NULL strength reduction
001127  */
001128  
001129  /*
001130  ** Macros for "wheretrace"
001131  */
001132  extern u32 sqlite3WhereTrace;
001133  #if defined(SQLITE_DEBUG) \
001134      && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE))
001135  # define WHERETRACE(K,X)  if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X
001136  # define WHERETRACE_ENABLED 1
001137  #else
001138  # define WHERETRACE(K,X)
001139  #endif
001140  
001141  /*
001142  ** Bits for the sqlite3WhereTrace mask:
001143  **
001144  ** (---any--)   Top-level block structure
001145  ** 0x-------F   High-level debug messages
001146  ** 0x----FFF-   More detail
001147  ** 0xFFFF----   Low-level debug messages
001148  **
001149  ** 0x00000001   Code generation
001150  ** 0x00000002   Solver
001151  ** 0x00000004   Solver costs
001152  ** 0x00000008   WhereLoop inserts
001153  **
001154  ** 0x00000010   Display sqlite3_index_info xBestIndex calls
001155  ** 0x00000020   Range an equality scan metrics
001156  ** 0x00000040   IN operator decisions
001157  ** 0x00000080   WhereLoop cost adjustements
001158  ** 0x00000100
001159  ** 0x00000200   Covering index decisions
001160  ** 0x00000400   OR optimization
001161  ** 0x00000800   Index scanner
001162  ** 0x00001000   More details associated with code generation
001163  ** 0x00002000
001164  ** 0x00004000   Show all WHERE terms at key points
001165  ** 0x00008000   Show the full SELECT statement at key places
001166  **
001167  ** 0x00010000   Show more detail when printing WHERE terms
001168  ** 0x00020000   Show WHERE terms returned from whereScanNext()
001169  */
001170  
001171  
001172  /*
001173  ** An instance of the following structure is used to store the busy-handler
001174  ** callback for a given sqlite handle.
001175  **
001176  ** The sqlite.busyHandler member of the sqlite struct contains the busy
001177  ** callback for the database handle. Each pager opened via the sqlite
001178  ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
001179  ** callback is currently invoked only from within pager.c.
001180  */
001181  typedef struct BusyHandler BusyHandler;
001182  struct BusyHandler {
001183    int (*xBusyHandler)(void *,int);  /* The busy callback */
001184    void *pBusyArg;                   /* First arg to busy callback */
001185    int nBusy;                        /* Incremented with each busy call */
001186  };
001187  
001188  /*
001189  ** Name of table that holds the database schema.
001190  **
001191  ** The PREFERRED names are used wherever possible.  But LEGACY is also
001192  ** used for backwards compatibility.
001193  **
001194  **  1.  Queries can use either the PREFERRED or the LEGACY names
001195  **  2.  The sqlite3_set_authorizer() callback uses the LEGACY name
001196  **  3.  The PRAGMA table_list statement uses the PREFERRED name
001197  **
001198  ** The LEGACY names are stored in the internal symbol hash table
001199  ** in support of (2).  Names are translated using sqlite3PreferredTableName()
001200  ** for (3).  The sqlite3FindTable() function takes care of translating
001201  ** names for (1).
001202  **
001203  ** Note that "sqlite_temp_schema" can also be called "temp.sqlite_schema".
001204  */
001205  #define LEGACY_SCHEMA_TABLE          "sqlite_master"
001206  #define LEGACY_TEMP_SCHEMA_TABLE     "sqlite_temp_master"
001207  #define PREFERRED_SCHEMA_TABLE       "sqlite_schema"
001208  #define PREFERRED_TEMP_SCHEMA_TABLE  "sqlite_temp_schema"
001209  
001210  
001211  /*
001212  ** The root-page of the schema table.
001213  */
001214  #define SCHEMA_ROOT    1
001215  
001216  /*
001217  ** The name of the schema table.  The name is different for TEMP.
001218  */
001219  #define SCHEMA_TABLE(x) \
001220      ((!OMIT_TEMPDB)&&(x==1)?LEGACY_TEMP_SCHEMA_TABLE:LEGACY_SCHEMA_TABLE)
001221  
001222  /*
001223  ** A convenience macro that returns the number of elements in
001224  ** an array.
001225  */
001226  #define ArraySize(X)    ((int)(sizeof(X)/sizeof(X[0])))
001227  
001228  /*
001229  ** Determine if the argument is a power of two
001230  */
001231  #define IsPowerOfTwo(X) (((X)&((X)-1))==0)
001232  
001233  /*
001234  ** The following value as a destructor means to use sqlite3DbFree().
001235  ** The sqlite3DbFree() routine requires two parameters instead of the
001236  ** one parameter that destructors normally want.  So we have to introduce
001237  ** this magic value that the code knows to handle differently.  Any
001238  ** pointer will work here as long as it is distinct from SQLITE_STATIC
001239  ** and SQLITE_TRANSIENT.
001240  */
001241  #define SQLITE_DYNAMIC   ((sqlite3_destructor_type)sqlite3OomClear)
001242  
001243  /*
001244  ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
001245  ** not support Writable Static Data (WSD) such as global and static variables.
001246  ** All variables must either be on the stack or dynamically allocated from
001247  ** the heap.  When WSD is unsupported, the variable declarations scattered
001248  ** throughout the SQLite code must become constants instead.  The SQLITE_WSD
001249  ** macro is used for this purpose.  And instead of referencing the variable
001250  ** directly, we use its constant as a key to lookup the run-time allocated
001251  ** buffer that holds real variable.  The constant is also the initializer
001252  ** for the run-time allocated buffer.
001253  **
001254  ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
001255  ** macros become no-ops and have zero performance impact.
001256  */
001257  #ifdef SQLITE_OMIT_WSD
001258    #define SQLITE_WSD const
001259    #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
001260    #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
001261    int sqlite3_wsd_init(int N, int J);
001262    void *sqlite3_wsd_find(void *K, int L);
001263  #else
001264    #define SQLITE_WSD
001265    #define GLOBAL(t,v) v
001266    #define sqlite3GlobalConfig sqlite3Config
001267  #endif
001268  
001269  /*
001270  ** The following macros are used to suppress compiler warnings and to
001271  ** make it clear to human readers when a function parameter is deliberately
001272  ** left unused within the body of a function. This usually happens when
001273  ** a function is called via a function pointer. For example the
001274  ** implementation of an SQL aggregate step callback may not use the
001275  ** parameter indicating the number of arguments passed to the aggregate,
001276  ** if it knows that this is enforced elsewhere.
001277  **
001278  ** When a function parameter is not used at all within the body of a function,
001279  ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
001280  ** However, these macros may also be used to suppress warnings related to
001281  ** parameters that may or may not be used depending on compilation options.
001282  ** For example those parameters only used in assert() statements. In these
001283  ** cases the parameters are named as per the usual conventions.
001284  */
001285  #define UNUSED_PARAMETER(x) (void)(x)
001286  #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
001287  
001288  /*
001289  ** Forward references to structures
001290  */
001291  typedef struct AggInfo AggInfo;
001292  typedef struct AuthContext AuthContext;
001293  typedef struct AutoincInfo AutoincInfo;
001294  typedef struct Bitvec Bitvec;
001295  typedef struct CollSeq CollSeq;
001296  typedef struct Column Column;
001297  typedef struct Cte Cte;
001298  typedef struct CteUse CteUse;
001299  typedef struct Db Db;
001300  typedef struct DbClientData DbClientData;
001301  typedef struct DbFixer DbFixer;
001302  typedef struct Schema Schema;
001303  typedef struct Expr Expr;
001304  typedef struct ExprList ExprList;
001305  typedef struct FKey FKey;
001306  typedef struct FpDecode FpDecode;
001307  typedef struct FuncDestructor FuncDestructor;
001308  typedef struct FuncDef FuncDef;
001309  typedef struct FuncDefHash FuncDefHash;
001310  typedef struct IdList IdList;
001311  typedef struct Index Index;
001312  typedef struct IndexedExpr IndexedExpr;
001313  typedef struct IndexSample IndexSample;
001314  typedef struct KeyClass KeyClass;
001315  typedef struct KeyInfo KeyInfo;
001316  typedef struct Lookaside Lookaside;
001317  typedef struct LookasideSlot LookasideSlot;
001318  typedef struct Module Module;
001319  typedef struct NameContext NameContext;
001320  typedef struct OnOrUsing OnOrUsing;
001321  typedef struct Parse Parse;
001322  typedef struct ParseCleanup ParseCleanup;
001323  typedef struct PreUpdate PreUpdate;
001324  typedef struct PrintfArguments PrintfArguments;
001325  typedef struct RCStr RCStr;
001326  typedef struct RenameToken RenameToken;
001327  typedef struct Returning Returning;
001328  typedef struct RowSet RowSet;
001329  typedef struct Savepoint Savepoint;
001330  typedef struct Select Select;
001331  typedef struct SQLiteThread SQLiteThread;
001332  typedef struct SelectDest SelectDest;
001333  typedef struct SrcItem SrcItem;
001334  typedef struct SrcList SrcList;
001335  typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */
001336  typedef struct Table Table;
001337  typedef struct TableLock TableLock;
001338  typedef struct Token Token;
001339  typedef struct TreeView TreeView;
001340  typedef struct Trigger Trigger;
001341  typedef struct TriggerPrg TriggerPrg;
001342  typedef struct TriggerStep TriggerStep;
001343  typedef struct UnpackedRecord UnpackedRecord;
001344  typedef struct Upsert Upsert;
001345  typedef struct VTable VTable;
001346  typedef struct VtabCtx VtabCtx;
001347  typedef struct Walker Walker;
001348  typedef struct WhereInfo WhereInfo;
001349  typedef struct Window Window;
001350  typedef struct With With;
001351  
001352  
001353  /*
001354  ** The bitmask datatype defined below is used for various optimizations.
001355  **
001356  ** Changing this from a 64-bit to a 32-bit type limits the number of
001357  ** tables in a join to 32 instead of 64.  But it also reduces the size
001358  ** of the library by 738 bytes on ix86.
001359  */
001360  #ifdef SQLITE_BITMASK_TYPE
001361    typedef SQLITE_BITMASK_TYPE Bitmask;
001362  #else
001363    typedef u64 Bitmask;
001364  #endif
001365  
001366  /*
001367  ** The number of bits in a Bitmask.  "BMS" means "BitMask Size".
001368  */
001369  #define BMS  ((int)(sizeof(Bitmask)*8))
001370  
001371  /*
001372  ** A bit in a Bitmask
001373  */
001374  #define MASKBIT(n)    (((Bitmask)1)<<(n))
001375  #define MASKBIT64(n)  (((u64)1)<<(n))
001376  #define MASKBIT32(n)  (((unsigned int)1)<<(n))
001377  #define SMASKBIT32(n) ((n)<=31?((unsigned int)1)<<(n):0)
001378  #define ALLBITS       ((Bitmask)-1)
001379  #define TOPBIT        (((Bitmask)1)<<(BMS-1))
001380  
001381  /* A VList object records a mapping between parameters/variables/wildcards
001382  ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
001383  ** variable number associated with that parameter.  See the format description
001384  ** on the sqlite3VListAdd() routine for more information.  A VList is really
001385  ** just an array of integers.
001386  */
001387  typedef int VList;
001388  
001389  /*
001390  ** Defer sourcing vdbe.h and btree.h until after the "u8" and
001391  ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
001392  ** pointer types (i.e. FuncDef) defined above.
001393  */
001394  #include "os.h"
001395  #include "pager.h"
001396  #include "btree.h"
001397  #include "vdbe.h"
001398  #include "pcache.h"
001399  #include "mutex.h"
001400  
001401  /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
001402  ** synchronous setting to EXTRA.  It is no longer supported.
001403  */
001404  #ifdef SQLITE_EXTRA_DURABLE
001405  # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
001406  # define SQLITE_DEFAULT_SYNCHRONOUS 3
001407  #endif
001408  
001409  /*
001410  ** Default synchronous levels.
001411  **
001412  ** Note that (for historical reasons) the PAGER_SYNCHRONOUS_* macros differ
001413  ** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
001414  **
001415  **           PAGER_SYNCHRONOUS       DEFAULT_SYNCHRONOUS
001416  **   OFF           1                         0
001417  **   NORMAL        2                         1
001418  **   FULL          3                         2
001419  **   EXTRA         4                         3
001420  **
001421  ** The "PRAGMA synchronous" statement also uses the zero-based numbers.
001422  ** In other words, the zero-based numbers are used for all external interfaces
001423  ** and the one-based values are used internally.
001424  */
001425  #ifndef SQLITE_DEFAULT_SYNCHRONOUS
001426  # define SQLITE_DEFAULT_SYNCHRONOUS 2
001427  #endif
001428  #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
001429  # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
001430  #endif
001431  
001432  /*
001433  ** Each database file to be accessed by the system is an instance
001434  ** of the following structure.  There are normally two of these structures
001435  ** in the sqlite.aDb[] array.  aDb[0] is the main database file and
001436  ** aDb[1] is the database file used to hold temporary tables.  Additional
001437  ** databases may be attached.
001438  */
001439  struct Db {
001440    char *zDbSName;      /* Name of this database. (schema name, not filename) */
001441    Btree *pBt;          /* The B*Tree structure for this database file */
001442    u8 safety_level;     /* How aggressive at syncing data to disk */
001443    u8 bSyncSet;         /* True if "PRAGMA synchronous=N" has been run */
001444    Schema *pSchema;     /* Pointer to database schema (possibly shared) */
001445  };
001446  
001447  /*
001448  ** An instance of the following structure stores a database schema.
001449  **
001450  ** Most Schema objects are associated with a Btree.  The exception is
001451  ** the Schema for the TEMP database (sqlite3.aDb[1]) which is free-standing.
001452  ** In shared cache mode, a single Schema object can be shared by multiple
001453  ** Btrees that refer to the same underlying BtShared object.
001454  **
001455  ** Schema objects are automatically deallocated when the last Btree that
001456  ** references them is destroyed.   The TEMP Schema is manually freed by
001457  ** sqlite3_close().
001458  *
001459  ** A thread must be holding a mutex on the corresponding Btree in order
001460  ** to access Schema content.  This implies that the thread must also be
001461  ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
001462  ** For a TEMP Schema, only the connection mutex is required.
001463  */
001464  struct Schema {
001465    int schema_cookie;   /* Database schema version number for this file */
001466    int iGeneration;     /* Generation counter.  Incremented with each change */
001467    Hash tblHash;        /* All tables indexed by name */
001468    Hash idxHash;        /* All (named) indices indexed by name */
001469    Hash trigHash;       /* All triggers indexed by name */
001470    Hash fkeyHash;       /* All foreign keys by referenced table name */
001471    Table *pSeqTab;      /* The sqlite_sequence table used by AUTOINCREMENT */
001472    u8 file_format;      /* Schema format version for this file */
001473    u8 enc;              /* Text encoding used by this database */
001474    u16 schemaFlags;     /* Flags associated with this schema */
001475    int cache_size;      /* Number of pages to use in the cache */
001476  };
001477  
001478  /*
001479  ** These macros can be used to test, set, or clear bits in the
001480  ** Db.pSchema->flags field.
001481  */
001482  #define DbHasProperty(D,I,P)     (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
001483  #define DbHasAnyProperty(D,I,P)  (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
001484  #define DbSetProperty(D,I,P)     (D)->aDb[I].pSchema->schemaFlags|=(P)
001485  #define DbClearProperty(D,I,P)   (D)->aDb[I].pSchema->schemaFlags&=~(P)
001486  
001487  /*
001488  ** Allowed values for the DB.pSchema->flags field.
001489  **
001490  ** The DB_SchemaLoaded flag is set after the database schema has been
001491  ** read into internal hash tables.
001492  **
001493  ** DB_UnresetViews means that one or more views have column names that
001494  ** have been filled out.  If the schema changes, these column names might
001495  ** changes and so the view will need to be reset.
001496  */
001497  #define DB_SchemaLoaded    0x0001  /* The schema has been loaded */
001498  #define DB_UnresetViews    0x0002  /* Some views have defined column names */
001499  #define DB_ResetWanted     0x0008  /* Reset the schema when nSchemaLock==0 */
001500  
001501  /*
001502  ** The number of different kinds of things that can be limited
001503  ** using the sqlite3_limit() interface.
001504  */
001505  #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
001506  
001507  /*
001508  ** Lookaside malloc is a set of fixed-size buffers that can be used
001509  ** to satisfy small transient memory allocation requests for objects
001510  ** associated with a particular database connection.  The use of
001511  ** lookaside malloc provides a significant performance enhancement
001512  ** (approx 10%) by avoiding numerous malloc/free requests while parsing
001513  ** SQL statements.
001514  **
001515  ** The Lookaside structure holds configuration information about the
001516  ** lookaside malloc subsystem.  Each available memory allocation in
001517  ** the lookaside subsystem is stored on a linked list of LookasideSlot
001518  ** objects.
001519  **
001520  ** Lookaside allocations are only allowed for objects that are associated
001521  ** with a particular database connection.  Hence, schema information cannot
001522  ** be stored in lookaside because in shared cache mode the schema information
001523  ** is shared by multiple database connections.  Therefore, while parsing
001524  ** schema information, the Lookaside.bEnabled flag is cleared so that
001525  ** lookaside allocations are not used to construct the schema objects.
001526  **
001527  ** New lookaside allocations are only allowed if bDisable==0.  When
001528  ** bDisable is greater than zero, sz is set to zero which effectively
001529  ** disables lookaside without adding a new test for the bDisable flag
001530  ** in a performance-critical path.  sz should be set by to szTrue whenever
001531  ** bDisable changes back to zero.
001532  **
001533  ** Lookaside buffers are initially held on the pInit list.  As they are
001534  ** used and freed, they are added back to the pFree list.  New allocations
001535  ** come off of pFree first, then pInit as a fallback.  This dual-list
001536  ** allows use to compute a high-water mark - the maximum number of allocations
001537  ** outstanding at any point in the past - by subtracting the number of
001538  ** allocations on the pInit list from the total number of allocations.
001539  **
001540  ** Enhancement on 2019-12-12:  Two-size-lookaside
001541  ** The default lookaside configuration is 100 slots of 1200 bytes each.
001542  ** The larger slot sizes are important for performance, but they waste
001543  ** a lot of space, as most lookaside allocations are less than 128 bytes.
001544  ** The two-size-lookaside enhancement breaks up the lookaside allocation
001545  ** into two pools:  One of 128-byte slots and the other of the default size
001546  ** (1200-byte) slots.   Allocations are filled from the small-pool first,
001547  ** failing over to the full-size pool if that does not work.  Thus more
001548  ** lookaside slots are available while also using less memory.
001549  ** This enhancement can be omitted by compiling with
001550  ** SQLITE_OMIT_TWOSIZE_LOOKASIDE.
001551  */
001552  struct Lookaside {
001553    u32 bDisable;           /* Only operate the lookaside when zero */
001554    u16 sz;                 /* Size of each buffer in bytes */
001555    u16 szTrue;             /* True value of sz, even if disabled */
001556    u8 bMalloced;           /* True if pStart obtained from sqlite3_malloc() */
001557    u32 nSlot;              /* Number of lookaside slots allocated */
001558    u32 anStat[3];          /* 0: hits.  1: size misses.  2: full misses */
001559    LookasideSlot *pInit;   /* List of buffers not previously used */
001560    LookasideSlot *pFree;   /* List of available buffers */
001561  #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
001562    LookasideSlot *pSmallInit; /* List of small buffers not previously used */
001563    LookasideSlot *pSmallFree; /* List of available small buffers */
001564    void *pMiddle;          /* First byte past end of full-size buffers and
001565                            ** the first byte of LOOKASIDE_SMALL buffers */
001566  #endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
001567    void *pStart;           /* First byte of available memory space */
001568    void *pEnd;             /* First byte past end of available space */
001569    void *pTrueEnd;         /* True value of pEnd, when db->pnBytesFreed!=0 */
001570  };
001571  struct LookasideSlot {
001572    LookasideSlot *pNext;    /* Next buffer in the list of free buffers */
001573  };
001574  
001575  #define DisableLookaside  db->lookaside.bDisable++;db->lookaside.sz=0
001576  #define EnableLookaside   db->lookaside.bDisable--;\
001577     db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue
001578  
001579  /* Size of the smaller allocations in two-size lookaside */
001580  #ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE
001581  #  define LOOKASIDE_SMALL           0
001582  #else
001583  #  define LOOKASIDE_SMALL         128
001584  #endif
001585  
001586  /*
001587  ** A hash table for built-in function definitions.  (Application-defined
001588  ** functions use a regular table table from hash.h.)
001589  **
001590  ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
001591  ** Collisions are on the FuncDef.u.pHash chain.  Use the SQLITE_FUNC_HASH()
001592  ** macro to compute a hash on the function name.
001593  */
001594  #define SQLITE_FUNC_HASH_SZ 23
001595  struct FuncDefHash {
001596    FuncDef *a[SQLITE_FUNC_HASH_SZ];       /* Hash table for functions */
001597  };
001598  #define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ)
001599  
001600  #ifdef SQLITE_USER_AUTHENTICATION
001601  /*
001602  ** Information held in the "sqlite3" database connection object and used
001603  ** to manage user authentication.
001604  */
001605  typedef struct sqlite3_userauth sqlite3_userauth;
001606  struct sqlite3_userauth {
001607    u8 authLevel;                 /* Current authentication level */
001608    int nAuthPW;                  /* Size of the zAuthPW in bytes */
001609    char *zAuthPW;                /* Password used to authenticate */
001610    char *zAuthUser;              /* User name used to authenticate */
001611  };
001612  
001613  /* Allowed values for sqlite3_userauth.authLevel */
001614  #define UAUTH_Unknown     0     /* Authentication not yet checked */
001615  #define UAUTH_Fail        1     /* User authentication failed */
001616  #define UAUTH_User        2     /* Authenticated as a normal user */
001617  #define UAUTH_Admin       3     /* Authenticated as an administrator */
001618  
001619  /* Functions used only by user authorization logic */
001620  int sqlite3UserAuthTable(const char*);
001621  int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*);
001622  void sqlite3UserAuthInit(sqlite3*);
001623  void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
001624  
001625  #endif /* SQLITE_USER_AUTHENTICATION */
001626  
001627  /*
001628  ** typedef for the authorization callback function.
001629  */
001630  #ifdef SQLITE_USER_AUTHENTICATION
001631    typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
001632                                 const char*, const char*);
001633  #else
001634    typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
001635                                 const char*);
001636  #endif
001637  
001638  #ifndef SQLITE_OMIT_DEPRECATED
001639  /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
001640  ** in the style of sqlite3_trace()
001641  */
001642  #define SQLITE_TRACE_LEGACY          0x40     /* Use the legacy xTrace */
001643  #define SQLITE_TRACE_XPROFILE        0x80     /* Use the legacy xProfile */
001644  #else
001645  #define SQLITE_TRACE_LEGACY          0
001646  #define SQLITE_TRACE_XPROFILE        0
001647  #endif /* SQLITE_OMIT_DEPRECATED */
001648  #define SQLITE_TRACE_NONLEGACY_MASK  0x0f     /* Normal flags */
001649  
001650  /*
001651  ** Maximum number of sqlite3.aDb[] entries.  This is the number of attached
001652  ** databases plus 2 for "main" and "temp".
001653  */
001654  #define SQLITE_MAX_DB (SQLITE_MAX_ATTACHED+2)
001655  
001656  /*
001657  ** Each database connection is an instance of the following structure.
001658  */
001659  struct sqlite3 {
001660    sqlite3_vfs *pVfs;            /* OS Interface */
001661    struct Vdbe *pVdbe;           /* List of active virtual machines */
001662    CollSeq *pDfltColl;           /* BINARY collseq for the database encoding */
001663    sqlite3_mutex *mutex;         /* Connection mutex */
001664    Db *aDb;                      /* All backends */
001665    int nDb;                      /* Number of backends currently in use */
001666    u32 mDbFlags;                 /* flags recording internal state */
001667    u64 flags;                    /* flags settable by pragmas. See below */
001668    i64 lastRowid;                /* ROWID of most recent insert (see above) */
001669    i64 szMmap;                   /* Default mmap_size setting */
001670    u32 nSchemaLock;              /* Do not reset the schema when non-zero */
001671    unsigned int openFlags;       /* Flags passed to sqlite3_vfs.xOpen() */
001672    int errCode;                  /* Most recent error code (SQLITE_*) */
001673    int errByteOffset;            /* Byte offset of error in SQL statement */
001674    int errMask;                  /* & result codes with this before returning */
001675    int iSysErrno;                /* Errno value from last system error */
001676    u32 dbOptFlags;               /* Flags to enable/disable optimizations */
001677    u8 enc;                       /* Text encoding */
001678    u8 autoCommit;                /* The auto-commit flag. */
001679    u8 temp_store;                /* 1: file 2: memory 0: default */
001680    u8 mallocFailed;              /* True if we have seen a malloc failure */
001681    u8 bBenignMalloc;             /* Do not require OOMs if true */
001682    u8 dfltLockMode;              /* Default locking-mode for attached dbs */
001683    signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
001684    u8 suppressErr;               /* Do not issue error messages if true */
001685    u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */
001686    u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */
001687    u8 mTrace;                    /* zero or more SQLITE_TRACE flags */
001688    u8 noSharedCache;             /* True if no shared-cache backends */
001689    u8 nSqlExec;                  /* Number of pending OP_SqlExec opcodes */
001690    u8 eOpenState;                /* Current condition of the connection */
001691    int nextPagesize;             /* Pagesize after VACUUM if >0 */
001692    i64 nChange;                  /* Value returned by sqlite3_changes() */
001693    i64 nTotalChange;             /* Value returned by sqlite3_total_changes() */
001694    int aLimit[SQLITE_N_LIMIT];   /* Limits */
001695    int nMaxSorterMmap;           /* Maximum size of regions mapped by sorter */
001696    struct sqlite3InitInfo {      /* Information used during initialization */
001697      Pgno newTnum;               /* Rootpage of table being initialized */
001698      u8 iDb;                     /* Which db file is being initialized */
001699      u8 busy;                    /* TRUE if currently initializing */
001700      unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */
001701      unsigned imposterTable : 1; /* Building an imposter table */
001702      unsigned reopenMemdb : 1;   /* ATTACH is really a reopen using MemDB */
001703      const char **azInit;        /* "type", "name", and "tbl_name" columns */
001704    } init;
001705    int nVdbeActive;              /* Number of VDBEs currently running */
001706    int nVdbeRead;                /* Number of active VDBEs that read or write */
001707    int nVdbeWrite;               /* Number of active VDBEs that read and write */
001708    int nVdbeExec;                /* Number of nested calls to VdbeExec() */
001709    int nVDestroy;                /* Number of active OP_VDestroy operations */
001710    int nExtension;               /* Number of loaded extensions */
001711    void **aExtension;            /* Array of shared library handles */
001712    union {
001713      void (*xLegacy)(void*,const char*);   /* mTrace==SQLITE_TRACE_LEGACY */
001714      int (*xV2)(u32,void*,void*,void*);    /* All other mTrace values */
001715    } trace;
001716    void *pTraceArg;                        /* Argument to the trace function */
001717  #ifndef SQLITE_OMIT_DEPRECATED
001718    void (*xProfile)(void*,const char*,u64);  /* Profiling function */
001719    void *pProfileArg;                        /* Argument to profile function */
001720  #endif
001721    void *pCommitArg;                 /* Argument to xCommitCallback() */
001722    int (*xCommitCallback)(void*);    /* Invoked at every commit. */
001723    void *pRollbackArg;               /* Argument to xRollbackCallback() */
001724    void (*xRollbackCallback)(void*); /* Invoked at every commit. */
001725    void *pUpdateArg;
001726    void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
001727    void *pAutovacPagesArg;           /* Client argument to autovac_pages */
001728    void (*xAutovacDestr)(void*);     /* Destructor for pAutovacPAgesArg */
001729    unsigned int (*xAutovacPages)(void*,const char*,u32,u32,u32);
001730    Parse *pParse;                /* Current parse */
001731  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
001732    void *pPreUpdateArg;          /* First argument to xPreUpdateCallback */
001733    void (*xPreUpdateCallback)(   /* Registered using sqlite3_preupdate_hook() */
001734      void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64
001735    );
001736    PreUpdate *pPreUpdate;        /* Context for active pre-update callback */
001737  #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
001738  #ifndef SQLITE_OMIT_WAL
001739    int (*xWalCallback)(void *, sqlite3 *, const char *, int);
001740    void *pWalArg;
001741  #endif
001742    void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
001743    void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
001744    void *pCollNeededArg;
001745    sqlite3_value *pErr;          /* Most recent error message */
001746    union {
001747      volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
001748      double notUsed1;            /* Spacer */
001749    } u1;
001750    Lookaside lookaside;          /* Lookaside malloc configuration */
001751  #ifndef SQLITE_OMIT_AUTHORIZATION
001752    sqlite3_xauth xAuth;          /* Access authorization function */
001753    void *pAuthArg;               /* 1st argument to the access auth function */
001754  #endif
001755  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
001756    int (*xProgress)(void *);     /* The progress callback */
001757    void *pProgressArg;           /* Argument to the progress callback */
001758    unsigned nProgressOps;        /* Number of opcodes for progress callback */
001759  #endif
001760  #ifndef SQLITE_OMIT_VIRTUALTABLE
001761    int nVTrans;                  /* Allocated size of aVTrans */
001762    Hash aModule;                 /* populated by sqlite3_create_module() */
001763    VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */
001764    VTable **aVTrans;             /* Virtual tables with open transactions */
001765    VTable *pDisconnect;          /* Disconnect these in next sqlite3_prepare() */
001766  #endif
001767    Hash aFunc;                   /* Hash table of connection functions */
001768    Hash aCollSeq;                /* All collating sequences */
001769    BusyHandler busyHandler;      /* Busy callback */
001770    Db aDbStatic[2];              /* Static space for the 2 default backends */
001771    Savepoint *pSavepoint;        /* List of active savepoints */
001772    int nAnalysisLimit;           /* Number of index rows to ANALYZE */
001773    int busyTimeout;              /* Busy handler timeout, in msec */
001774    int nSavepoint;               /* Number of non-transaction savepoints */
001775    int nStatement;               /* Number of nested statement-transactions  */
001776    i64 nDeferredCons;            /* Net deferred constraints this transaction. */
001777    i64 nDeferredImmCons;         /* Net deferred immediate constraints */
001778    int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */
001779    DbClientData *pDbData;        /* sqlite3_set_clientdata() content */
001780  #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
001781    /* The following variables are all protected by the STATIC_MAIN
001782    ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
001783    **
001784    ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
001785    ** unlock so that it can proceed.
001786    **
001787    ** When X.pBlockingConnection==Y, that means that something that X tried
001788    ** tried to do recently failed with an SQLITE_LOCKED error due to locks
001789    ** held by Y.
001790    */
001791    sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
001792    sqlite3 *pUnlockConnection;           /* Connection to watch for unlock */
001793    void *pUnlockArg;                     /* Argument to xUnlockNotify */
001794    void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
001795    sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
001796  #endif
001797  #ifdef SQLITE_USER_AUTHENTICATION
001798    sqlite3_userauth auth;        /* User authentication information */
001799  #endif
001800  };
001801  
001802  /*
001803  ** A macro to discover the encoding of a database.
001804  */
001805  #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
001806  #define ENC(db)        ((db)->enc)
001807  
001808  /*
001809  ** A u64 constant where the lower 32 bits are all zeros.  Only the
001810  ** upper 32 bits are included in the argument.  Necessary because some
001811  ** C-compilers still do not accept LL integer literals.
001812  */
001813  #define HI(X)  ((u64)(X)<<32)
001814  
001815  /*
001816  ** Possible values for the sqlite3.flags.
001817  **
001818  ** Value constraints (enforced via assert()):
001819  **      SQLITE_FullFSync     == PAGER_FULLFSYNC
001820  **      SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
001821  **      SQLITE_CacheSpill    == PAGER_CACHE_SPILL
001822  */
001823  #define SQLITE_WriteSchema    0x00000001  /* OK to update SQLITE_SCHEMA */
001824  #define SQLITE_LegacyFileFmt  0x00000002  /* Create new databases in format 1 */
001825  #define SQLITE_FullColNames   0x00000004  /* Show full column names on SELECT */
001826  #define SQLITE_FullFSync      0x00000008  /* Use full fsync on the backend */
001827  #define SQLITE_CkptFullFSync  0x00000010  /* Use full fsync for checkpoint */
001828  #define SQLITE_CacheSpill     0x00000020  /* OK to spill pager cache */
001829  #define SQLITE_ShortColNames  0x00000040  /* Show short columns names */
001830  #define SQLITE_TrustedSchema  0x00000080  /* Allow unsafe functions and
001831                                            ** vtabs in the schema definition */
001832  #define SQLITE_NullCallback   0x00000100  /* Invoke the callback once if the */
001833                                            /*   result set is empty */
001834  #define SQLITE_IgnoreChecks   0x00000200  /* Do not enforce check constraints */
001835  #define SQLITE_StmtScanStatus 0x00000400  /* Enable stmt_scanstats() counters */
001836  #define SQLITE_NoCkptOnClose  0x00000800  /* No checkpoint on close()/DETACH */
001837  #define SQLITE_ReverseOrder   0x00001000  /* Reverse unordered SELECTs */
001838  #define SQLITE_RecTriggers    0x00002000  /* Enable recursive triggers */
001839  #define SQLITE_ForeignKeys    0x00004000  /* Enforce foreign key constraints  */
001840  #define SQLITE_AutoIndex      0x00008000  /* Enable automatic indexes */
001841  #define SQLITE_LoadExtension  0x00010000  /* Enable load_extension */
001842  #define SQLITE_LoadExtFunc    0x00020000  /* Enable load_extension() SQL func */
001843  #define SQLITE_EnableTrigger  0x00040000  /* True to enable triggers */
001844  #define SQLITE_DeferFKs       0x00080000  /* Defer all FK constraints */
001845  #define SQLITE_QueryOnly      0x00100000  /* Disable database changes */
001846  #define SQLITE_CellSizeCk     0x00200000  /* Check btree cell sizes on load */
001847  #define SQLITE_Fts3Tokenizer  0x00400000  /* Enable fts3_tokenizer(2) */
001848  #define SQLITE_EnableQPSG     0x00800000  /* Query Planner Stability Guarantee*/
001849  #define SQLITE_TriggerEQP     0x01000000  /* Show trigger EXPLAIN QUERY PLAN */
001850  #define SQLITE_ResetDatabase  0x02000000  /* Reset the database */
001851  #define SQLITE_LegacyAlter    0x04000000  /* Legacy ALTER TABLE behaviour */
001852  #define SQLITE_NoSchemaError  0x08000000  /* Do not report schema parse errors*/
001853  #define SQLITE_Defensive      0x10000000  /* Input SQL is likely hostile */
001854  #define SQLITE_DqsDDL         0x20000000  /* dbl-quoted strings allowed in DDL*/
001855  #define SQLITE_DqsDML         0x40000000  /* dbl-quoted strings allowed in DML*/
001856  #define SQLITE_EnableView     0x80000000  /* Enable the use of views */
001857  #define SQLITE_CountRows      HI(0x00001) /* Count rows changed by INSERT, */
001858                                            /*   DELETE, or UPDATE and return */
001859                                            /*   the count using a callback. */
001860  #define SQLITE_CorruptRdOnly  HI(0x00002) /* Prohibit writes due to error */
001861  #define SQLITE_ReadUncommit   HI(0x00004) /* READ UNCOMMITTED in shared-cache */
001862  #define SQLITE_FkNoAction     HI(0x00008) /* Treat all FK as NO ACTION */
001863  
001864  /* Flags used only if debugging */
001865  #ifdef SQLITE_DEBUG
001866  #define SQLITE_SqlTrace       HI(0x0100000) /* Debug print SQL as it executes */
001867  #define SQLITE_VdbeListing    HI(0x0200000) /* Debug listings of VDBE progs */
001868  #define SQLITE_VdbeTrace      HI(0x0400000) /* True to trace VDBE execution */
001869  #define SQLITE_VdbeAddopTrace HI(0x0800000) /* Trace sqlite3VdbeAddOp() calls */
001870  #define SQLITE_VdbeEQP        HI(0x1000000) /* Debug EXPLAIN QUERY PLAN */
001871  #define SQLITE_ParserTrace    HI(0x2000000) /* PRAGMA parser_trace=ON */
001872  #endif
001873  
001874  /*
001875  ** Allowed values for sqlite3.mDbFlags
001876  */
001877  #define DBFLAG_SchemaChange   0x0001  /* Uncommitted Hash table changes */
001878  #define DBFLAG_PreferBuiltin  0x0002  /* Preference to built-in funcs */
001879  #define DBFLAG_Vacuum         0x0004  /* Currently in a VACUUM */
001880  #define DBFLAG_VacuumInto     0x0008  /* Currently running VACUUM INTO */
001881  #define DBFLAG_SchemaKnownOk  0x0010  /* Schema is known to be valid */
001882  #define DBFLAG_InternalFunc   0x0020  /* Allow use of internal functions */
001883  #define DBFLAG_EncodingFixed  0x0040  /* No longer possible to change enc. */
001884  
001885  /*
001886  ** Bits of the sqlite3.dbOptFlags field that are used by the
001887  ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
001888  ** selectively disable various optimizations.
001889  */
001890  #define SQLITE_QueryFlattener 0x00000001 /* Query flattening */
001891  #define SQLITE_WindowFunc     0x00000002 /* Use xInverse for window functions */
001892  #define SQLITE_GroupByOrder   0x00000004 /* GROUPBY cover of ORDERBY */
001893  #define SQLITE_FactorOutConst 0x00000008 /* Constant factoring */
001894  #define SQLITE_DistinctOpt    0x00000010 /* DISTINCT using indexes */
001895  #define SQLITE_CoverIdxScan   0x00000020 /* Covering index scans */
001896  #define SQLITE_OrderByIdxJoin 0x00000040 /* ORDER BY of joins via index */
001897  #define SQLITE_Transitive     0x00000080 /* Transitive constraints */
001898  #define SQLITE_OmitNoopJoin   0x00000100 /* Omit unused tables in joins */
001899  #define SQLITE_CountOfView    0x00000200 /* The count-of-view optimization */
001900  #define SQLITE_CursorHints    0x00000400 /* Add OP_CursorHint opcodes */
001901  #define SQLITE_Stat4          0x00000800 /* Use STAT4 data */
001902     /* TH3 expects this value  ^^^^^^^^^^ to be 0x0000800. Don't change it */
001903  #define SQLITE_PushDown       0x00001000 /* The push-down optimization */
001904  #define SQLITE_SimplifyJoin   0x00002000 /* Convert LEFT JOIN to JOIN */
001905  #define SQLITE_SkipScan       0x00004000 /* Skip-scans */
001906  #define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */
001907  #define SQLITE_MinMaxOpt      0x00010000 /* The min/max optimization */
001908  #define SQLITE_SeekScan       0x00020000 /* The OP_SeekScan optimization */
001909  #define SQLITE_OmitOrderBy    0x00040000 /* Omit pointless ORDER BY */
001910     /* TH3 expects this value  ^^^^^^^^^^ to be 0x40000. Coordinate any change */
001911  #define SQLITE_BloomFilter    0x00080000 /* Use a Bloom filter on searches */
001912  #define SQLITE_BloomPulldown  0x00100000 /* Run Bloom filters early */
001913  #define SQLITE_BalancedMerge  0x00200000 /* Balance multi-way merges */
001914  #define SQLITE_ReleaseReg     0x00400000 /* Use OP_ReleaseReg for testing */
001915  #define SQLITE_FlttnUnionAll  0x00800000 /* Disable the UNION ALL flattener */
001916     /* TH3 expects this value  ^^^^^^^^^^ See flatten04.test */
001917  #define SQLITE_IndexedExpr    0x01000000 /* Pull exprs from index when able */
001918  #define SQLITE_Coroutines     0x02000000 /* Co-routines for subqueries */
001919  #define SQLITE_NullUnusedCols 0x04000000 /* NULL unused columns in subqueries */
001920  #define SQLITE_OnePass        0x08000000 /* Single-pass DELETE and UPDATE */
001921  #define SQLITE_AllOpts        0xffffffff /* All optimizations */
001922  
001923  /*
001924  ** Macros for testing whether or not optimizations are enabled or disabled.
001925  */
001926  #define OptimizationDisabled(db, mask)  (((db)->dbOptFlags&(mask))!=0)
001927  #define OptimizationEnabled(db, mask)   (((db)->dbOptFlags&(mask))==0)
001928  
001929  /*
001930  ** Return true if it OK to factor constant expressions into the initialization
001931  ** code. The argument is a Parse object for the code generator.
001932  */
001933  #define ConstFactorOk(P) ((P)->okConstFactor)
001934  
001935  /* Possible values for the sqlite3.eOpenState field.
001936  ** The numbers are randomly selected such that a minimum of three bits must
001937  ** change to convert any number to another or to zero
001938  */
001939  #define SQLITE_STATE_OPEN     0x76  /* Database is open */
001940  #define SQLITE_STATE_CLOSED   0xce  /* Database is closed */
001941  #define SQLITE_STATE_SICK     0xba  /* Error and awaiting close */
001942  #define SQLITE_STATE_BUSY     0x6d  /* Database currently in use */
001943  #define SQLITE_STATE_ERROR    0xd5  /* An SQLITE_MISUSE error occurred */
001944  #define SQLITE_STATE_ZOMBIE   0xa7  /* Close with last statement close */
001945  
001946  /*
001947  ** Each SQL function is defined by an instance of the following
001948  ** structure.  For global built-in functions (ex: substr(), max(), count())
001949  ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
001950  ** For per-connection application-defined functions, a pointer to this
001951  ** structure is held in the db->aHash hash table.
001952  **
001953  ** The u.pHash field is used by the global built-ins.  The u.pDestructor
001954  ** field is used by per-connection app-def functions.
001955  */
001956  struct FuncDef {
001957    i8 nArg;             /* Number of arguments.  -1 means unlimited */
001958    u32 funcFlags;       /* Some combination of SQLITE_FUNC_* */
001959    void *pUserData;     /* User data parameter */
001960    FuncDef *pNext;      /* Next function with same name */
001961    void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
001962    void (*xFinalize)(sqlite3_context*);                  /* Agg finalizer */
001963    void (*xValue)(sqlite3_context*);                     /* Current agg value */
001964    void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */
001965    const char *zName;   /* SQL name of the function. */
001966    union {
001967      FuncDef *pHash;      /* Next with a different name but the same hash */
001968      FuncDestructor *pDestructor;   /* Reference counted destructor function */
001969    } u; /* pHash if SQLITE_FUNC_BUILTIN, pDestructor otherwise */
001970  };
001971  
001972  /*
001973  ** This structure encapsulates a user-function destructor callback (as
001974  ** configured using create_function_v2()) and a reference counter. When
001975  ** create_function_v2() is called to create a function with a destructor,
001976  ** a single object of this type is allocated. FuncDestructor.nRef is set to
001977  ** the number of FuncDef objects created (either 1 or 3, depending on whether
001978  ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
001979  ** member of each of the new FuncDef objects is set to point to the allocated
001980  ** FuncDestructor.
001981  **
001982  ** Thereafter, when one of the FuncDef objects is deleted, the reference
001983  ** count on this object is decremented. When it reaches 0, the destructor
001984  ** is invoked and the FuncDestructor structure freed.
001985  */
001986  struct FuncDestructor {
001987    int nRef;
001988    void (*xDestroy)(void *);
001989    void *pUserData;
001990  };
001991  
001992  /*
001993  ** Possible values for FuncDef.flags.  Note that the _LENGTH and _TYPEOF
001994  ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG.  And
001995  ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC.  There
001996  ** are assert() statements in the code to verify this.
001997  **
001998  ** Value constraints (enforced via assert()):
001999  **     SQLITE_FUNC_MINMAX      ==  NC_MinMaxAgg      == SF_MinMaxAgg
002000  **     SQLITE_FUNC_ANYORDER    ==  NC_OrderAgg       == SF_OrderByReqd
002001  **     SQLITE_FUNC_LENGTH      ==  OPFLAG_LENGTHARG
002002  **     SQLITE_FUNC_TYPEOF      ==  OPFLAG_TYPEOFARG
002003  **     SQLITE_FUNC_BYTELEN     ==  OPFLAG_BYTELENARG
002004  **     SQLITE_FUNC_CONSTANT    ==  SQLITE_DETERMINISTIC from the API
002005  **     SQLITE_FUNC_DIRECT      ==  SQLITE_DIRECTONLY from the API
002006  **     SQLITE_FUNC_UNSAFE      ==  SQLITE_INNOCUOUS  -- opposite meanings!!!
002007  **     SQLITE_FUNC_ENCMASK   depends on SQLITE_UTF* macros in the API
002008  **
002009  ** Note that even though SQLITE_FUNC_UNSAFE and SQLITE_INNOCUOUS have the
002010  ** same bit value, their meanings are inverted.  SQLITE_FUNC_UNSAFE is
002011  ** used internally and if set means that the function has side effects.
002012  ** SQLITE_INNOCUOUS is used by application code and means "not unsafe".
002013  ** See multiple instances of tag-20230109-1.
002014  */
002015  #define SQLITE_FUNC_ENCMASK  0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
002016  #define SQLITE_FUNC_LIKE     0x0004 /* Candidate for the LIKE optimization */
002017  #define SQLITE_FUNC_CASE     0x0008 /* Case-sensitive LIKE-type function */
002018  #define SQLITE_FUNC_EPHEM    0x0010 /* Ephemeral.  Delete with VDBE */
002019  #define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/
002020  #define SQLITE_FUNC_LENGTH   0x0040 /* Built-in length() function */
002021  #define SQLITE_FUNC_TYPEOF   0x0080 /* Built-in typeof() function */
002022  #define SQLITE_FUNC_BYTELEN  0x00c0 /* Built-in octet_length() function */
002023  #define SQLITE_FUNC_COUNT    0x0100 /* Built-in count(*) aggregate */
002024  /*                           0x0200 -- available for reuse */
002025  #define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
002026  #define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
002027  #define SQLITE_FUNC_MINMAX   0x1000 /* True for min() and max() aggregates */
002028  #define SQLITE_FUNC_SLOCHNG  0x2000 /* "Slow Change". Value constant during a
002029                                      ** single query - might change over time */
002030  #define SQLITE_FUNC_TEST     0x4000 /* Built-in testing functions */
002031  #define SQLITE_FUNC_RUNONLY  0x8000 /* Cannot be used by valueFromFunction */
002032  #define SQLITE_FUNC_WINDOW   0x00010000 /* Built-in window-only function */
002033  #define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
002034  #define SQLITE_FUNC_DIRECT   0x00080000 /* Not for use in TRIGGERs or VIEWs */
002035  /* SQLITE_SUBTYPE            0x00100000 // Consumer of subtypes */
002036  #define SQLITE_FUNC_UNSAFE   0x00200000 /* Function has side effects */
002037  #define SQLITE_FUNC_INLINE   0x00400000 /* Functions implemented in-line */
002038  #define SQLITE_FUNC_BUILTIN  0x00800000 /* This is a built-in function */
002039  /*  SQLITE_RESULT_SUBTYPE    0x01000000 // Generator of subtypes */
002040  #define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
002041  
002042  /* Identifier numbers for each in-line function */
002043  #define INLINEFUNC_coalesce             0
002044  #define INLINEFUNC_implies_nonnull_row  1
002045  #define INLINEFUNC_expr_implies_expr    2
002046  #define INLINEFUNC_expr_compare         3
002047  #define INLINEFUNC_affinity             4
002048  #define INLINEFUNC_iif                  5
002049  #define INLINEFUNC_sqlite_offset        6
002050  #define INLINEFUNC_unlikely            99  /* Default case */
002051  
002052  /*
002053  ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
002054  ** used to create the initializers for the FuncDef structures.
002055  **
002056  **   FUNCTION(zName, nArg, iArg, bNC, xFunc)
002057  **     Used to create a scalar function definition of a function zName
002058  **     implemented by C function xFunc that accepts nArg arguments. The
002059  **     value passed as iArg is cast to a (void*) and made available
002060  **     as the user-data (sqlite3_user_data()) for the function. If
002061  **     argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
002062  **
002063  **   VFUNCTION(zName, nArg, iArg, bNC, xFunc)
002064  **     Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
002065  **
002066  **   SFUNCTION(zName, nArg, iArg, bNC, xFunc)
002067  **     Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
002068  **     adds the SQLITE_DIRECTONLY flag.
002069  **
002070  **   INLINE_FUNC(zName, nArg, iFuncId, mFlags)
002071  **     zName is the name of a function that is implemented by in-line
002072  **     byte code rather than by the usual callbacks. The iFuncId
002073  **     parameter determines the function id.  The mFlags parameter is
002074  **     optional SQLITE_FUNC_ flags for this function.
002075  **
002076  **   TEST_FUNC(zName, nArg, iFuncId, mFlags)
002077  **     zName is the name of a test-only function implemented by in-line
002078  **     byte code rather than by the usual callbacks. The iFuncId
002079  **     parameter determines the function id.  The mFlags parameter is
002080  **     optional SQLITE_FUNC_ flags for this function.
002081  **
002082  **   DFUNCTION(zName, nArg, iArg, bNC, xFunc)
002083  **     Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
002084  **     adds the SQLITE_FUNC_SLOCHNG flag.  Used for date & time functions
002085  **     and functions like sqlite_version() that can change, but not during
002086  **     a single query.  The iArg is ignored.  The user-data is always set
002087  **     to a NULL pointer.  The bNC parameter is not used.
002088  **
002089  **   MFUNCTION(zName, nArg, xPtr, xFunc)
002090  **     For math-library functions.  xPtr is an arbitrary pointer.
002091  **
002092  **   PURE_DATE(zName, nArg, iArg, bNC, xFunc)
002093  **     Used for "pure" date/time functions, this macro is like DFUNCTION
002094  **     except that it does set the SQLITE_FUNC_CONSTANT flags.  iArg is
002095  **     ignored and the user-data for these functions is set to an
002096  **     arbitrary non-NULL pointer.  The bNC parameter is not used.
002097  **
002098  **   AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
002099  **     Used to create an aggregate function definition implemented by
002100  **     the C functions xStep and xFinal. The first four parameters
002101  **     are interpreted in the same way as the first 4 parameters to
002102  **     FUNCTION().
002103  **
002104  **   WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse)
002105  **     Used to create an aggregate function definition implemented by
002106  **     the C functions xStep and xFinal. The first four parameters
002107  **     are interpreted in the same way as the first 4 parameters to
002108  **     FUNCTION().
002109  **
002110  **   LIKEFUNC(zName, nArg, pArg, flags)
002111  **     Used to create a scalar function definition of a function zName
002112  **     that accepts nArg arguments and is implemented by a call to C
002113  **     function likeFunc. Argument pArg is cast to a (void *) and made
002114  **     available as the function user-data (sqlite3_user_data()). The
002115  **     FuncDef.flags variable is set to the value passed as the flags
002116  **     parameter.
002117  */
002118  #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
002119    {nArg, SQLITE_FUNC_BUILTIN|\
002120     SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
002121     SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
002122  #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
002123    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
002124     SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
002125  #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
002126    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
002127     SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
002128  #define MFUNCTION(zName, nArg, xPtr, xFunc) \
002129    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \
002130     xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
002131  #define JFUNCTION(zName, nArg, bUseCache, bWS, bRS, bJsonB, iArg, xFunc) \
002132    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|SQLITE_FUNC_CONSTANT|\
002133     SQLITE_UTF8|((bUseCache)*SQLITE_FUNC_RUNONLY)|\
002134     ((bRS)*SQLITE_SUBTYPE)|((bWS)*SQLITE_RESULT_SUBTYPE), \
002135     SQLITE_INT_TO_PTR(iArg|((bJsonB)*JSON_BLOB)),0,xFunc,0, 0, 0, #zName, {0} }
002136  #define INLINE_FUNC(zName, nArg, iArg, mFlags) \
002137    {nArg, SQLITE_FUNC_BUILTIN|\
002138     SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
002139     SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
002140  #define TEST_FUNC(zName, nArg, iArg, mFlags) \
002141    {nArg, SQLITE_FUNC_BUILTIN|\
002142           SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
002143           SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
002144     SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
002145  #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
002146    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
002147     0, 0, xFunc, 0, 0, 0, #zName, {0} }
002148  #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
002149    {nArg, SQLITE_FUNC_BUILTIN|\
002150           SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
002151     (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
002152  #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
002153    {nArg, SQLITE_FUNC_BUILTIN|\
002154     SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
002155     SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
002156  #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
002157    {nArg, SQLITE_FUNC_BUILTIN|\
002158     SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
002159     pArg, 0, xFunc, 0, 0, 0, #zName, }
002160  #define LIKEFUNC(zName, nArg, arg, flags) \
002161    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
002162     (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
002163  #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
002164    {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
002165     SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
002166  #define INTERNAL_FUNCTION(zName, nArg, xFunc) \
002167    {nArg, SQLITE_FUNC_BUILTIN|\
002168     SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
002169     0, 0, xFunc, 0, 0, 0, #zName, {0} }
002170  
002171  
002172  /*
002173  ** All current savepoints are stored in a linked list starting at
002174  ** sqlite3.pSavepoint. The first element in the list is the most recently
002175  ** opened savepoint. Savepoints are added to the list by the vdbe
002176  ** OP_Savepoint instruction.
002177  */
002178  struct Savepoint {
002179    char *zName;                        /* Savepoint name (nul-terminated) */
002180    i64 nDeferredCons;                  /* Number of deferred fk violations */
002181    i64 nDeferredImmCons;               /* Number of deferred imm fk. */
002182    Savepoint *pNext;                   /* Parent savepoint (if any) */
002183  };
002184  
002185  /*
002186  ** The following are used as the second parameter to sqlite3Savepoint(),
002187  ** and as the P1 argument to the OP_Savepoint instruction.
002188  */
002189  #define SAVEPOINT_BEGIN      0
002190  #define SAVEPOINT_RELEASE    1
002191  #define SAVEPOINT_ROLLBACK   2
002192  
002193  
002194  /*
002195  ** Each SQLite module (virtual table definition) is defined by an
002196  ** instance of the following structure, stored in the sqlite3.aModule
002197  ** hash table.
002198  */
002199  struct Module {
002200    const sqlite3_module *pModule;       /* Callback pointers */
002201    const char *zName;                   /* Name passed to create_module() */
002202    int nRefModule;                      /* Number of pointers to this object */
002203    void *pAux;                          /* pAux passed to create_module() */
002204    void (*xDestroy)(void *);            /* Module destructor function */
002205    Table *pEpoTab;                      /* Eponymous table for this module */
002206  };
002207  
002208  /*
002209  ** Information about each column of an SQL table is held in an instance
002210  ** of the Column structure, in the Table.aCol[] array.
002211  **
002212  ** Definitions:
002213  **
002214  **   "table column index"     This is the index of the column in the
002215  **                            Table.aCol[] array, and also the index of
002216  **                            the column in the original CREATE TABLE stmt.
002217  **
002218  **   "storage column index"   This is the index of the column in the
002219  **                            record BLOB generated by the OP_MakeRecord
002220  **                            opcode.  The storage column index is less than
002221  **                            or equal to the table column index.  It is
002222  **                            equal if and only if there are no VIRTUAL
002223  **                            columns to the left.
002224  **
002225  ** Notes on zCnName:
002226  ** The zCnName field stores the name of the column, the datatype of the
002227  ** column, and the collating sequence for the column, in that order, all in
002228  ** a single allocation.  Each string is 0x00 terminated.  The datatype
002229  ** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the
002230  ** collating sequence name is only included if the COLFLAG_HASCOLL bit is
002231  ** set.
002232  */
002233  struct Column {
002234    char *zCnName;        /* Name of this column */
002235    unsigned notNull :4;  /* An OE_ code for handling a NOT NULL constraint */
002236    unsigned eCType :4;   /* One of the standard types */
002237    char affinity;        /* One of the SQLITE_AFF_... values */
002238    u8 szEst;             /* Est size of value in this column. sizeof(INT)==1 */
002239    u8 hName;             /* Column name hash for faster lookup */
002240    u16 iDflt;            /* 1-based index of DEFAULT.  0 means "none" */
002241    u16 colFlags;         /* Boolean properties.  See COLFLAG_ defines below */
002242  };
002243  
002244  /* Allowed values for Column.eCType.
002245  **
002246  ** Values must match entries in the global constant arrays
002247  ** sqlite3StdTypeLen[] and sqlite3StdType[].  Each value is one more
002248  ** than the offset into these arrays for the corresponding name.
002249  ** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
002250  */
002251  #define COLTYPE_CUSTOM      0   /* Type appended to zName */
002252  #define COLTYPE_ANY         1
002253  #define COLTYPE_BLOB        2
002254  #define COLTYPE_INT         3
002255  #define COLTYPE_INTEGER     4
002256  #define COLTYPE_REAL        5
002257  #define COLTYPE_TEXT        6
002258  #define SQLITE_N_STDTYPE    6  /* Number of standard types */
002259  
002260  /* Allowed values for Column.colFlags.
002261  **
002262  ** Constraints:
002263  **         TF_HasVirtual == COLFLAG_VIRTUAL
002264  **         TF_HasStored  == COLFLAG_STORED
002265  **         TF_HasHidden  == COLFLAG_HIDDEN
002266  */
002267  #define COLFLAG_PRIMKEY   0x0001   /* Column is part of the primary key */
002268  #define COLFLAG_HIDDEN    0x0002   /* A hidden column in a virtual table */
002269  #define COLFLAG_HASTYPE   0x0004   /* Type name follows column name */
002270  #define COLFLAG_UNIQUE    0x0008   /* Column def contains "UNIQUE" or "PK" */
002271  #define COLFLAG_SORTERREF 0x0010   /* Use sorter-refs with this column */
002272  #define COLFLAG_VIRTUAL   0x0020   /* GENERATED ALWAYS AS ... VIRTUAL */
002273  #define COLFLAG_STORED    0x0040   /* GENERATED ALWAYS AS ... STORED */
002274  #define COLFLAG_NOTAVAIL  0x0080   /* STORED column not yet calculated */
002275  #define COLFLAG_BUSY      0x0100   /* Blocks recursion on GENERATED columns */
002276  #define COLFLAG_HASCOLL   0x0200   /* Has collating sequence name in zCnName */
002277  #define COLFLAG_NOEXPAND  0x0400   /* Omit this column when expanding "*" */
002278  #define COLFLAG_GENERATED 0x0060   /* Combo: _STORED, _VIRTUAL */
002279  #define COLFLAG_NOINSERT  0x0062   /* Combo: _HIDDEN, _STORED, _VIRTUAL */
002280  
002281  /*
002282  ** A "Collating Sequence" is defined by an instance of the following
002283  ** structure. Conceptually, a collating sequence consists of a name and
002284  ** a comparison routine that defines the order of that sequence.
002285  **
002286  ** If CollSeq.xCmp is NULL, it means that the
002287  ** collating sequence is undefined.  Indices built on an undefined
002288  ** collating sequence may not be read or written.
002289  */
002290  struct CollSeq {
002291    char *zName;          /* Name of the collating sequence, UTF-8 encoded */
002292    u8 enc;               /* Text encoding handled by xCmp() */
002293    void *pUser;          /* First argument to xCmp() */
002294    int (*xCmp)(void*,int, const void*, int, const void*);
002295    void (*xDel)(void*);  /* Destructor for pUser */
002296  };
002297  
002298  /*
002299  ** A sort order can be either ASC or DESC.
002300  */
002301  #define SQLITE_SO_ASC       0  /* Sort in ascending order */
002302  #define SQLITE_SO_DESC      1  /* Sort in ascending order */
002303  #define SQLITE_SO_UNDEFINED -1 /* No sort order specified */
002304  
002305  /*
002306  ** Column affinity types.
002307  **
002308  ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
002309  ** 't' for SQLITE_AFF_TEXT.  But we can save a little space and improve
002310  ** the speed a little by numbering the values consecutively.
002311  **
002312  ** But rather than start with 0 or 1, we begin with 'A'.  That way,
002313  ** when multiple affinity types are concatenated into a string and
002314  ** used as the P4 operand, they will be more readable.
002315  **
002316  ** Note also that the numeric types are grouped together so that testing
002317  ** for a numeric type is a single comparison.  And the BLOB type is first.
002318  */
002319  #define SQLITE_AFF_NONE     0x40  /* '@' */
002320  #define SQLITE_AFF_BLOB     0x41  /* 'A' */
002321  #define SQLITE_AFF_TEXT     0x42  /* 'B' */
002322  #define SQLITE_AFF_NUMERIC  0x43  /* 'C' */
002323  #define SQLITE_AFF_INTEGER  0x44  /* 'D' */
002324  #define SQLITE_AFF_REAL     0x45  /* 'E' */
002325  #define SQLITE_AFF_FLEXNUM  0x46  /* 'F' */
002326  
002327  #define sqlite3IsNumericAffinity(X)  ((X)>=SQLITE_AFF_NUMERIC)
002328  
002329  /*
002330  ** The SQLITE_AFF_MASK values masks off the significant bits of an
002331  ** affinity value.
002332  */
002333  #define SQLITE_AFF_MASK     0x47
002334  
002335  /*
002336  ** Additional bit values that can be ORed with an affinity without
002337  ** changing the affinity.
002338  **
002339  ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
002340  ** It causes an assert() to fire if either operand to a comparison
002341  ** operator is NULL.  It is added to certain comparison operators to
002342  ** prove that the operands are always NOT NULL.
002343  */
002344  #define SQLITE_JUMPIFNULL   0x10  /* jumps if either operand is NULL */
002345  #define SQLITE_NULLEQ       0x80  /* NULL=NULL */
002346  #define SQLITE_NOTNULL      0x90  /* Assert that operands are never NULL */
002347  
002348  /*
002349  ** An object of this type is created for each virtual table present in
002350  ** the database schema.
002351  **
002352  ** If the database schema is shared, then there is one instance of this
002353  ** structure for each database connection (sqlite3*) that uses the shared
002354  ** schema. This is because each database connection requires its own unique
002355  ** instance of the sqlite3_vtab* handle used to access the virtual table
002356  ** implementation. sqlite3_vtab* handles can not be shared between
002357  ** database connections, even when the rest of the in-memory database
002358  ** schema is shared, as the implementation often stores the database
002359  ** connection handle passed to it via the xConnect() or xCreate() method
002360  ** during initialization internally. This database connection handle may
002361  ** then be used by the virtual table implementation to access real tables
002362  ** within the database. So that they appear as part of the callers
002363  ** transaction, these accesses need to be made via the same database
002364  ** connection as that used to execute SQL operations on the virtual table.
002365  **
002366  ** All VTable objects that correspond to a single table in a shared
002367  ** database schema are initially stored in a linked-list pointed to by
002368  ** the Table.pVTable member variable of the corresponding Table object.
002369  ** When an sqlite3_prepare() operation is required to access the virtual
002370  ** table, it searches the list for the VTable that corresponds to the
002371  ** database connection doing the preparing so as to use the correct
002372  ** sqlite3_vtab* handle in the compiled query.
002373  **
002374  ** When an in-memory Table object is deleted (for example when the
002375  ** schema is being reloaded for some reason), the VTable objects are not
002376  ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
002377  ** immediately. Instead, they are moved from the Table.pVTable list to
002378  ** another linked list headed by the sqlite3.pDisconnect member of the
002379  ** corresponding sqlite3 structure. They are then deleted/xDisconnected
002380  ** next time a statement is prepared using said sqlite3*. This is done
002381  ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
002382  ** Refer to comments above function sqlite3VtabUnlockList() for an
002383  ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
002384  ** list without holding the corresponding sqlite3.mutex mutex.
002385  **
002386  ** The memory for objects of this type is always allocated by
002387  ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
002388  ** the first argument.
002389  */
002390  struct VTable {
002391    sqlite3 *db;              /* Database connection associated with this table */
002392    Module *pMod;             /* Pointer to module implementation */
002393    sqlite3_vtab *pVtab;      /* Pointer to vtab instance */
002394    int nRef;                 /* Number of pointers to this structure */
002395    u8 bConstraint;           /* True if constraints are supported */
002396    u8 bAllSchemas;           /* True if might use any attached schema */
002397    u8 eVtabRisk;             /* Riskiness of allowing hacker access */
002398    int iSavepoint;           /* Depth of the SAVEPOINT stack */
002399    VTable *pNext;            /* Next in linked list (see above) */
002400  };
002401  
002402  /* Allowed values for VTable.eVtabRisk
002403  */
002404  #define SQLITE_VTABRISK_Low          0
002405  #define SQLITE_VTABRISK_Normal       1
002406  #define SQLITE_VTABRISK_High         2
002407  
002408  /*
002409  ** The schema for each SQL table, virtual table, and view is represented
002410  ** in memory by an instance of the following structure.
002411  */
002412  struct Table {
002413    char *zName;         /* Name of the table or view */
002414    Column *aCol;        /* Information about each column */
002415    Index *pIndex;       /* List of SQL indexes on this table. */
002416    char *zColAff;       /* String defining the affinity of each column */
002417    ExprList *pCheck;    /* All CHECK constraints */
002418                         /*   ... also used as column name list in a VIEW */
002419    Pgno tnum;           /* Root BTree page for this table */
002420    u32 nTabRef;         /* Number of pointers to this Table */
002421    u32 tabFlags;        /* Mask of TF_* values */
002422    i16 iPKey;           /* If not negative, use aCol[iPKey] as the rowid */
002423    i16 nCol;            /* Number of columns in this table */
002424    i16 nNVCol;          /* Number of columns that are not VIRTUAL */
002425    LogEst nRowLogEst;   /* Estimated rows in table - from sqlite_stat1 table */
002426    LogEst szTabRow;     /* Estimated size of each table row in bytes */
002427  #ifdef SQLITE_ENABLE_COSTMULT
002428    LogEst costMult;     /* Cost multiplier for using this table */
002429  #endif
002430    u8 keyConf;          /* What to do in case of uniqueness conflict on iPKey */
002431    u8 eTabType;         /* 0: normal, 1: virtual, 2: view */
002432    union {
002433      struct {             /* Used by ordinary tables: */
002434        int addColOffset;    /* Offset in CREATE TABLE stmt to add a new column */
002435        FKey *pFKey;         /* Linked list of all foreign keys in this table */
002436        ExprList *pDfltList; /* DEFAULT clauses on various columns.
002437                             ** Or the AS clause for generated columns. */
002438      } tab;
002439      struct {             /* Used by views: */
002440        Select *pSelect;     /* View definition */
002441      } view;
002442      struct {             /* Used by virtual tables only: */
002443        int nArg;            /* Number of arguments to the module */
002444        char **azArg;        /* 0: module 1: schema 2: vtab name 3...: args */
002445        VTable *p;           /* List of VTable objects. */
002446      } vtab;
002447    } u;
002448    Trigger *pTrigger;   /* List of triggers on this object */
002449    Schema *pSchema;     /* Schema that contains this table */
002450  };
002451  
002452  /*
002453  ** Allowed values for Table.tabFlags.
002454  **
002455  ** TF_OOOHidden applies to tables or view that have hidden columns that are
002456  ** followed by non-hidden columns.  Example:  "CREATE VIRTUAL TABLE x USING
002457  ** vtab1(a HIDDEN, b);".  Since "b" is a non-hidden column but "a" is hidden,
002458  ** the TF_OOOHidden attribute would apply in this case.  Such tables require
002459  ** special handling during INSERT processing. The "OOO" means "Out Of Order".
002460  **
002461  ** Constraints:
002462  **
002463  **         TF_HasVirtual == COLFLAG_VIRTUAL
002464  **         TF_HasStored  == COLFLAG_STORED
002465  **         TF_HasHidden  == COLFLAG_HIDDEN
002466  */
002467  #define TF_Readonly       0x00000001 /* Read-only system table */
002468  #define TF_HasHidden      0x00000002 /* Has one or more hidden columns */
002469  #define TF_HasPrimaryKey  0x00000004 /* Table has a primary key */
002470  #define TF_Autoincrement  0x00000008 /* Integer primary key is autoincrement */
002471  #define TF_HasStat1       0x00000010 /* nRowLogEst set from sqlite_stat1 */
002472  #define TF_HasVirtual     0x00000020 /* Has one or more VIRTUAL columns */
002473  #define TF_HasStored      0x00000040 /* Has one or more STORED columns */
002474  #define TF_HasGenerated   0x00000060 /* Combo: HasVirtual + HasStored */
002475  #define TF_WithoutRowid   0x00000080 /* No rowid.  PRIMARY KEY is the key */
002476  #define TF_StatsUsed      0x00000100 /* Query planner decisions affected by
002477                                       ** Index.aiRowLogEst[] values */
002478  #define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */
002479  #define TF_OOOHidden      0x00000400 /* Out-of-Order hidden columns */
002480  #define TF_HasNotNull     0x00000800 /* Contains NOT NULL constraints */
002481  #define TF_Shadow         0x00001000 /* True for a shadow table */
002482  #define TF_HasStat4       0x00002000 /* STAT4 info available for this table */
002483  #define TF_Ephemeral      0x00004000 /* An ephemeral table */
002484  #define TF_Eponymous      0x00008000 /* An eponymous virtual table */
002485  #define TF_Strict         0x00010000 /* STRICT mode */
002486  
002487  /*
002488  ** Allowed values for Table.eTabType
002489  */
002490  #define TABTYP_NORM      0     /* Ordinary table */
002491  #define TABTYP_VTAB      1     /* Virtual table */
002492  #define TABTYP_VIEW      2     /* A view */
002493  
002494  #define IsView(X)           ((X)->eTabType==TABTYP_VIEW)
002495  #define IsOrdinaryTable(X)  ((X)->eTabType==TABTYP_NORM)
002496  
002497  /*
002498  ** Test to see whether or not a table is a virtual table.  This is
002499  ** done as a macro so that it will be optimized out when virtual
002500  ** table support is omitted from the build.
002501  */
002502  #ifndef SQLITE_OMIT_VIRTUALTABLE
002503  #  define IsVirtual(X)      ((X)->eTabType==TABTYP_VTAB)
002504  #  define ExprIsVtab(X)  \
002505     ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB)
002506  #else
002507  #  define IsVirtual(X)      0
002508  #  define ExprIsVtab(X)     0
002509  #endif
002510  
002511  /*
002512  ** Macros to determine if a column is hidden.  IsOrdinaryHiddenColumn()
002513  ** only works for non-virtual tables (ordinary tables and views) and is
002514  ** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined.  The
002515  ** IsHiddenColumn() macro is general purpose.
002516  */
002517  #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS)
002518  #  define IsHiddenColumn(X)         (((X)->colFlags & COLFLAG_HIDDEN)!=0)
002519  #  define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
002520  #elif !defined(SQLITE_OMIT_VIRTUALTABLE)
002521  #  define IsHiddenColumn(X)         (((X)->colFlags & COLFLAG_HIDDEN)!=0)
002522  #  define IsOrdinaryHiddenColumn(X) 0
002523  #else
002524  #  define IsHiddenColumn(X)         0
002525  #  define IsOrdinaryHiddenColumn(X) 0
002526  #endif
002527  
002528  
002529  /* Does the table have a rowid */
002530  #define HasRowid(X)     (((X)->tabFlags & TF_WithoutRowid)==0)
002531  #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0)
002532  
002533  /*
002534  ** Each foreign key constraint is an instance of the following structure.
002535  **
002536  ** A foreign key is associated with two tables.  The "from" table is
002537  ** the table that contains the REFERENCES clause that creates the foreign
002538  ** key.  The "to" table is the table that is named in the REFERENCES clause.
002539  ** Consider this example:
002540  **
002541  **     CREATE TABLE ex1(
002542  **       a INTEGER PRIMARY KEY,
002543  **       b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
002544  **     );
002545  **
002546  ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
002547  ** Equivalent names:
002548  **
002549  **     from-table == child-table
002550  **       to-table == parent-table
002551  **
002552  ** Each REFERENCES clause generates an instance of the following structure
002553  ** which is attached to the from-table.  The to-table need not exist when
002554  ** the from-table is created.  The existence of the to-table is not checked.
002555  **
002556  ** The list of all parents for child Table X is held at X.pFKey.
002557  **
002558  ** A list of all children for a table named Z (which might not even exist)
002559  ** is held in Schema.fkeyHash with a hash key of Z.
002560  */
002561  struct FKey {
002562    Table *pFrom;     /* Table containing the REFERENCES clause (aka: Child) */
002563    FKey *pNextFrom;  /* Next FKey with the same in pFrom. Next parent of pFrom */
002564    char *zTo;        /* Name of table that the key points to (aka: Parent) */
002565    FKey *pNextTo;    /* Next with the same zTo. Next child of zTo. */
002566    FKey *pPrevTo;    /* Previous with the same zTo */
002567    int nCol;         /* Number of columns in this key */
002568    /* EV: R-30323-21917 */
002569    u8 isDeferred;       /* True if constraint checking is deferred till COMMIT */
002570    u8 aAction[2];        /* ON DELETE and ON UPDATE actions, respectively */
002571    Trigger *apTrigger[2];/* Triggers for aAction[] actions */
002572    struct sColMap {      /* Mapping of columns in pFrom to columns in zTo */
002573      int iFrom;            /* Index of column in pFrom */
002574      char *zCol;           /* Name of column in zTo.  If NULL use PRIMARY KEY */
002575    } aCol[1];            /* One entry for each of nCol columns */
002576  };
002577  
002578  /*
002579  ** SQLite supports many different ways to resolve a constraint
002580  ** error.  ROLLBACK processing means that a constraint violation
002581  ** causes the operation in process to fail and for the current transaction
002582  ** to be rolled back.  ABORT processing means the operation in process
002583  ** fails and any prior changes from that one operation are backed out,
002584  ** but the transaction is not rolled back.  FAIL processing means that
002585  ** the operation in progress stops and returns an error code.  But prior
002586  ** changes due to the same operation are not backed out and no rollback
002587  ** occurs.  IGNORE means that the particular row that caused the constraint
002588  ** error is not inserted or updated.  Processing continues and no error
002589  ** is returned.  REPLACE means that preexisting database rows that caused
002590  ** a UNIQUE constraint violation are removed so that the new insert or
002591  ** update can proceed.  Processing continues and no error is reported.
002592  ** UPDATE applies to insert operations only and means that the insert
002593  ** is omitted and the DO UPDATE clause of an upsert is run instead.
002594  **
002595  ** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys.
002596  ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
002597  ** same as ROLLBACK for DEFERRED keys.  SETNULL means that the foreign
002598  ** key is set to NULL.  SETDFLT means that the foreign key is set
002599  ** to its default value.  CASCADE means that a DELETE or UPDATE of the
002600  ** referenced table row is propagated into the row that holds the
002601  ** foreign key.
002602  **
002603  ** The OE_Default value is a place holder that means to use whatever
002604  ** conflict resolution algorithm is required from context.
002605  **
002606  ** The following symbolic values are used to record which type
002607  ** of conflict resolution action to take.
002608  */
002609  #define OE_None     0   /* There is no constraint to check */
002610  #define OE_Rollback 1   /* Fail the operation and rollback the transaction */
002611  #define OE_Abort    2   /* Back out changes but do no rollback transaction */
002612  #define OE_Fail     3   /* Stop the operation but leave all prior changes */
002613  #define OE_Ignore   4   /* Ignore the error. Do not do the INSERT or UPDATE */
002614  #define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */
002615  #define OE_Update   6   /* Process as a DO UPDATE in an upsert */
002616  #define OE_Restrict 7   /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
002617  #define OE_SetNull  8   /* Set the foreign key value to NULL */
002618  #define OE_SetDflt  9   /* Set the foreign key value to its default */
002619  #define OE_Cascade  10  /* Cascade the changes */
002620  #define OE_Default  11  /* Do whatever the default action is */
002621  
002622  
002623  /*
002624  ** An instance of the following structure is passed as the first
002625  ** argument to sqlite3VdbeKeyCompare and is used to control the
002626  ** comparison of the two index keys.
002627  **
002628  ** Note that aSortOrder[] and aColl[] have nField+1 slots.  There
002629  ** are nField slots for the columns of an index then one extra slot
002630  ** for the rowid at the end.
002631  */
002632  struct KeyInfo {
002633    u32 nRef;           /* Number of references to this KeyInfo object */
002634    u8 enc;             /* Text encoding - one of the SQLITE_UTF* values */
002635    u16 nKeyField;      /* Number of key columns in the index */
002636    u16 nAllField;      /* Total columns, including key plus others */
002637    sqlite3 *db;        /* The database connection */
002638    u8 *aSortFlags;     /* Sort order for each column. */
002639    CollSeq *aColl[1];  /* Collating sequence for each term of the key */
002640  };
002641  
002642  /*
002643  ** Allowed bit values for entries in the KeyInfo.aSortFlags[] array.
002644  */
002645  #define KEYINFO_ORDER_DESC    0x01    /* DESC sort order */
002646  #define KEYINFO_ORDER_BIGNULL 0x02    /* NULL is larger than any other value */
002647  
002648  /*
002649  ** This object holds a record which has been parsed out into individual
002650  ** fields, for the purposes of doing a comparison.
002651  **
002652  ** A record is an object that contains one or more fields of data.
002653  ** Records are used to store the content of a table row and to store
002654  ** the key of an index.  A blob encoding of a record is created by
002655  ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
002656  ** OP_Column opcode.
002657  **
002658  ** An instance of this object serves as a "key" for doing a search on
002659  ** an index b+tree. The goal of the search is to find the entry that
002660  ** is closed to the key described by this object.  This object might hold
002661  ** just a prefix of the key.  The number of fields is given by
002662  ** pKeyInfo->nField.
002663  **
002664  ** The r1 and r2 fields are the values to return if this key is less than
002665  ** or greater than a key in the btree, respectively.  These are normally
002666  ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree
002667  ** is in DESC order.
002668  **
002669  ** The key comparison functions actually return default_rc when they find
002670  ** an equals comparison.  default_rc can be -1, 0, or +1.  If there are
002671  ** multiple entries in the b-tree with the same key (when only looking
002672  ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
002673  ** cause the search to find the last match, or +1 to cause the search to
002674  ** find the first match.
002675  **
002676  ** The key comparison functions will set eqSeen to true if they ever
002677  ** get and equal results when comparing this structure to a b-tree record.
002678  ** When default_rc!=0, the search might end up on the record immediately
002679  ** before the first match or immediately after the last match.  The
002680  ** eqSeen field will indicate whether or not an exact match exists in the
002681  ** b-tree.
002682  */
002683  struct UnpackedRecord {
002684    KeyInfo *pKeyInfo;  /* Collation and sort-order information */
002685    Mem *aMem;          /* Values */
002686    union {
002687      char *z;            /* Cache of aMem[0].z for vdbeRecordCompareString() */
002688      i64 i;              /* Cache of aMem[0].u.i for vdbeRecordCompareInt() */
002689    } u;
002690    int n;              /* Cache of aMem[0].n used by vdbeRecordCompareString() */
002691    u16 nField;         /* Number of entries in apMem[] */
002692    i8 default_rc;      /* Comparison result if keys are equal */
002693    u8 errCode;         /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
002694    i8 r1;              /* Value to return if (lhs < rhs) */
002695    i8 r2;              /* Value to return if (lhs > rhs) */
002696    u8 eqSeen;          /* True if an equality comparison has been seen */
002697  };
002698  
002699  
002700  /*
002701  ** Each SQL index is represented in memory by an
002702  ** instance of the following structure.
002703  **
002704  ** The columns of the table that are to be indexed are described
002705  ** by the aiColumn[] field of this structure.  For example, suppose
002706  ** we have the following table and index:
002707  **
002708  **     CREATE TABLE Ex1(c1 int, c2 int, c3 text);
002709  **     CREATE INDEX Ex2 ON Ex1(c3,c1);
002710  **
002711  ** In the Table structure describing Ex1, nCol==3 because there are
002712  ** three columns in the table.  In the Index structure describing
002713  ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
002714  ** The value of aiColumn is {2, 0}.  aiColumn[0]==2 because the
002715  ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
002716  ** The second column to be indexed (c1) has an index of 0 in
002717  ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
002718  **
002719  ** The Index.onError field determines whether or not the indexed columns
002720  ** must be unique and what to do if they are not.  When Index.onError=OE_None,
002721  ** it means this is not a unique index.  Otherwise it is a unique index
002722  ** and the value of Index.onError indicates which conflict resolution
002723  ** algorithm to employ when an attempt is made to insert a non-unique
002724  ** element.
002725  **
002726  ** The colNotIdxed bitmask is used in combination with SrcItem.colUsed
002727  ** for a fast test to see if an index can serve as a covering index.
002728  ** colNotIdxed has a 1 bit for every column of the original table that
002729  ** is *not* available in the index.  Thus the expression
002730  ** "colUsed & colNotIdxed" will be non-zero if the index is not a
002731  ** covering index.  The most significant bit of of colNotIdxed will always
002732  ** be true (note-20221022-a).  If a column beyond the 63rd column of the
002733  ** table is used, the "colUsed & colNotIdxed" test will always be non-zero
002734  ** and we have to assume either that the index is not covering, or use
002735  ** an alternative (slower) algorithm to determine whether or not
002736  ** the index is covering.
002737  **
002738  ** While parsing a CREATE TABLE or CREATE INDEX statement in order to
002739  ** generate VDBE code (as opposed to parsing one read from an sqlite_schema
002740  ** table as part of parsing an existing database schema), transient instances
002741  ** of this structure may be created. In this case the Index.tnum variable is
002742  ** used to store the address of a VDBE instruction, not a database page
002743  ** number (it cannot - the database page is not allocated until the VDBE
002744  ** program is executed). See convertToWithoutRowidTable() for details.
002745  */
002746  struct Index {
002747    char *zName;             /* Name of this index */
002748    i16 *aiColumn;           /* Which columns are used by this index.  1st is 0 */
002749    LogEst *aiRowLogEst;     /* From ANALYZE: Est. rows selected by each column */
002750    Table *pTable;           /* The SQL table being indexed */
002751    char *zColAff;           /* String defining the affinity of each column */
002752    Index *pNext;            /* The next index associated with the same table */
002753    Schema *pSchema;         /* Schema containing this index */
002754    u8 *aSortOrder;          /* for each column: True==DESC, False==ASC */
002755    const char **azColl;     /* Array of collation sequence names for index */
002756    Expr *pPartIdxWhere;     /* WHERE clause for partial indices */
002757    ExprList *aColExpr;      /* Column expressions */
002758    Pgno tnum;               /* DB Page containing root of this index */
002759    LogEst szIdxRow;         /* Estimated average row size in bytes */
002760    u16 nKeyCol;             /* Number of columns forming the key */
002761    u16 nColumn;             /* Number of columns stored in the index */
002762    u8 onError;              /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
002763    unsigned idxType:2;      /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */
002764    unsigned bUnordered:1;   /* Use this index for == or IN queries only */
002765    unsigned uniqNotNull:1;  /* True if UNIQUE and NOT NULL for all columns */
002766    unsigned isResized:1;    /* True if resizeIndexObject() has been called */
002767    unsigned isCovering:1;   /* True if this is a covering index */
002768    unsigned noSkipScan:1;   /* Do not try to use skip-scan if true */
002769    unsigned hasStat1:1;     /* aiRowLogEst values come from sqlite_stat1 */
002770    unsigned bLowQual:1;     /* sqlite_stat1 says this is a low-quality index */
002771    unsigned bNoQuery:1;     /* Do not use this index to optimize queries */
002772    unsigned bAscKeyBug:1;   /* True if the bba7b69f9849b5bf bug applies */
002773    unsigned bHasVCol:1;     /* Index references one or more VIRTUAL columns */
002774    unsigned bHasExpr:1;     /* Index contains an expression, either a literal
002775                             ** expression, or a reference to a VIRTUAL column */
002776  #ifdef SQLITE_ENABLE_STAT4
002777    int nSample;             /* Number of elements in aSample[] */
002778    int mxSample;            /* Number of slots allocated to aSample[] */
002779    int nSampleCol;          /* Size of IndexSample.anEq[] and so on */
002780    tRowcnt *aAvgEq;         /* Average nEq values for keys not in aSample */
002781    IndexSample *aSample;    /* Samples of the left-most key */
002782    tRowcnt *aiRowEst;       /* Non-logarithmic stat1 data for this index */
002783    tRowcnt nRowEst0;        /* Non-logarithmic number of rows in the index */
002784  #endif
002785    Bitmask colNotIdxed;     /* Unindexed columns in pTab */
002786  };
002787  
002788  /*
002789  ** Allowed values for Index.idxType
002790  */
002791  #define SQLITE_IDXTYPE_APPDEF      0   /* Created using CREATE INDEX */
002792  #define SQLITE_IDXTYPE_UNIQUE      1   /* Implements a UNIQUE constraint */
002793  #define SQLITE_IDXTYPE_PRIMARYKEY  2   /* Is the PRIMARY KEY for the table */
002794  #define SQLITE_IDXTYPE_IPK         3   /* INTEGER PRIMARY KEY index */
002795  
002796  /* Return true if index X is a PRIMARY KEY index */
002797  #define IsPrimaryKeyIndex(X)  ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
002798  
002799  /* Return true if index X is a UNIQUE index */
002800  #define IsUniqueIndex(X)      ((X)->onError!=OE_None)
002801  
002802  /* The Index.aiColumn[] values are normally positive integer.  But
002803  ** there are some negative values that have special meaning:
002804  */
002805  #define XN_ROWID     (-1)     /* Indexed column is the rowid */
002806  #define XN_EXPR      (-2)     /* Indexed column is an expression */
002807  
002808  /*
002809  ** Each sample stored in the sqlite_stat4 table is represented in memory
002810  ** using a structure of this type.  See documentation at the top of the
002811  ** analyze.c source file for additional information.
002812  */
002813  struct IndexSample {
002814    void *p;          /* Pointer to sampled record */
002815    int n;            /* Size of record in bytes */
002816    tRowcnt *anEq;    /* Est. number of rows where the key equals this sample */
002817    tRowcnt *anLt;    /* Est. number of rows where key is less than this sample */
002818    tRowcnt *anDLt;   /* Est. number of distinct keys less than this sample */
002819  };
002820  
002821  /*
002822  ** Possible values to use within the flags argument to sqlite3GetToken().
002823  */
002824  #define SQLITE_TOKEN_QUOTED    0x1 /* Token is a quoted identifier. */
002825  #define SQLITE_TOKEN_KEYWORD   0x2 /* Token is a keyword. */
002826  
002827  /*
002828  ** Each token coming out of the lexer is an instance of
002829  ** this structure.  Tokens are also used as part of an expression.
002830  **
002831  ** The memory that "z" points to is owned by other objects.  Take care
002832  ** that the owner of the "z" string does not deallocate the string before
002833  ** the Token goes out of scope!  Very often, the "z" points to some place
002834  ** in the middle of the Parse.zSql text.  But it might also point to a
002835  ** static string.
002836  */
002837  struct Token {
002838    const char *z;     /* Text of the token.  Not NULL-terminated! */
002839    unsigned int n;    /* Number of characters in this token */
002840  };
002841  
002842  /*
002843  ** An instance of this structure contains information needed to generate
002844  ** code for a SELECT that contains aggregate functions.
002845  **
002846  ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
002847  ** pointer to this structure.  The Expr.iAgg field is the index in
002848  ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
002849  ** code for that node.
002850  **
002851  ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
002852  ** original Select structure that describes the SELECT statement.  These
002853  ** fields do not need to be freed when deallocating the AggInfo structure.
002854  */
002855  struct AggInfo {
002856    u8 directMode;          /* Direct rendering mode means take data directly
002857                            ** from source tables rather than from accumulators */
002858    u8 useSortingIdx;       /* In direct mode, reference the sorting index rather
002859                            ** than the source table */
002860    u16 nSortingColumn;     /* Number of columns in the sorting index */
002861    int sortingIdx;         /* Cursor number of the sorting index */
002862    int sortingIdxPTab;     /* Cursor number of pseudo-table */
002863    int iFirstReg;          /* First register in range for aCol[] and aFunc[] */
002864    ExprList *pGroupBy;     /* The group by clause */
002865    struct AggInfo_col {    /* For each column used in source tables */
002866      Table *pTab;             /* Source table */
002867      Expr *pCExpr;            /* The original expression */
002868      int iTable;              /* Cursor number of the source table */
002869      i16 iColumn;             /* Column number within the source table */
002870      i16 iSorterColumn;       /* Column number in the sorting index */
002871    } *aCol;
002872    int nColumn;            /* Number of used entries in aCol[] */
002873    int nAccumulator;       /* Number of columns that show through to the output.
002874                            ** Additional columns are used only as parameters to
002875                            ** aggregate functions */
002876    struct AggInfo_func {   /* For each aggregate function */
002877      Expr *pFExpr;            /* Expression encoding the function */
002878      FuncDef *pFunc;          /* The aggregate function implementation */
002879      int iDistinct;           /* Ephemeral table used to enforce DISTINCT */
002880      int iDistAddr;           /* Address of OP_OpenEphemeral */
002881      int iOBTab;              /* Ephemeral table to implement ORDER BY */
002882      u8 bOBPayload;           /* iOBTab has payload columns separate from key */
002883      u8 bOBUnique;            /* Enforce uniqueness on iOBTab keys */
002884      u8 bUseSubtype;          /* Transfer subtype info through sorter */
002885    } *aFunc;
002886    int nFunc;              /* Number of entries in aFunc[] */
002887    u32 selId;              /* Select to which this AggInfo belongs */
002888  #ifdef SQLITE_DEBUG
002889    Select *pSelect;        /* SELECT statement that this AggInfo supports */
002890  #endif
002891  };
002892  
002893  /*
002894  ** Macros to compute aCol[] and aFunc[] register numbers.
002895  **
002896  ** These macros should not be used prior to the call to
002897  ** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg.
002898  ** The assert()s that are part of this macro verify that constraint.
002899  */
002900  #define AggInfoColumnReg(A,I)  (assert((A)->iFirstReg),(A)->iFirstReg+(I))
002901  #define AggInfoFuncReg(A,I)    \
002902                        (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))
002903  
002904  /*
002905  ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
002906  ** Usually it is 16-bits.  But if SQLITE_MAX_VARIABLE_NUMBER is greater
002907  ** than 32767 we have to make it 32-bit.  16-bit is preferred because
002908  ** it uses less memory in the Expr object, which is a big memory user
002909  ** in systems with lots of prepared statements.  And few applications
002910  ** need more than about 10 or 20 variables.  But some extreme users want
002911  ** to have prepared statements with over 32766 variables, and for them
002912  ** the option is available (at compile-time).
002913  */
002914  #if SQLITE_MAX_VARIABLE_NUMBER<32767
002915  typedef i16 ynVar;
002916  #else
002917  typedef int ynVar;
002918  #endif
002919  
002920  /*
002921  ** Each node of an expression in the parse tree is an instance
002922  ** of this structure.
002923  **
002924  ** Expr.op is the opcode. The integer parser token codes are reused
002925  ** as opcodes here. For example, the parser defines TK_GE to be an integer
002926  ** code representing the ">=" operator. This same integer code is reused
002927  ** to represent the greater-than-or-equal-to operator in the expression
002928  ** tree.
002929  **
002930  ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
002931  ** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If
002932  ** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the
002933  ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
002934  ** then Expr.u.zToken contains the name of the function.
002935  **
002936  ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
002937  ** binary operator. Either or both may be NULL.
002938  **
002939  ** Expr.x.pList is a list of arguments if the expression is an SQL function,
002940  ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
002941  ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
002942  ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
002943  ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
002944  ** valid.
002945  **
002946  ** An expression of the form ID or ID.ID refers to a column in a table.
002947  ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
002948  ** the integer cursor number of a VDBE cursor pointing to that table and
002949  ** Expr.iColumn is the column number for the specific column.  If the
002950  ** expression is used as a result in an aggregate SELECT, then the
002951  ** value is also stored in the Expr.iAgg column in the aggregate so that
002952  ** it can be accessed after all aggregates are computed.
002953  **
002954  ** If the expression is an unbound variable marker (a question mark
002955  ** character '?' in the original SQL) then the Expr.iTable holds the index
002956  ** number for that variable.
002957  **
002958  ** If the expression is a subquery then Expr.iColumn holds an integer
002959  ** register number containing the result of the subquery.  If the
002960  ** subquery gives a constant result, then iTable is -1.  If the subquery
002961  ** gives a different answer at different times during statement processing
002962  ** then iTable is the address of a subroutine that computes the subquery.
002963  **
002964  ** If the Expr is of type OP_Column, and the table it is selecting from
002965  ** is a disk table or the "old.*" pseudo-table, then pTab points to the
002966  ** corresponding table definition.
002967  **
002968  ** ALLOCATION NOTES:
002969  **
002970  ** Expr objects can use a lot of memory space in database schema.  To
002971  ** help reduce memory requirements, sometimes an Expr object will be
002972  ** truncated.  And to reduce the number of memory allocations, sometimes
002973  ** two or more Expr objects will be stored in a single memory allocation,
002974  ** together with Expr.u.zToken strings.
002975  **
002976  ** If the EP_Reduced and EP_TokenOnly flags are set when
002977  ** an Expr object is truncated.  When EP_Reduced is set, then all
002978  ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
002979  ** are contained within the same memory allocation.  Note, however, that
002980  ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
002981  ** allocated, regardless of whether or not EP_Reduced is set.
002982  */
002983  struct Expr {
002984    u8 op;                 /* Operation performed by this node */
002985    char affExpr;          /* affinity, or RAISE type */
002986    u8 op2;                /* TK_REGISTER/TK_TRUTH: original value of Expr.op
002987                           ** TK_COLUMN: the value of p5 for OP_Column
002988                           ** TK_AGG_FUNCTION: nesting depth
002989                           ** TK_FUNCTION: NC_SelfRef flag if needs OP_PureFunc */
002990  #ifdef SQLITE_DEBUG
002991    u8 vvaFlags;           /* Verification flags. */
002992  #endif
002993    u32 flags;             /* Various flags.  EP_* See below */
002994    union {
002995      char *zToken;          /* Token value. Zero terminated and dequoted */
002996      int iValue;            /* Non-negative integer value if EP_IntValue */
002997    } u;
002998  
002999    /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
003000    ** space is allocated for the fields below this point. An attempt to
003001    ** access them will result in a segfault or malfunction.
003002    *********************************************************************/
003003  
003004    Expr *pLeft;           /* Left subnode */
003005    Expr *pRight;          /* Right subnode */
003006    union {
003007      ExprList *pList;     /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
003008      Select *pSelect;     /* EP_xIsSelect and op = IN, EXISTS, SELECT */
003009    } x;
003010  
003011    /* If the EP_Reduced flag is set in the Expr.flags mask, then no
003012    ** space is allocated for the fields below this point. An attempt to
003013    ** access them will result in a segfault or malfunction.
003014    *********************************************************************/
003015  
003016  #if SQLITE_MAX_EXPR_DEPTH>0
003017    int nHeight;           /* Height of the tree headed by this node */
003018  #endif
003019    int iTable;            /* TK_COLUMN: cursor number of table holding column
003020                           ** TK_REGISTER: register number
003021                           ** TK_TRIGGER: 1 -> new, 0 -> old
003022                           ** EP_Unlikely:  134217728 times likelihood
003023                           ** TK_IN: ephemeral table holding RHS
003024                           ** TK_SELECT_COLUMN: Number of columns on the LHS
003025                           ** TK_SELECT: 1st register of result vector */
003026    ynVar iColumn;         /* TK_COLUMN: column index.  -1 for rowid.
003027                           ** TK_VARIABLE: variable number (always >= 1).
003028                           ** TK_SELECT_COLUMN: column of the result vector */
003029    i16 iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
003030    union {
003031      int iJoin;             /* If EP_OuterON or EP_InnerON, the right table */
003032      int iOfst;             /* else: start of token from start of statement */
003033    } w;
003034    AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
003035    union {
003036      Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL
003037                             ** for a column of an index on an expression */
003038      Window *pWin;          /* EP_WinFunc: Window/Filter defn for a function */
003039      struct {               /* TK_IN, TK_SELECT, and TK_EXISTS */
003040        int iAddr;             /* Subroutine entry address */
003041        int regReturn;         /* Register used to hold return address */
003042      } sub;
003043    } y;
003044  };
003045  
003046  /* The following are the meanings of bits in the Expr.flags field.
003047  ** Value restrictions:
003048  **
003049  **          EP_Agg == NC_HasAgg == SF_HasAgg
003050  **          EP_Win == NC_HasWin
003051  */
003052  #define EP_OuterON    0x000001 /* Originates in ON/USING clause of outer join */
003053  #define EP_InnerON    0x000002 /* Originates in ON/USING of an inner join */
003054  #define EP_Distinct   0x000004 /* Aggregate function with DISTINCT keyword */
003055  #define EP_HasFunc    0x000008 /* Contains one or more functions of any kind */
003056  #define EP_Agg        0x000010 /* Contains one or more aggregate functions */
003057  #define EP_FixedCol   0x000020 /* TK_Column with a known fixed value */
003058  #define EP_VarSelect  0x000040 /* pSelect is correlated, not constant */
003059  #define EP_DblQuoted  0x000080 /* token.z was originally in "..." */
003060  #define EP_InfixFunc  0x000100 /* True for an infix function: LIKE, GLOB, etc */
003061  #define EP_Collate    0x000200 /* Tree contains a TK_COLLATE operator */
003062  #define EP_Commuted   0x000400 /* Comparison operator has been commuted */
003063  #define EP_IntValue   0x000800 /* Integer value contained in u.iValue */
003064  #define EP_xIsSelect  0x001000 /* x.pSelect is valid (otherwise x.pList is) */
003065  #define EP_Skip       0x002000 /* Operator does not contribute to affinity */
003066  #define EP_Reduced    0x004000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
003067  #define EP_Win        0x008000 /* Contains window functions */
003068  #define EP_TokenOnly  0x010000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
003069  #define EP_FullSize   0x020000 /* Expr structure must remain full sized */
003070  #define EP_IfNullRow  0x040000 /* The TK_IF_NULL_ROW opcode */
003071  #define EP_Unlikely   0x080000 /* unlikely() or likelihood() function */
003072  #define EP_ConstFunc  0x100000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
003073  #define EP_CanBeNull  0x200000 /* Can be null despite NOT NULL constraint */
003074  #define EP_Subquery   0x400000 /* Tree contains a TK_SELECT operator */
003075  #define EP_Leaf       0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
003076  #define EP_WinFunc   0x1000000 /* TK_FUNCTION with Expr.y.pWin set */
003077  #define EP_Subrtn    0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */
003078  #define EP_Quoted    0x4000000 /* TK_ID was originally quoted */
003079  #define EP_Static    0x8000000 /* Held in memory not obtained from malloc() */
003080  #define EP_IsTrue   0x10000000 /* Always has boolean value of TRUE */
003081  #define EP_IsFalse  0x20000000 /* Always has boolean value of FALSE */
003082  #define EP_FromDDL  0x40000000 /* Originates from sqlite_schema */
003083                 /*   0x80000000 // Available */
003084  
003085  /* The EP_Propagate mask is a set of properties that automatically propagate
003086  ** upwards into parent nodes.
003087  */
003088  #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)
003089  
003090  /* Macros can be used to test, set, or clear bits in the
003091  ** Expr.flags field.
003092  */
003093  #define ExprHasProperty(E,P)     (((E)->flags&(P))!=0)
003094  #define ExprHasAllProperty(E,P)  (((E)->flags&(P))==(P))
003095  #define ExprSetProperty(E,P)     (E)->flags|=(P)
003096  #define ExprClearProperty(E,P)   (E)->flags&=~(P)
003097  #define ExprAlwaysTrue(E)   (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue)
003098  #define ExprAlwaysFalse(E)  (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse)
003099  #define ExprIsFullSize(E)   (((E)->flags&(EP_Reduced|EP_TokenOnly))==0)
003100  
003101  /* Macros used to ensure that the correct members of unions are accessed
003102  ** in Expr.
003103  */
003104  #define ExprUseUToken(E)    (((E)->flags&EP_IntValue)==0)
003105  #define ExprUseUValue(E)    (((E)->flags&EP_IntValue)!=0)
003106  #define ExprUseWOfst(E)     (((E)->flags&(EP_InnerON|EP_OuterON))==0)
003107  #define ExprUseWJoin(E)     (((E)->flags&(EP_InnerON|EP_OuterON))!=0)
003108  #define ExprUseXList(E)     (((E)->flags&EP_xIsSelect)==0)
003109  #define ExprUseXSelect(E)   (((E)->flags&EP_xIsSelect)!=0)
003110  #define ExprUseYTab(E)      (((E)->flags&(EP_WinFunc|EP_Subrtn))==0)
003111  #define ExprUseYWin(E)      (((E)->flags&EP_WinFunc)!=0)
003112  #define ExprUseYSub(E)      (((E)->flags&EP_Subrtn)!=0)
003113  
003114  /* Flags for use with Expr.vvaFlags
003115  */
003116  #define EP_NoReduce   0x01  /* Cannot EXPRDUP_REDUCE this Expr */
003117  #define EP_Immutable  0x02  /* Do not change this Expr node */
003118  
003119  /* The ExprSetVVAProperty() macro is used for Verification, Validation,
003120  ** and Accreditation only.  It works like ExprSetProperty() during VVA
003121  ** processes but is a no-op for delivery.
003122  */
003123  #ifdef SQLITE_DEBUG
003124  # define ExprSetVVAProperty(E,P)   (E)->vvaFlags|=(P)
003125  # define ExprHasVVAProperty(E,P)   (((E)->vvaFlags&(P))!=0)
003126  # define ExprClearVVAProperties(E) (E)->vvaFlags = 0
003127  #else
003128  # define ExprSetVVAProperty(E,P)
003129  # define ExprHasVVAProperty(E,P)   0
003130  # define ExprClearVVAProperties(E)
003131  #endif
003132  
003133  /*
003134  ** Macros to determine the number of bytes required by a normal Expr
003135  ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
003136  ** and an Expr struct with the EP_TokenOnly flag set.
003137  */
003138  #define EXPR_FULLSIZE           sizeof(Expr)           /* Full size */
003139  #define EXPR_REDUCEDSIZE        offsetof(Expr,iTable)  /* Common features */
003140  #define EXPR_TOKENONLYSIZE      offsetof(Expr,pLeft)   /* Fewer features */
003141  
003142  /*
003143  ** Flags passed to the sqlite3ExprDup() function. See the header comment
003144  ** above sqlite3ExprDup() for details.
003145  */
003146  #define EXPRDUP_REDUCE         0x0001  /* Used reduced-size Expr nodes */
003147  
003148  /*
003149  ** True if the expression passed as an argument was a function with
003150  ** an OVER() clause (a window function).
003151  */
003152  #ifdef SQLITE_OMIT_WINDOWFUNC
003153  # define IsWindowFunc(p) 0
003154  #else
003155  # define IsWindowFunc(p) ( \
003156      ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \
003157   )
003158  #endif
003159  
003160  /*
003161  ** A list of expressions.  Each expression may optionally have a
003162  ** name.  An expr/name combination can be used in several ways, such
003163  ** as the list of "expr AS ID" fields following a "SELECT" or in the
003164  ** list of "ID = expr" items in an UPDATE.  A list of expressions can
003165  ** also be used as the argument to a function, in which case the a.zName
003166  ** field is not used.
003167  **
003168  ** In order to try to keep memory usage down, the Expr.a.zEName field
003169  ** is used for multiple purposes:
003170  **
003171  **     eEName          Usage
003172  **    ----------       -------------------------
003173  **    ENAME_NAME       (1) the AS of result set column
003174  **                     (2) COLUMN= of an UPDATE
003175  **
003176  **    ENAME_TAB        DB.TABLE.NAME used to resolve names
003177  **                     of subqueries
003178  **
003179  **    ENAME_SPAN       Text of the original result set
003180  **                     expression.
003181  */
003182  struct ExprList {
003183    int nExpr;             /* Number of expressions on the list */
003184    int nAlloc;            /* Number of a[] slots allocated */
003185    struct ExprList_item { /* For each expression in the list */
003186      Expr *pExpr;            /* The parse tree for this expression */
003187      char *zEName;           /* Token associated with this expression */
003188      struct {
003189        u8 sortFlags;           /* Mask of KEYINFO_ORDER_* flags */
003190        unsigned eEName :2;     /* Meaning of zEName */
003191        unsigned done :1;       /* Indicates when processing is finished */
003192        unsigned reusable :1;   /* Constant expression is reusable */
003193        unsigned bSorterRef :1; /* Defer evaluation until after sorting */
003194        unsigned bNulls :1;     /* True if explicit "NULLS FIRST/LAST" */
003195        unsigned bUsed :1;      /* This column used in a SF_NestedFrom subquery */
003196        unsigned bUsingTerm:1;  /* Term from the USING clause of a NestedFrom */
003197        unsigned bNoExpand: 1;  /* Term is an auxiliary in NestedFrom and should
003198                                ** not be expanded by "*" in parent queries */
003199      } fg;
003200      union {
003201        struct {             /* Used by any ExprList other than Parse.pConsExpr */
003202          u16 iOrderByCol;      /* For ORDER BY, column number in result set */
003203          u16 iAlias;           /* Index into Parse.aAlias[] for zName */
003204        } x;
003205        int iConstExprReg;   /* Register in which Expr value is cached. Used only
003206                             ** by Parse.pConstExpr */
003207      } u;
003208    } a[1];                  /* One slot for each expression in the list */
003209  };
003210  
003211  /*
003212  ** Allowed values for Expr.a.eEName
003213  */
003214  #define ENAME_NAME  0       /* The AS clause of a result set */
003215  #define ENAME_SPAN  1       /* Complete text of the result set expression */
003216  #define ENAME_TAB   2       /* "DB.TABLE.NAME" for the result set */
003217  #define ENAME_ROWID 3       /* "DB.TABLE._rowid_" for * expansion of rowid */
003218  
003219  /*
003220  ** An instance of this structure can hold a simple list of identifiers,
003221  ** such as the list "a,b,c" in the following statements:
003222  **
003223  **      INSERT INTO t(a,b,c) VALUES ...;
003224  **      CREATE INDEX idx ON t(a,b,c);
003225  **      CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
003226  **
003227  ** The IdList.a.idx field is used when the IdList represents the list of
003228  ** column names after a table name in an INSERT statement.  In the statement
003229  **
003230  **     INSERT INTO t(a,b,c) ...
003231  **
003232  ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
003233  */
003234  struct IdList {
003235    int nId;         /* Number of identifiers on the list */
003236    u8 eU4;          /* Which element of a.u4 is valid */
003237    struct IdList_item {
003238      char *zName;      /* Name of the identifier */
003239      union {
003240        int idx;          /* Index in some Table.aCol[] of a column named zName */
003241        Expr *pExpr;      /* Expr to implement a USING variable -- NOT USED */
003242      } u4;
003243    } a[1];
003244  };
003245  
003246  /*
003247  ** Allowed values for IdList.eType, which determines which value of the a.u4
003248  ** is valid.
003249  */
003250  #define EU4_NONE   0   /* Does not use IdList.a.u4 */
003251  #define EU4_IDX    1   /* Uses IdList.a.u4.idx */
003252  #define EU4_EXPR   2   /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
003253  
003254  /*
003255  ** The SrcItem object represents a single term in the FROM clause of a query.
003256  ** The SrcList object is mostly an array of SrcItems.
003257  **
003258  ** The jointype starts out showing the join type between the current table
003259  ** and the next table on the list.  The parser builds the list this way.
003260  ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
003261  ** jointype expresses the join between the table and the previous table.
003262  **
003263  ** In the colUsed field, the high-order bit (bit 63) is set if the table
003264  ** contains more than 63 columns and the 64-th or later column is used.
003265  **
003266  ** Union member validity:
003267  **
003268  **    u1.zIndexedBy          fg.isIndexedBy && !fg.isTabFunc
003269  **    u1.pFuncArg            fg.isTabFunc   && !fg.isIndexedBy
003270  **    u2.pIBIndex            fg.isIndexedBy && !fg.isCte
003271  **    u2.pCteUse             fg.isCte       && !fg.isIndexedBy
003272  */
003273  struct SrcItem {
003274    Schema *pSchema;  /* Schema to which this item is fixed */
003275    char *zDatabase;  /* Name of database holding this table */
003276    char *zName;      /* Name of the table */
003277    char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
003278    Table *pTab;      /* An SQL table corresponding to zName */
003279    Select *pSelect;  /* A SELECT statement used in place of a table name */
003280    int addrFillSub;  /* Address of subroutine to manifest a subquery */
003281    int regReturn;    /* Register holding return address of addrFillSub */
003282    int regResult;    /* Registers holding results of a co-routine */
003283    struct {
003284      u8 jointype;      /* Type of join between this table and the previous */
003285      unsigned notIndexed :1;    /* True if there is a NOT INDEXED clause */
003286      unsigned isIndexedBy :1;   /* True if there is an INDEXED BY clause */
003287      unsigned isTabFunc :1;     /* True if table-valued-function syntax */
003288      unsigned isCorrelated :1;  /* True if sub-query is correlated */
003289      unsigned isMaterialized:1; /* This is a materialized view */
003290      unsigned viaCoroutine :1;  /* Implemented as a co-routine */
003291      unsigned isRecursive :1;   /* True for recursive reference in WITH */
003292      unsigned fromDDL :1;       /* Comes from sqlite_schema */
003293      unsigned isCte :1;         /* This is a CTE */
003294      unsigned notCte :1;        /* This item may not match a CTE */
003295      unsigned isUsing :1;       /* u3.pUsing is valid */
003296      unsigned isOn :1;          /* u3.pOn was once valid and non-NULL */
003297      unsigned isSynthUsing :1;  /* u3.pUsing is synthesized from NATURAL */
003298      unsigned isNestedFrom :1;  /* pSelect is a SF_NestedFrom subquery */
003299    } fg;
003300    int iCursor;      /* The VDBE cursor number used to access this table */
003301    union {
003302      Expr *pOn;        /* fg.isUsing==0 =>  The ON clause of a join */
003303      IdList *pUsing;   /* fg.isUsing==1 =>  The USING clause of a join */
003304    } u3;
003305    Bitmask colUsed;  /* Bit N set if column N used. Details above for N>62 */
003306    union {
003307      char *zIndexedBy;    /* Identifier from "INDEXED BY <zIndex>" clause */
003308      ExprList *pFuncArg;  /* Arguments to table-valued-function */
003309    } u1;
003310    union {
003311      Index *pIBIndex;  /* Index structure corresponding to u1.zIndexedBy */
003312      CteUse *pCteUse;  /* CTE Usage info when fg.isCte is true */
003313    } u2;
003314  };
003315  
003316  /*
003317  ** The OnOrUsing object represents either an ON clause or a USING clause.
003318  ** It can never be both at the same time, but it can be neither.
003319  */
003320  struct OnOrUsing {
003321    Expr *pOn;         /* The ON clause of a join */
003322    IdList *pUsing;    /* The USING clause of a join */
003323  };
003324  
003325  /*
003326  ** This object represents one or more tables that are the source of
003327  ** content for an SQL statement.  For example, a single SrcList object
003328  ** is used to hold the FROM clause of a SELECT statement.  SrcList also
003329  ** represents the target tables for DELETE, INSERT, and UPDATE statements.
003330  **
003331  */
003332  struct SrcList {
003333    int nSrc;        /* Number of tables or subqueries in the FROM clause */
003334    u32 nAlloc;      /* Number of entries allocated in a[] below */
003335    SrcItem a[1];    /* One entry for each identifier on the list */
003336  };
003337  
003338  /*
003339  ** Permitted values of the SrcList.a.jointype field
003340  */
003341  #define JT_INNER     0x01    /* Any kind of inner or cross join */
003342  #define JT_CROSS     0x02    /* Explicit use of the CROSS keyword */
003343  #define JT_NATURAL   0x04    /* True for a "natural" join */
003344  #define JT_LEFT      0x08    /* Left outer join */
003345  #define JT_RIGHT     0x10    /* Right outer join */
003346  #define JT_OUTER     0x20    /* The "OUTER" keyword is present */
003347  #define JT_LTORJ     0x40    /* One of the LEFT operands of a RIGHT JOIN
003348                               ** Mnemonic: Left Table Of Right Join */
003349  #define JT_ERROR     0x80    /* unknown or unsupported join type */
003350  
003351  /*
003352  ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
003353  ** and the WhereInfo.wctrlFlags member.
003354  **
003355  ** Value constraints (enforced via assert()):
003356  **     WHERE_USE_LIMIT  == SF_FixedLimit
003357  */
003358  #define WHERE_ORDERBY_NORMAL   0x0000 /* No-op */
003359  #define WHERE_ORDERBY_MIN      0x0001 /* ORDER BY processing for min() func */
003360  #define WHERE_ORDERBY_MAX      0x0002 /* ORDER BY processing for max() func */
003361  #define WHERE_ONEPASS_DESIRED  0x0004 /* Want to do one-pass UPDATE/DELETE */
003362  #define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
003363  #define WHERE_DUPLICATES_OK    0x0010 /* Ok to return a row more than once */
003364  #define WHERE_OR_SUBCLAUSE     0x0020 /* Processing a sub-WHERE as part of
003365                                        ** the OR optimization  */
003366  #define WHERE_GROUPBY          0x0040 /* pOrderBy is really a GROUP BY */
003367  #define WHERE_DISTINCTBY       0x0080 /* pOrderby is really a DISTINCT clause */
003368  #define WHERE_WANT_DISTINCT    0x0100 /* All output needs to be distinct */
003369  #define WHERE_SORTBYGROUP      0x0200 /* Support sqlite3WhereIsSorted() */
003370  #define WHERE_AGG_DISTINCT     0x0400 /* Query is "SELECT agg(DISTINCT ...)" */
003371  #define WHERE_ORDERBY_LIMIT    0x0800 /* ORDERBY+LIMIT on the inner loop */
003372  #define WHERE_RIGHT_JOIN       0x1000 /* Processing a RIGHT JOIN */
003373                          /*     0x2000    not currently used */
003374  #define WHERE_USE_LIMIT        0x4000 /* Use the LIMIT in cost estimates */
003375                          /*     0x8000    not currently used */
003376  
003377  /* Allowed return values from sqlite3WhereIsDistinct()
003378  */
003379  #define WHERE_DISTINCT_NOOP      0  /* DISTINCT keyword not used */
003380  #define WHERE_DISTINCT_UNIQUE    1  /* No duplicates */
003381  #define WHERE_DISTINCT_ORDERED   2  /* All duplicates are adjacent */
003382  #define WHERE_DISTINCT_UNORDERED 3  /* Duplicates are scattered */
003383  
003384  /*
003385  ** A NameContext defines a context in which to resolve table and column
003386  ** names.  The context consists of a list of tables (the pSrcList) field and
003387  ** a list of named expression (pEList).  The named expression list may
003388  ** be NULL.  The pSrc corresponds to the FROM clause of a SELECT or
003389  ** to the table being operated on by INSERT, UPDATE, or DELETE.  The
003390  ** pEList corresponds to the result set of a SELECT and is NULL for
003391  ** other statements.
003392  **
003393  ** NameContexts can be nested.  When resolving names, the inner-most
003394  ** context is searched first.  If no match is found, the next outer
003395  ** context is checked.  If there is still no match, the next context
003396  ** is checked.  This process continues until either a match is found
003397  ** or all contexts are check.  When a match is found, the nRef member of
003398  ** the context containing the match is incremented.
003399  **
003400  ** Each subquery gets a new NameContext.  The pNext field points to the
003401  ** NameContext in the parent query.  Thus the process of scanning the
003402  ** NameContext list corresponds to searching through successively outer
003403  ** subqueries looking for a match.
003404  */
003405  struct NameContext {
003406    Parse *pParse;       /* The parser */
003407    SrcList *pSrcList;   /* One or more tables used to resolve names */
003408    union {
003409      ExprList *pEList;    /* Optional list of result-set columns */
003410      AggInfo *pAggInfo;   /* Information about aggregates at this level */
003411      Upsert *pUpsert;     /* ON CONFLICT clause information from an upsert */
003412      int iBaseReg;        /* For TK_REGISTER when parsing RETURNING */
003413    } uNC;
003414    NameContext *pNext;  /* Next outer name context.  NULL for outermost */
003415    int nRef;            /* Number of names resolved by this context */
003416    int nNcErr;          /* Number of errors encountered while resolving names */
003417    int ncFlags;         /* Zero or more NC_* flags defined below */
003418    u32 nNestedSelect;   /* Number of nested selects using this NC */
003419    Select *pWinSelect;  /* SELECT statement for any window functions */
003420  };
003421  
003422  /*
003423  ** Allowed values for the NameContext, ncFlags field.
003424  **
003425  ** Value constraints (all checked via assert()):
003426  **    NC_HasAgg    == SF_HasAgg       == EP_Agg
003427  **    NC_MinMaxAgg == SF_MinMaxAgg    == SQLITE_FUNC_MINMAX
003428  **    NC_OrderAgg  == SF_OrderByReqd  == SQLITE_FUNC_ANYORDER
003429  **    NC_HasWin    == EP_Win
003430  **
003431  */
003432  #define NC_AllowAgg  0x000001 /* Aggregate functions are allowed here */
003433  #define NC_PartIdx   0x000002 /* True if resolving a partial index WHERE */
003434  #define NC_IsCheck   0x000004 /* True if resolving a CHECK constraint */
003435  #define NC_GenCol    0x000008 /* True for a GENERATED ALWAYS AS clause */
003436  #define NC_HasAgg    0x000010 /* One or more aggregate functions seen */
003437  #define NC_IdxExpr   0x000020 /* True if resolving columns of CREATE INDEX */
003438  #define NC_SelfRef   0x00002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */
003439  #define NC_Subquery  0x000040 /* A subquery has been seen */
003440  #define NC_UEList    0x000080 /* True if uNC.pEList is used */
003441  #define NC_UAggInfo  0x000100 /* True if uNC.pAggInfo is used */
003442  #define NC_UUpsert   0x000200 /* True if uNC.pUpsert is used */
003443  #define NC_UBaseReg  0x000400 /* True if uNC.iBaseReg is used */
003444  #define NC_MinMaxAgg 0x001000 /* min/max aggregates seen.  See note above */
003445  #define NC_Complex   0x002000 /* True if a function or subquery seen */
003446  #define NC_AllowWin  0x004000 /* Window functions are allowed here */
003447  #define NC_HasWin    0x008000 /* One or more window functions seen */
003448  #define NC_IsDDL     0x010000 /* Resolving names in a CREATE statement */
003449  #define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */
003450  #define NC_FromDDL   0x040000 /* SQL text comes from sqlite_schema */
003451  #define NC_NoSelect  0x080000 /* Do not descend into sub-selects */
003452  #define NC_Where     0x100000 /* Processing WHERE clause of a SELECT */
003453  #define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
003454  
003455  /*
003456  ** An instance of the following object describes a single ON CONFLICT
003457  ** clause in an upsert.
003458  **
003459  ** The pUpsertTarget field is only set if the ON CONFLICT clause includes
003460  ** conflict-target clause.  (In "ON CONFLICT(a,b)" the "(a,b)" is the
003461  ** conflict-target clause.)  The pUpsertTargetWhere is the optional
003462  ** WHERE clause used to identify partial unique indexes.
003463  **
003464  ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
003465  ** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING.  The
003466  ** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the
003467  ** WHERE clause is omitted.
003468  */
003469  struct Upsert {
003470    ExprList *pUpsertTarget;  /* Optional description of conflict target */
003471    Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */
003472    ExprList *pUpsertSet;     /* The SET clause from an ON CONFLICT UPDATE */
003473    Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */
003474    Upsert *pNextUpsert;      /* Next ON CONFLICT clause in the list */
003475    u8 isDoUpdate;            /* True for DO UPDATE.  False for DO NOTHING */
003476    u8 isDup;                 /* True if 2nd or later with same pUpsertIdx */
003477    /* Above this point is the parse tree for the ON CONFLICT clauses.
003478    ** The next group of fields stores intermediate data. */
003479    void *pToFree;            /* Free memory when deleting the Upsert object */
003480    /* All fields above are owned by the Upsert object and must be freed
003481    ** when the Upsert is destroyed.  The fields below are used to transfer
003482    ** information from the INSERT processing down into the UPDATE processing
003483    ** while generating code.  The fields below are owned by the INSERT
003484    ** statement and will be freed by INSERT processing. */
003485    Index *pUpsertIdx;        /* UNIQUE constraint specified by pUpsertTarget */
003486    SrcList *pUpsertSrc;      /* Table to be updated */
003487    int regData;              /* First register holding array of VALUES */
003488    int iDataCur;             /* Index of the data cursor */
003489    int iIdxCur;              /* Index of the first index cursor */
003490  };
003491  
003492  /*
003493  ** An instance of the following structure contains all information
003494  ** needed to generate code for a single SELECT statement.
003495  **
003496  ** See the header comment on the computeLimitRegisters() routine for a
003497  ** detailed description of the meaning of the iLimit and iOffset fields.
003498  **
003499  ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
003500  ** These addresses must be stored so that we can go back and fill in
003501  ** the P4_KEYINFO and P2 parameters later.  Neither the KeyInfo nor
003502  ** the number of columns in P2 can be computed at the same time
003503  ** as the OP_OpenEphm instruction is coded because not
003504  ** enough information about the compound query is known at that point.
003505  ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
003506  ** for the result set.  The KeyInfo for addrOpenEphm[2] contains collating
003507  ** sequences for the ORDER BY clause.
003508  */
003509  struct Select {
003510    u8 op;                 /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
003511    LogEst nSelectRow;     /* Estimated number of result rows */
003512    u32 selFlags;          /* Various SF_* values */
003513    int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
003514    u32 selId;             /* Unique identifier number for this SELECT */
003515    int addrOpenEphm[2];   /* OP_OpenEphem opcodes related to this select */
003516    ExprList *pEList;      /* The fields of the result */
003517    SrcList *pSrc;         /* The FROM clause */
003518    Expr *pWhere;          /* The WHERE clause */
003519    ExprList *pGroupBy;    /* The GROUP BY clause */
003520    Expr *pHaving;         /* The HAVING clause */
003521    ExprList *pOrderBy;    /* The ORDER BY clause */
003522    Select *pPrior;        /* Prior select in a compound select statement */
003523    Select *pNext;         /* Next select to the left in a compound */
003524    Expr *pLimit;          /* LIMIT expression. NULL means not used. */
003525    With *pWith;           /* WITH clause attached to this select. Or NULL. */
003526  #ifndef SQLITE_OMIT_WINDOWFUNC
003527    Window *pWin;          /* List of window functions */
003528    Window *pWinDefn;      /* List of named window definitions */
003529  #endif
003530  };
003531  
003532  /*
003533  ** Allowed values for Select.selFlags.  The "SF" prefix stands for
003534  ** "Select Flag".
003535  **
003536  ** Value constraints (all checked via assert())
003537  **     SF_HasAgg      == NC_HasAgg
003538  **     SF_MinMaxAgg   == NC_MinMaxAgg     == SQLITE_FUNC_MINMAX
003539  **     SF_OrderByReqd == NC_OrderAgg      == SQLITE_FUNC_ANYORDER
003540  **     SF_FixedLimit  == WHERE_USE_LIMIT
003541  */
003542  #define SF_Distinct      0x0000001 /* Output should be DISTINCT */
003543  #define SF_All           0x0000002 /* Includes the ALL keyword */
003544  #define SF_Resolved      0x0000004 /* Identifiers have been resolved */
003545  #define SF_Aggregate     0x0000008 /* Contains agg functions or a GROUP BY */
003546  #define SF_HasAgg        0x0000010 /* Contains aggregate functions */
003547  #define SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */
003548  #define SF_Expanded      0x0000040 /* sqlite3SelectExpand() called on this */
003549  #define SF_HasTypeInfo   0x0000080 /* FROM subqueries have Table metadata */
003550  #define SF_Compound      0x0000100 /* Part of a compound query */
003551  #define SF_Values        0x0000200 /* Synthesized from VALUES clause */
003552  #define SF_MultiValue    0x0000400 /* Single VALUES term with multiple rows */
003553  #define SF_NestedFrom    0x0000800 /* Part of a parenthesized FROM clause */
003554  #define SF_MinMaxAgg     0x0001000 /* Aggregate containing min() or max() */
003555  #define SF_Recursive     0x0002000 /* The recursive part of a recursive CTE */
003556  #define SF_FixedLimit    0x0004000 /* nSelectRow set by a constant LIMIT */
003557  #define SF_MaybeConvert  0x0008000 /* Need convertCompoundSelectToSubquery() */
003558  #define SF_Converted     0x0010000 /* By convertCompoundSelectToSubquery() */
003559  #define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */
003560  #define SF_ComplexResult 0x0040000 /* Result contains subquery or function */
003561  #define SF_WhereBegin    0x0080000 /* Really a WhereBegin() call.  Debug Only */
003562  #define SF_WinRewrite    0x0100000 /* Window function rewrite accomplished */
003563  #define SF_View          0x0200000 /* SELECT statement is a view */
003564  #define SF_NoopOrderBy   0x0400000 /* ORDER BY is ignored for this query */
003565  #define SF_UFSrcCheck    0x0800000 /* Check pSrc as required by UPDATE...FROM */
003566  #define SF_PushDown      0x1000000 /* SELECT has be modified by push-down opt */
003567  #define SF_MultiPart     0x2000000 /* Has multiple incompatible PARTITIONs */
003568  #define SF_CopyCte       0x4000000 /* SELECT statement is a copy of a CTE */
003569  #define SF_OrderByReqd   0x8000000 /* The ORDER BY clause may not be omitted */
003570  #define SF_UpdateFrom   0x10000000 /* Query originates with UPDATE FROM */
003571  
003572  /* True if S exists and has SF_NestedFrom */
003573  #define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)
003574  
003575  /*
003576  ** The results of a SELECT can be distributed in several ways, as defined
003577  ** by one of the following macros.  The "SRT" prefix means "SELECT Result
003578  ** Type".
003579  **
003580  **     SRT_Union       Store results as a key in a temporary index
003581  **                     identified by pDest->iSDParm.
003582  **
003583  **     SRT_Except      Remove results from the temporary index pDest->iSDParm.
003584  **
003585  **     SRT_Exists      Store a 1 in memory cell pDest->iSDParm if the result
003586  **                     set is not empty.
003587  **
003588  **     SRT_Discard     Throw the results away.  This is used by SELECT
003589  **                     statements within triggers whose only purpose is
003590  **                     the side-effects of functions.
003591  **
003592  **     SRT_Output      Generate a row of output (using the OP_ResultRow
003593  **                     opcode) for each row in the result set.
003594  **
003595  **     SRT_Mem         Only valid if the result is a single column.
003596  **                     Store the first column of the first result row
003597  **                     in register pDest->iSDParm then abandon the rest
003598  **                     of the query.  This destination implies "LIMIT 1".
003599  **
003600  **     SRT_Set         The result must be a single column.  Store each
003601  **                     row of result as the key in table pDest->iSDParm.
003602  **                     Apply the affinity pDest->affSdst before storing
003603  **                     results.  Used to implement "IN (SELECT ...)".
003604  **
003605  **     SRT_EphemTab    Create an temporary table pDest->iSDParm and store
003606  **                     the result there. The cursor is left open after
003607  **                     returning.  This is like SRT_Table except that
003608  **                     this destination uses OP_OpenEphemeral to create
003609  **                     the table first.
003610  **
003611  **     SRT_Coroutine   Generate a co-routine that returns a new row of
003612  **                     results each time it is invoked.  The entry point
003613  **                     of the co-routine is stored in register pDest->iSDParm
003614  **                     and the result row is stored in pDest->nDest registers
003615  **                     starting with pDest->iSdst.
003616  **
003617  **     SRT_Table       Store results in temporary table pDest->iSDParm.
003618  **     SRT_Fifo        This is like SRT_EphemTab except that the table
003619  **                     is assumed to already be open.  SRT_Fifo has
003620  **                     the additional property of being able to ignore
003621  **                     the ORDER BY clause.
003622  **
003623  **     SRT_DistFifo    Store results in a temporary table pDest->iSDParm.
003624  **                     But also use temporary table pDest->iSDParm+1 as
003625  **                     a record of all prior results and ignore any duplicate
003626  **                     rows.  Name means:  "Distinct Fifo".
003627  **
003628  **     SRT_Queue       Store results in priority queue pDest->iSDParm (really
003629  **                     an index).  Append a sequence number so that all entries
003630  **                     are distinct.
003631  **
003632  **     SRT_DistQueue   Store results in priority queue pDest->iSDParm only if
003633  **                     the same record has never been stored before.  The
003634  **                     index at pDest->iSDParm+1 hold all prior stores.
003635  **
003636  **     SRT_Upfrom      Store results in the temporary table already opened by
003637  **                     pDest->iSDParm. If (pDest->iSDParm<0), then the temp
003638  **                     table is an intkey table - in this case the first
003639  **                     column returned by the SELECT is used as the integer
003640  **                     key. If (pDest->iSDParm>0), then the table is an index
003641  **                     table. (pDest->iSDParm) is the number of key columns in
003642  **                     each index record in this case.
003643  */
003644  #define SRT_Union        1  /* Store result as keys in an index */
003645  #define SRT_Except       2  /* Remove result from a UNION index */
003646  #define SRT_Exists       3  /* Store 1 if the result is not empty */
003647  #define SRT_Discard      4  /* Do not save the results anywhere */
003648  #define SRT_DistFifo     5  /* Like SRT_Fifo, but unique results only */
003649  #define SRT_DistQueue    6  /* Like SRT_Queue, but unique results only */
003650  
003651  /* The DISTINCT clause is ignored for all of the above.  Not that
003652  ** IgnorableDistinct() implies IgnorableOrderby() */
003653  #define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue)
003654  
003655  #define SRT_Queue        7  /* Store result in an queue */
003656  #define SRT_Fifo         8  /* Store result as data with an automatic rowid */
003657  
003658  /* The ORDER BY clause is ignored for all of the above */
003659  #define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo)
003660  
003661  #define SRT_Output       9  /* Output each row of result */
003662  #define SRT_Mem         10  /* Store result in a memory cell */
003663  #define SRT_Set         11  /* Store results as keys in an index */
003664  #define SRT_EphemTab    12  /* Create transient tab and store like SRT_Table */
003665  #define SRT_Coroutine   13  /* Generate a single row of result */
003666  #define SRT_Table       14  /* Store result as data with an automatic rowid */
003667  #define SRT_Upfrom      15  /* Store result as data with rowid */
003668  
003669  /*
003670  ** An instance of this object describes where to put of the results of
003671  ** a SELECT statement.
003672  */
003673  struct SelectDest {
003674    u8 eDest;            /* How to dispose of the results.  One of SRT_* above. */
003675    int iSDParm;         /* A parameter used by the eDest disposal method */
003676    int iSDParm2;        /* A second parameter for the eDest disposal method */
003677    int iSdst;           /* Base register where results are written */
003678    int nSdst;           /* Number of registers allocated */
003679    char *zAffSdst;      /* Affinity used for SRT_Set */
003680    ExprList *pOrderBy;  /* Key columns for SRT_Queue and SRT_DistQueue */
003681  };
003682  
003683  /*
003684  ** During code generation of statements that do inserts into AUTOINCREMENT
003685  ** tables, the following information is attached to the Table.u.autoInc.p
003686  ** pointer of each autoincrement table to record some side information that
003687  ** the code generator needs.  We have to keep per-table autoincrement
003688  ** information in case inserts are done within triggers.  Triggers do not
003689  ** normally coordinate their activities, but we do need to coordinate the
003690  ** loading and saving of autoincrement information.
003691  */
003692  struct AutoincInfo {
003693    AutoincInfo *pNext;   /* Next info block in a list of them all */
003694    Table *pTab;          /* Table this info block refers to */
003695    int iDb;              /* Index in sqlite3.aDb[] of database holding pTab */
003696    int regCtr;           /* Memory register holding the rowid counter */
003697  };
003698  
003699  /*
003700  ** At least one instance of the following structure is created for each
003701  ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
003702  ** statement. All such objects are stored in the linked list headed at
003703  ** Parse.pTriggerPrg and deleted once statement compilation has been
003704  ** completed.
003705  **
003706  ** A Vdbe sub-program that implements the body and WHEN clause of trigger
003707  ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
003708  ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
003709  ** The Parse.pTriggerPrg list never contains two entries with the same
003710  ** values for both pTrigger and orconf.
003711  **
003712  ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
003713  ** accessed (or set to 0 for triggers fired as a result of INSERT
003714  ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
003715  ** a mask of new.* columns used by the program.
003716  */
003717  struct TriggerPrg {
003718    Trigger *pTrigger;      /* Trigger this program was coded from */
003719    TriggerPrg *pNext;      /* Next entry in Parse.pTriggerPrg list */
003720    SubProgram *pProgram;   /* Program implementing pTrigger/orconf */
003721    int orconf;             /* Default ON CONFLICT policy */
003722    u32 aColmask[2];        /* Masks of old.*, new.* columns accessed */
003723  };
003724  
003725  /*
003726  ** The yDbMask datatype for the bitmask of all attached databases.
003727  */
003728  #if SQLITE_MAX_ATTACHED>30
003729    typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8];
003730  # define DbMaskTest(M,I)    (((M)[(I)/8]&(1<<((I)&7)))!=0)
003731  # define DbMaskZero(M)      memset((M),0,sizeof(M))
003732  # define DbMaskSet(M,I)     (M)[(I)/8]|=(1<<((I)&7))
003733  # define DbMaskAllZero(M)   sqlite3DbMaskAllZero(M)
003734  # define DbMaskNonZero(M)   (sqlite3DbMaskAllZero(M)==0)
003735  #else
003736    typedef unsigned int yDbMask;
003737  # define DbMaskTest(M,I)    (((M)&(((yDbMask)1)<<(I)))!=0)
003738  # define DbMaskZero(M)      ((M)=0)
003739  # define DbMaskSet(M,I)     ((M)|=(((yDbMask)1)<<(I)))
003740  # define DbMaskAllZero(M)   ((M)==0)
003741  # define DbMaskNonZero(M)   ((M)!=0)
003742  #endif
003743  
003744  /*
003745  ** For each index X that has as one of its arguments either an expression
003746  ** or the name of a virtual generated column, and if X is in scope such that
003747  ** the value of the expression can simply be read from the index, then
003748  ** there is an instance of this object on the Parse.pIdxExpr list.
003749  **
003750  ** During code generation, while generating code to evaluate expressions,
003751  ** this list is consulted and if a matching expression is found, the value
003752  ** is read from the index rather than being recomputed.
003753  */
003754  struct IndexedExpr {
003755    Expr *pExpr;            /* The expression contained in the index */
003756    int iDataCur;           /* The data cursor associated with the index */
003757    int iIdxCur;            /* The index cursor */
003758    int iIdxCol;            /* The index column that contains value of pExpr */
003759    u8 bMaybeNullRow;       /* True if we need an OP_IfNullRow check */
003760    u8 aff;                 /* Affinity of the pExpr expression */
003761    IndexedExpr *pIENext;   /* Next in a list of all indexed expressions */
003762  #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
003763    const char *zIdxName;   /* Name of index, used only for bytecode comments */
003764  #endif
003765  };
003766  
003767  /*
003768  ** An instance of the ParseCleanup object specifies an operation that
003769  ** should be performed after parsing to deallocation resources obtained
003770  ** during the parse and which are no longer needed.
003771  */
003772  struct ParseCleanup {
003773    ParseCleanup *pNext;               /* Next cleanup task */
003774    void *pPtr;                        /* Pointer to object to deallocate */
003775    void (*xCleanup)(sqlite3*,void*);  /* Deallocation routine */
003776  };
003777  
003778  /*
003779  ** An SQL parser context.  A copy of this structure is passed through
003780  ** the parser and down into all the parser action routine in order to
003781  ** carry around information that is global to the entire parse.
003782  **
003783  ** The structure is divided into two parts.  When the parser and code
003784  ** generate call themselves recursively, the first part of the structure
003785  ** is constant but the second part is reset at the beginning and end of
003786  ** each recursion.
003787  **
003788  ** The nTableLock and aTableLock variables are only used if the shared-cache
003789  ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
003790  ** used to store the set of table-locks required by the statement being
003791  ** compiled. Function sqlite3TableLock() is used to add entries to the
003792  ** list.
003793  */
003794  struct Parse {
003795    sqlite3 *db;         /* The main database structure */
003796    char *zErrMsg;       /* An error message */
003797    Vdbe *pVdbe;         /* An engine for executing database bytecode */
003798    int rc;              /* Return code from execution */
003799    u8 colNamesSet;      /* TRUE after OP_ColumnName has been issued to pVdbe */
003800    u8 checkSchema;      /* Causes schema cookie check after an error */
003801    u8 nested;           /* Number of nested calls to the parser/code generator */
003802    u8 nTempReg;         /* Number of temporary registers in aTempReg[] */
003803    u8 isMultiWrite;     /* True if statement may modify/insert multiple rows */
003804    u8 mayAbort;         /* True if statement may throw an ABORT exception */
003805    u8 hasCompound;      /* Need to invoke convertCompoundSelectToSubquery() */
003806    u8 okConstFactor;    /* OK to factor out constants */
003807    u8 disableLookaside; /* Number of times lookaside has been disabled */
003808    u8 prepFlags;        /* SQLITE_PREPARE_* flags */
003809    u8 withinRJSubrtn;   /* Nesting level for RIGHT JOIN body subroutines */
003810  #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
003811    u8 earlyCleanup;     /* OOM inside sqlite3ParserAddCleanup() */
003812  #endif
003813  #ifdef SQLITE_DEBUG
003814    u8 ifNotExists;      /* Might be true if IF NOT EXISTS.  Assert()s only */
003815  #endif
003816    int nRangeReg;       /* Size of the temporary register block */
003817    int iRangeReg;       /* First register in temporary register block */
003818    int nErr;            /* Number of errors seen */
003819    int nTab;            /* Number of previously allocated VDBE cursors */
003820    int nMem;            /* Number of memory cells used so far */
003821    int szOpAlloc;       /* Bytes of memory space allocated for Vdbe.aOp[] */
003822    int iSelfTab;        /* Table associated with an index on expr, or negative
003823                         ** of the base register during check-constraint eval */
003824    int nLabel;          /* The *negative* of the number of labels used */
003825    int nLabelAlloc;     /* Number of slots in aLabel */
003826    int *aLabel;         /* Space to hold the labels */
003827    ExprList *pConstExpr;/* Constant expressions */
003828    IndexedExpr *pIdxEpr;/* List of expressions used by active indexes */
003829    IndexedExpr *pIdxPartExpr; /* Exprs constrained by index WHERE clauses */
003830    Token constraintName;/* Name of the constraint currently being parsed */
003831    yDbMask writeMask;   /* Start a write transaction on these databases */
003832    yDbMask cookieMask;  /* Bitmask of schema verified databases */
003833    int regRowid;        /* Register holding rowid of CREATE TABLE entry */
003834    int regRoot;         /* Register holding root page number for new objects */
003835    int nMaxArg;         /* Max args passed to user function by sub-program */
003836    int nSelect;         /* Number of SELECT stmts. Counter for Select.selId */
003837  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
003838    u32 nProgressSteps;  /* xProgress steps taken during sqlite3_prepare() */
003839  #endif
003840  #ifndef SQLITE_OMIT_SHARED_CACHE
003841    int nTableLock;        /* Number of locks in aTableLock */
003842    TableLock *aTableLock; /* Required table locks for shared-cache mode */
003843  #endif
003844    AutoincInfo *pAinc;  /* Information about AUTOINCREMENT counters */
003845    Parse *pToplevel;    /* Parse structure for main program (or NULL) */
003846    Table *pTriggerTab;  /* Table triggers are being coded for */
003847    TriggerPrg *pTriggerPrg;  /* Linked list of coded triggers */
003848    ParseCleanup *pCleanup;   /* List of cleanup operations to run after parse */
003849    union {
003850      int addrCrTab;         /* Address of OP_CreateBtree on CREATE TABLE */
003851      Returning *pReturning; /* The RETURNING clause */
003852    } u1;
003853    u32 oldmask;         /* Mask of old.* columns referenced */
003854    u32 newmask;         /* Mask of new.* columns referenced */
003855    LogEst nQueryLoop;   /* Est number of iterations of a query (10*log2(N)) */
003856    u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */
003857    u8 bReturning;       /* Coding a RETURNING trigger */
003858    u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */
003859    u8 disableTriggers;  /* True to disable triggers */
003860  
003861    /**************************************************************************
003862    ** Fields above must be initialized to zero.  The fields that follow,
003863    ** down to the beginning of the recursive section, do not need to be
003864    ** initialized as they will be set before being used.  The boundary is
003865    ** determined by offsetof(Parse,aTempReg).
003866    **************************************************************************/
003867  
003868    int aTempReg[8];        /* Holding area for temporary registers */
003869    Parse *pOuterParse;     /* Outer Parse object when nested */
003870    Token sNameToken;       /* Token with unqualified schema object name */
003871  
003872    /************************************************************************
003873    ** Above is constant between recursions.  Below is reset before and after
003874    ** each recursion.  The boundary between these two regions is determined
003875    ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
003876    ** first field in the recursive region.
003877    ************************************************************************/
003878  
003879    Token sLastToken;       /* The last token parsed */
003880    ynVar nVar;               /* Number of '?' variables seen in the SQL so far */
003881    u8 iPkSortOrder;          /* ASC or DESC for INTEGER PRIMARY KEY */
003882    u8 explain;               /* True if the EXPLAIN flag is found on the query */
003883    u8 eParseMode;            /* PARSE_MODE_XXX constant */
003884  #ifndef SQLITE_OMIT_VIRTUALTABLE
003885    int nVtabLock;            /* Number of virtual tables to lock */
003886  #endif
003887    int nHeight;              /* Expression tree height of current sub-select */
003888  #ifndef SQLITE_OMIT_EXPLAIN
003889    int addrExplain;          /* Address of current OP_Explain opcode */
003890  #endif
003891    VList *pVList;            /* Mapping between variable names and numbers */
003892    Vdbe *pReprepare;         /* VM being reprepared (sqlite3Reprepare()) */
003893    const char *zTail;        /* All SQL text past the last semicolon parsed */
003894    Table *pNewTable;         /* A table being constructed by CREATE TABLE */
003895    Index *pNewIndex;         /* An index being constructed by CREATE INDEX.
003896                              ** Also used to hold redundant UNIQUE constraints
003897                              ** during a RENAME COLUMN */
003898    Trigger *pNewTrigger;     /* Trigger under construct by a CREATE TRIGGER */
003899    const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
003900  #ifndef SQLITE_OMIT_VIRTUALTABLE
003901    Token sArg;               /* Complete text of a module argument */
003902    Table **apVtabLock;       /* Pointer to virtual tables needing locking */
003903  #endif
003904    With *pWith;              /* Current WITH clause, or NULL */
003905  #ifndef SQLITE_OMIT_ALTERTABLE
003906    RenameToken *pRename;     /* Tokens subject to renaming by ALTER TABLE */
003907  #endif
003908  };
003909  
003910  /* Allowed values for Parse.eParseMode
003911  */
003912  #define PARSE_MODE_NORMAL        0
003913  #define PARSE_MODE_DECLARE_VTAB  1
003914  #define PARSE_MODE_RENAME        2
003915  #define PARSE_MODE_UNMAP         3
003916  
003917  /*
003918  ** Sizes and pointers of various parts of the Parse object.
003919  */
003920  #define PARSE_HDR(X)  (((char*)(X))+offsetof(Parse,zErrMsg))
003921  #define PARSE_HDR_SZ (offsetof(Parse,aTempReg)-offsetof(Parse,zErrMsg)) /* Recursive part w/o aColCache*/
003922  #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken)    /* Recursive part */
003923  #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
003924  #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ)  /* Pointer to tail */
003925  
003926  /*
003927  ** Return true if currently inside an sqlite3_declare_vtab() call.
003928  */
003929  #ifdef SQLITE_OMIT_VIRTUALTABLE
003930    #define IN_DECLARE_VTAB 0
003931  #else
003932    #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)
003933  #endif
003934  
003935  #if defined(SQLITE_OMIT_ALTERTABLE)
003936    #define IN_RENAME_OBJECT 0
003937  #else
003938    #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)
003939  #endif
003940  
003941  #if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE)
003942    #define IN_SPECIAL_PARSE 0
003943  #else
003944    #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)
003945  #endif
003946  
003947  /*
003948  ** An instance of the following structure can be declared on a stack and used
003949  ** to save the Parse.zAuthContext value so that it can be restored later.
003950  */
003951  struct AuthContext {
003952    const char *zAuthContext;   /* Put saved Parse.zAuthContext here */
003953    Parse *pParse;              /* The Parse structure */
003954  };
003955  
003956  /*
003957  ** Bitfield flags for P5 value in various opcodes.
003958  **
003959  ** Value constraints (enforced via assert()):
003960  **    OPFLAG_LENGTHARG    == SQLITE_FUNC_LENGTH
003961  **    OPFLAG_TYPEOFARG    == SQLITE_FUNC_TYPEOF
003962  **    OPFLAG_BULKCSR      == BTREE_BULKLOAD
003963  **    OPFLAG_SEEKEQ       == BTREE_SEEK_EQ
003964  **    OPFLAG_FORDELETE    == BTREE_FORDELETE
003965  **    OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
003966  **    OPFLAG_AUXDELETE    == BTREE_AUXDELETE
003967  */
003968  #define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */
003969                                       /* Also used in P2 (not P5) of OP_Delete */
003970  #define OPFLAG_NOCHNG        0x01    /* OP_VColumn nochange for UPDATE */
003971  #define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */
003972  #define OPFLAG_LASTROWID     0x20    /* Set to update db->lastRowid */
003973  #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
003974  #define OPFLAG_APPEND        0x08    /* This is likely to be an append */
003975  #define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */
003976  #define OPFLAG_ISNOOP        0x40    /* OP_Delete does pre-update-hook only */
003977  #define OPFLAG_LENGTHARG     0x40    /* OP_Column only used for length() */
003978  #define OPFLAG_TYPEOFARG     0x80    /* OP_Column only used for typeof() */
003979  #define OPFLAG_BYTELENARG    0xc0    /* OP_Column only for octet_length() */
003980  #define OPFLAG_BULKCSR       0x01    /* OP_Open** used to open bulk cursor */
003981  #define OPFLAG_SEEKEQ        0x02    /* OP_Open** cursor uses EQ seek only */
003982  #define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */
003983  #define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */
003984  #define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
003985  #define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete/Insert: save cursor pos */
003986  #define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */
003987  #define OPFLAG_NOCHNG_MAGIC  0x6d    /* OP_MakeRecord: serialtype 10 is ok */
003988  #define OPFLAG_PREFORMAT     0x80    /* OP_Insert uses preformatted cell */
003989  
003990  /*
003991  ** Each trigger present in the database schema is stored as an instance of
003992  ** struct Trigger.
003993  **
003994  ** Pointers to instances of struct Trigger are stored in two ways.
003995  ** 1. In the "trigHash" hash table (part of the sqlite3* that represents the
003996  **    database). This allows Trigger structures to be retrieved by name.
003997  ** 2. All triggers associated with a single table form a linked list, using the
003998  **    pNext member of struct Trigger. A pointer to the first element of the
003999  **    linked list is stored as the "pTrigger" member of the associated
004000  **    struct Table.
004001  **
004002  ** The "step_list" member points to the first element of a linked list
004003  ** containing the SQL statements specified as the trigger program.
004004  */
004005  struct Trigger {
004006    char *zName;            /* The name of the trigger                        */
004007    char *table;            /* The table or view to which the trigger applies */
004008    u8 op;                  /* One of TK_DELETE, TK_UPDATE, TK_INSERT         */
004009    u8 tr_tm;               /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
004010    u8 bReturning;          /* This trigger implements a RETURNING clause */
004011    Expr *pWhen;            /* The WHEN clause of the expression (may be NULL) */
004012    IdList *pColumns;       /* If this is an UPDATE OF <column-list> trigger,
004013                               the <column-list> is stored here */
004014    Schema *pSchema;        /* Schema containing the trigger */
004015    Schema *pTabSchema;     /* Schema containing the table */
004016    TriggerStep *step_list; /* Link list of trigger program steps             */
004017    Trigger *pNext;         /* Next trigger associated with the table */
004018  };
004019  
004020  /*
004021  ** A trigger is either a BEFORE or an AFTER trigger.  The following constants
004022  ** determine which.
004023  **
004024  ** If there are multiple triggers, you might of some BEFORE and some AFTER.
004025  ** In that cases, the constants below can be ORed together.
004026  */
004027  #define TRIGGER_BEFORE  1
004028  #define TRIGGER_AFTER   2
004029  
004030  /*
004031  ** An instance of struct TriggerStep is used to store a single SQL statement
004032  ** that is a part of a trigger-program.
004033  **
004034  ** Instances of struct TriggerStep are stored in a singly linked list (linked
004035  ** using the "pNext" member) referenced by the "step_list" member of the
004036  ** associated struct Trigger instance. The first element of the linked list is
004037  ** the first step of the trigger-program.
004038  **
004039  ** The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
004040  ** "SELECT" statement. The meanings of the other members is determined by the
004041  ** value of "op" as follows:
004042  **
004043  ** (op == TK_INSERT)
004044  ** orconf    -> stores the ON CONFLICT algorithm
004045  ** pSelect   -> The content to be inserted - either a SELECT statement or
004046  **              a VALUES clause.
004047  ** zTarget   -> Dequoted name of the table to insert into.
004048  ** pIdList   -> If this is an INSERT INTO ... (<column-names>) VALUES ...
004049  **              statement, then this stores the column-names to be
004050  **              inserted into.
004051  ** pUpsert   -> The ON CONFLICT clauses for an Upsert
004052  **
004053  ** (op == TK_DELETE)
004054  ** zTarget   -> Dequoted name of the table to delete from.
004055  ** pWhere    -> The WHERE clause of the DELETE statement if one is specified.
004056  **              Otherwise NULL.
004057  **
004058  ** (op == TK_UPDATE)
004059  ** zTarget   -> Dequoted name of the table to update.
004060  ** pWhere    -> The WHERE clause of the UPDATE statement if one is specified.
004061  **              Otherwise NULL.
004062  ** pExprList -> A list of the columns to update and the expressions to update
004063  **              them to. See sqlite3Update() documentation of "pChanges"
004064  **              argument.
004065  **
004066  ** (op == TK_SELECT)
004067  ** pSelect   -> The SELECT statement
004068  **
004069  ** (op == TK_RETURNING)
004070  ** pExprList -> The list of expressions that follow the RETURNING keyword.
004071  **
004072  */
004073  struct TriggerStep {
004074    u8 op;               /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT,
004075                         ** or TK_RETURNING */
004076    u8 orconf;           /* OE_Rollback etc. */
004077    Trigger *pTrig;      /* The trigger that this step is a part of */
004078    Select *pSelect;     /* SELECT statement or RHS of INSERT INTO SELECT ... */
004079    char *zTarget;       /* Target table for DELETE, UPDATE, INSERT */
004080    SrcList *pFrom;      /* FROM clause for UPDATE statement (if any) */
004081    Expr *pWhere;        /* The WHERE clause for DELETE or UPDATE steps */
004082    ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */
004083    IdList *pIdList;     /* Column names for INSERT */
004084    Upsert *pUpsert;     /* Upsert clauses on an INSERT */
004085    char *zSpan;         /* Original SQL text of this command */
004086    TriggerStep *pNext;  /* Next in the link-list */
004087    TriggerStep *pLast;  /* Last element in link-list. Valid for 1st elem only */
004088  };
004089  
004090  /*
004091  ** Information about a RETURNING clause
004092  */
004093  struct Returning {
004094    Parse *pParse;        /* The parse that includes the RETURNING clause */
004095    ExprList *pReturnEL;  /* List of expressions to return */
004096    Trigger retTrig;      /* The transient trigger that implements RETURNING */
004097    TriggerStep retTStep; /* The trigger step */
004098    int iRetCur;          /* Transient table holding RETURNING results */
004099    int nRetCol;          /* Number of in pReturnEL after expansion */
004100    int iRetReg;          /* Register array for holding a row of RETURNING */
004101    char zName[40];       /* Name of trigger: "sqlite_returning_%p" */
004102  };
004103  
004104  /*
004105  ** An objected used to accumulate the text of a string where we
004106  ** do not necessarily know how big the string will be in the end.
004107  */
004108  struct sqlite3_str {
004109    sqlite3 *db;         /* Optional database for lookaside.  Can be NULL */
004110    char *zText;         /* The string collected so far */
004111    u32  nAlloc;         /* Amount of space allocated in zText */
004112    u32  mxAlloc;        /* Maximum allowed allocation.  0 for no malloc usage */
004113    u32  nChar;          /* Length of the string so far */
004114    u8   accError;       /* SQLITE_NOMEM or SQLITE_TOOBIG */
004115    u8   printfFlags;    /* SQLITE_PRINTF flags below */
004116  };
004117  #define SQLITE_PRINTF_INTERNAL 0x01  /* Internal-use-only converters allowed */
004118  #define SQLITE_PRINTF_SQLFUNC  0x02  /* SQL function arguments to VXPrintf */
004119  #define SQLITE_PRINTF_MALLOCED 0x04  /* True if xText is allocated space */
004120  
004121  #define isMalloced(X)  (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
004122  
004123  /*
004124  ** The following object is the header for an "RCStr" or "reference-counted
004125  ** string".  An RCStr is passed around and used like any other char*
004126  ** that has been dynamically allocated.  The important interface
004127  ** differences:
004128  **
004129  **   1.  RCStr strings are reference counted.  They are deallocated
004130  **       when the reference count reaches zero.
004131  **
004132  **   2.  Use sqlite3RCStrUnref() to free an RCStr string rather than
004133  **       sqlite3_free()
004134  **
004135  **   3.  Make a (read-only) copy of a read-only RCStr string using
004136  **       sqlite3RCStrRef().
004137  **
004138  ** "String" is in the name, but an RCStr object can also be used to hold
004139  ** binary data.
004140  */
004141  struct RCStr {
004142    u64 nRCRef;            /* Number of references */
004143    /* Total structure size should be a multiple of 8 bytes for alignment */
004144  };
004145  
004146  /*
004147  ** A pointer to this structure is used to communicate information
004148  ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
004149  */
004150  typedef struct {
004151    sqlite3 *db;        /* The database being initialized */
004152    char **pzErrMsg;    /* Error message stored here */
004153    int iDb;            /* 0 for main database.  1 for TEMP, 2.. for ATTACHed */
004154    int rc;             /* Result code stored here */
004155    u32 mInitFlags;     /* Flags controlling error messages */
004156    u32 nInitRow;       /* Number of rows processed */
004157    Pgno mxPage;        /* Maximum page number.  0 for no limit. */
004158  } InitData;
004159  
004160  /*
004161  ** Allowed values for mInitFlags
004162  */
004163  #define INITFLAG_AlterMask     0x0003  /* Types of ALTER */
004164  #define INITFLAG_AlterRename   0x0001  /* Reparse after a RENAME */
004165  #define INITFLAG_AlterDrop     0x0002  /* Reparse after a DROP COLUMN */
004166  #define INITFLAG_AlterAdd      0x0003  /* Reparse after an ADD COLUMN */
004167  
004168  /* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
004169  ** on debug-builds of the CLI using ".testctrl tune ID VALUE".  Tuning
004170  ** parameters are for temporary use during development, to help find
004171  ** optimal values for parameters in the query planner.  The should not
004172  ** be used on trunk check-ins.  They are a temporary mechanism available
004173  ** for transient development builds only.
004174  **
004175  ** Tuning parameters are numbered starting with 1.
004176  */
004177  #define SQLITE_NTUNE  6             /* Should be zero for all trunk check-ins */
004178  #ifdef SQLITE_DEBUG
004179  # define Tuning(X)  (sqlite3Config.aTune[(X)-1])
004180  #else
004181  # define Tuning(X)  0
004182  #endif
004183  
004184  /*
004185  ** Structure containing global configuration data for the SQLite library.
004186  **
004187  ** This structure also contains some state information.
004188  */
004189  struct Sqlite3Config {
004190    int bMemstat;                     /* True to enable memory status */
004191    u8 bCoreMutex;                    /* True to enable core mutexing */
004192    u8 bFullMutex;                    /* True to enable full mutexing */
004193    u8 bOpenUri;                      /* True to interpret filenames as URIs */
004194    u8 bUseCis;                       /* Use covering indices for full-scans */
004195    u8 bSmallMalloc;                  /* Avoid large memory allocations if true */
004196    u8 bExtraSchemaChecks;            /* Verify type,name,tbl_name in schema */
004197    u8 bUseLongDouble;                /* Make use of long double */
004198  #ifdef SQLITE_DEBUG
004199    u8 bJsonSelfcheck;                /* Double-check JSON parsing */
004200  #endif
004201    int mxStrlen;                     /* Maximum string length */
004202    int neverCorrupt;                 /* Database is always well-formed */
004203    int szLookaside;                  /* Default lookaside buffer size */
004204    int nLookaside;                   /* Default lookaside buffer count */
004205    int nStmtSpill;                   /* Stmt-journal spill-to-disk threshold */
004206    sqlite3_mem_methods m;            /* Low-level memory allocation interface */
004207    sqlite3_mutex_methods mutex;      /* Low-level mutex interface */
004208    sqlite3_pcache_methods2 pcache2;  /* Low-level page-cache interface */
004209    void *pHeap;                      /* Heap storage space */
004210    int nHeap;                        /* Size of pHeap[] */
004211    int mnReq, mxReq;                 /* Min and max heap requests sizes */
004212    sqlite3_int64 szMmap;             /* mmap() space per open file */
004213    sqlite3_int64 mxMmap;             /* Maximum value for szMmap */
004214    void *pPage;                      /* Page cache memory */
004215    int szPage;                       /* Size of each page in pPage[] */
004216    int nPage;                        /* Number of pages in pPage[] */
004217    int mxParserStack;                /* maximum depth of the parser stack */
004218    int sharedCacheEnabled;           /* true if shared-cache mode enabled */
004219    u32 szPma;                        /* Maximum Sorter PMA size */
004220    /* The above might be initialized to non-zero.  The following need to always
004221    ** initially be zero, however. */
004222    int isInit;                       /* True after initialization has finished */
004223    int inProgress;                   /* True while initialization in progress */
004224    int isMutexInit;                  /* True after mutexes are initialized */
004225    int isMallocInit;                 /* True after malloc is initialized */
004226    int isPCacheInit;                 /* True after malloc is initialized */
004227    int nRefInitMutex;                /* Number of users of pInitMutex */
004228    sqlite3_mutex *pInitMutex;        /* Mutex used by sqlite3_initialize() */
004229    void (*xLog)(void*,int,const char*); /* Function for logging */
004230    void *pLogArg;                       /* First argument to xLog() */
004231  #ifdef SQLITE_ENABLE_SQLLOG
004232    void(*xSqllog)(void*,sqlite3*,const char*, int);
004233    void *pSqllogArg;
004234  #endif
004235  #ifdef SQLITE_VDBE_COVERAGE
004236    /* The following callback (if not NULL) is invoked on every VDBE branch
004237    ** operation.  Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
004238    */
004239    void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */
004240    void *pVdbeBranchArg;                                     /* 1st argument */
004241  #endif
004242  #ifndef SQLITE_OMIT_DESERIALIZE
004243    sqlite3_int64 mxMemdbSize;        /* Default max memdb size */
004244  #endif
004245  #ifndef SQLITE_UNTESTABLE
004246    int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
004247  #endif
004248    int bLocaltimeFault;              /* True to fail localtime() calls */
004249    int (*xAltLocaltime)(const void*,void*); /* Alternative localtime() routine */
004250    int iOnceResetThreshold;          /* When to reset OP_Once counters */
004251    u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
004252    unsigned int iPrngSeed;           /* Alternative fixed seed for the PRNG */
004253    /* vvvv--- must be last ---vvv */
004254  #ifdef SQLITE_DEBUG
004255    sqlite3_int64 aTune[SQLITE_NTUNE]; /* Tuning parameters */
004256  #endif
004257  };
004258  
004259  /*
004260  ** This macro is used inside of assert() statements to indicate that
004261  ** the assert is only valid on a well-formed database.  Instead of:
004262  **
004263  **     assert( X );
004264  **
004265  ** One writes:
004266  **
004267  **     assert( X || CORRUPT_DB );
004268  **
004269  ** CORRUPT_DB is true during normal operation.  CORRUPT_DB does not indicate
004270  ** that the database is definitely corrupt, only that it might be corrupt.
004271  ** For most test cases, CORRUPT_DB is set to false using a special
004272  ** sqlite3_test_control().  This enables assert() statements to prove
004273  ** things that are always true for well-formed databases.
004274  */
004275  #define CORRUPT_DB  (sqlite3Config.neverCorrupt==0)
004276  
004277  /*
004278  ** Context pointer passed down through the tree-walk.
004279  */
004280  struct Walker {
004281    Parse *pParse;                            /* Parser context.  */
004282    int (*xExprCallback)(Walker*, Expr*);     /* Callback for expressions */
004283    int (*xSelectCallback)(Walker*,Select*);  /* Callback for SELECTs */
004284    void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */
004285    int walkerDepth;                          /* Number of subqueries */
004286    u16 eCode;                                /* A small processing code */
004287    u16 mWFlags;                              /* Use-dependent flags */
004288    union {                                   /* Extra data for callback */
004289      NameContext *pNC;                         /* Naming context */
004290      int n;                                    /* A counter */
004291      int iCur;                                 /* A cursor number */
004292      SrcList *pSrcList;                        /* FROM clause */
004293      struct CCurHint *pCCurHint;               /* Used by codeCursorHint() */
004294      struct RefSrcList *pRefSrcList;           /* sqlite3ReferencesSrcList() */
004295      int *aiCol;                               /* array of column indexes */
004296      struct IdxCover *pIdxCover;               /* Check for index coverage */
004297      ExprList *pGroupBy;                       /* GROUP BY clause */
004298      Select *pSelect;                          /* HAVING to WHERE clause ctx */
004299      struct WindowRewrite *pRewrite;           /* Window rewrite context */
004300      struct WhereConst *pConst;                /* WHERE clause constants */
004301      struct RenameCtx *pRename;                /* RENAME COLUMN context */
004302      struct Table *pTab;                       /* Table of generated column */
004303      struct CoveringIndexCheck *pCovIdxCk;     /* Check for covering index */
004304      SrcItem *pSrcItem;                        /* A single FROM clause item */
004305      DbFixer *pFix;                            /* See sqlite3FixSelect() */
004306      Mem *aMem;                                /* See sqlite3BtreeCursorHint() */
004307    } u;
004308  };
004309  
004310  /*
004311  ** The following structure contains information used by the sqliteFix...
004312  ** routines as they walk the parse tree to make database references
004313  ** explicit.
004314  */
004315  struct DbFixer {
004316    Parse *pParse;      /* The parsing context.  Error messages written here */
004317    Walker w;           /* Walker object */
004318    Schema *pSchema;    /* Fix items to this schema */
004319    u8 bTemp;           /* True for TEMP schema entries */
004320    const char *zDb;    /* Make sure all objects are contained in this database */
004321    const char *zType;  /* Type of the container - used for error messages */
004322    const Token *pName; /* Name of the container - used for error messages */
004323  };
004324  
004325  /* Forward declarations */
004326  int sqlite3WalkExpr(Walker*, Expr*);
004327  int sqlite3WalkExprNN(Walker*, Expr*);
004328  int sqlite3WalkExprList(Walker*, ExprList*);
004329  int sqlite3WalkSelect(Walker*, Select*);
004330  int sqlite3WalkSelectExpr(Walker*, Select*);
004331  int sqlite3WalkSelectFrom(Walker*, Select*);
004332  int sqlite3ExprWalkNoop(Walker*, Expr*);
004333  int sqlite3SelectWalkNoop(Walker*, Select*);
004334  int sqlite3SelectWalkFail(Walker*, Select*);
004335  int sqlite3WalkerDepthIncrease(Walker*,Select*);
004336  void sqlite3WalkerDepthDecrease(Walker*,Select*);
004337  void sqlite3WalkWinDefnDummyCallback(Walker*,Select*);
004338  
004339  #ifdef SQLITE_DEBUG
004340  void sqlite3SelectWalkAssert2(Walker*, Select*);
004341  #endif
004342  
004343  #ifndef SQLITE_OMIT_CTE
004344  void sqlite3SelectPopWith(Walker*, Select*);
004345  #else
004346  # define sqlite3SelectPopWith 0
004347  #endif
004348  
004349  /*
004350  ** Return code from the parse-tree walking primitives and their
004351  ** callbacks.
004352  */
004353  #define WRC_Continue    0   /* Continue down into children */
004354  #define WRC_Prune       1   /* Omit children but continue walking siblings */
004355  #define WRC_Abort       2   /* Abandon the tree walk */
004356  
004357  /*
004358  ** A single common table expression
004359  */
004360  struct Cte {
004361    char *zName;            /* Name of this CTE */
004362    ExprList *pCols;        /* List of explicit column names, or NULL */
004363    Select *pSelect;        /* The definition of this CTE */
004364    const char *zCteErr;    /* Error message for circular references */
004365    CteUse *pUse;           /* Usage information for this CTE */
004366    u8 eM10d;               /* The MATERIALIZED flag */
004367  };
004368  
004369  /*
004370  ** Allowed values for the materialized flag (eM10d):
004371  */
004372  #define M10d_Yes       0  /* AS MATERIALIZED */
004373  #define M10d_Any       1  /* Not specified.  Query planner's choice */
004374  #define M10d_No        2  /* AS NOT MATERIALIZED */
004375  
004376  /*
004377  ** An instance of the With object represents a WITH clause containing
004378  ** one or more CTEs (common table expressions).
004379  */
004380  struct With {
004381    int nCte;               /* Number of CTEs in the WITH clause */
004382    int bView;              /* Belongs to the outermost Select of a view */
004383    With *pOuter;           /* Containing WITH clause, or NULL */
004384    Cte a[1];               /* For each CTE in the WITH clause.... */
004385  };
004386  
004387  /*
004388  ** The Cte object is not guaranteed to persist for the entire duration
004389  ** of code generation.  (The query flattener or other parser tree
004390  ** edits might delete it.)  The following object records information
004391  ** about each Common Table Expression that must be preserved for the
004392  ** duration of the parse.
004393  **
004394  ** The CteUse objects are freed using sqlite3ParserAddCleanup() rather
004395  ** than sqlite3SelectDelete(), which is what enables them to persist
004396  ** until the end of code generation.
004397  */
004398  struct CteUse {
004399    int nUse;              /* Number of users of this CTE */
004400    int addrM9e;           /* Start of subroutine to compute materialization */
004401    int regRtn;            /* Return address register for addrM9e subroutine */
004402    int iCur;              /* Ephemeral table holding the materialization */
004403    LogEst nRowEst;        /* Estimated number of rows in the table */
004404    u8 eM10d;              /* The MATERIALIZED flag */
004405  };
004406  
004407  
004408  /* Client data associated with sqlite3_set_clientdata() and
004409  ** sqlite3_get_clientdata().
004410  */
004411  struct DbClientData {
004412    DbClientData *pNext;        /* Next in a linked list */
004413    void *pData;                /* The data */
004414    void (*xDestructor)(void*); /* Destructor.  Might be NULL */
004415    char zName[1];              /* Name of this client data. MUST BE LAST */
004416  };
004417  
004418  #ifdef SQLITE_DEBUG
004419  /*
004420  ** An instance of the TreeView object is used for printing the content of
004421  ** data structures on sqlite3DebugPrintf() using a tree-like view.
004422  */
004423  struct TreeView {
004424    int iLevel;             /* Which level of the tree we are on */
004425    u8  bLine[100];         /* Draw vertical in column i if bLine[i] is true */
004426  };
004427  #endif /* SQLITE_DEBUG */
004428  
004429  /*
004430  ** This object is used in various ways, most (but not all) related to window
004431  ** functions.
004432  **
004433  **   (1) A single instance of this structure is attached to the
004434  **       the Expr.y.pWin field for each window function in an expression tree.
004435  **       This object holds the information contained in the OVER clause,
004436  **       plus additional fields used during code generation.
004437  **
004438  **   (2) All window functions in a single SELECT form a linked-list
004439  **       attached to Select.pWin.  The Window.pFunc and Window.pExpr
004440  **       fields point back to the expression that is the window function.
004441  **
004442  **   (3) The terms of the WINDOW clause of a SELECT are instances of this
004443  **       object on a linked list attached to Select.pWinDefn.
004444  **
004445  **   (4) For an aggregate function with a FILTER clause, an instance
004446  **       of this object is stored in Expr.y.pWin with eFrmType set to
004447  **       TK_FILTER. In this case the only field used is Window.pFilter.
004448  **
004449  ** The uses (1) and (2) are really the same Window object that just happens
004450  ** to be accessible in two different ways.  Use case (3) are separate objects.
004451  */
004452  struct Window {
004453    char *zName;            /* Name of window (may be NULL) */
004454    char *zBase;            /* Name of base window for chaining (may be NULL) */
004455    ExprList *pPartition;   /* PARTITION BY clause */
004456    ExprList *pOrderBy;     /* ORDER BY clause */
004457    u8 eFrmType;            /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */
004458    u8 eStart;              /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
004459    u8 eEnd;                /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
004460    u8 bImplicitFrame;      /* True if frame was implicitly specified */
004461    u8 eExclude;            /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */
004462    Expr *pStart;           /* Expression for "<expr> PRECEDING" */
004463    Expr *pEnd;             /* Expression for "<expr> FOLLOWING" */
004464    Window **ppThis;        /* Pointer to this object in Select.pWin list */
004465    Window *pNextWin;       /* Next window function belonging to this SELECT */
004466    Expr *pFilter;          /* The FILTER expression */
004467    FuncDef *pWFunc;        /* The function */
004468    int iEphCsr;            /* Partition buffer or Peer buffer */
004469    int regAccum;           /* Accumulator */
004470    int regResult;          /* Interim result */
004471    int csrApp;             /* Function cursor (used by min/max) */
004472    int regApp;             /* Function register (also used by min/max) */
004473    int regPart;            /* Array of registers for PARTITION BY values */
004474    Expr *pOwner;           /* Expression object this window is attached to */
004475    int nBufferCol;         /* Number of columns in buffer table */
004476    int iArgCol;            /* Offset of first argument for this function */
004477    int regOne;             /* Register containing constant value 1 */
004478    int regStartRowid;
004479    int regEndRowid;
004480    u8 bExprArgs;           /* Defer evaluation of window function arguments
004481                            ** due to the SQLITE_SUBTYPE flag */
004482  };
004483  
004484  #ifndef SQLITE_OMIT_WINDOWFUNC
004485  void sqlite3WindowDelete(sqlite3*, Window*);
004486  void sqlite3WindowUnlinkFromSelect(Window*);
004487  void sqlite3WindowListDelete(sqlite3 *db, Window *p);
004488  Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
004489  void sqlite3WindowAttach(Parse*, Expr*, Window*);
004490  void sqlite3WindowLink(Select *pSel, Window *pWin);
004491  int sqlite3WindowCompare(const Parse*, const Window*, const Window*, int);
004492  void sqlite3WindowCodeInit(Parse*, Select*);
004493  void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int);
004494  int sqlite3WindowRewrite(Parse*, Select*);
004495  void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*);
004496  Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p);
004497  Window *sqlite3WindowListDup(sqlite3 *db, Window *p);
004498  void sqlite3WindowFunctions(void);
004499  void sqlite3WindowChain(Parse*, Window*, Window*);
004500  Window *sqlite3WindowAssemble(Parse*, Window*, ExprList*, ExprList*, Token*);
004501  #else
004502  # define sqlite3WindowDelete(a,b)
004503  # define sqlite3WindowFunctions()
004504  # define sqlite3WindowAttach(a,b,c)
004505  #endif
004506  
004507  /*
004508  ** Assuming zIn points to the first byte of a UTF-8 character,
004509  ** advance zIn to point to the first byte of the next UTF-8 character.
004510  */
004511  #define SQLITE_SKIP_UTF8(zIn) {                        \
004512    if( (*(zIn++))>=0xc0 ){                              \
004513      while( (*zIn & 0xc0)==0x80 ){ zIn++; }             \
004514    }                                                    \
004515  }
004516  
004517  /*
004518  ** The SQLITE_*_BKPT macros are substitutes for the error codes with
004519  ** the same name but without the _BKPT suffix.  These macros invoke
004520  ** routines that report the line-number on which the error originated
004521  ** using sqlite3_log().  The routines also provide a convenient place
004522  ** to set a debugger breakpoint.
004523  */
004524  int sqlite3ReportError(int iErr, int lineno, const char *zType);
004525  int sqlite3CorruptError(int);
004526  int sqlite3MisuseError(int);
004527  int sqlite3CantopenError(int);
004528  #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
004529  #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
004530  #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
004531  #ifdef SQLITE_DEBUG
004532    int sqlite3NomemError(int);
004533    int sqlite3IoerrnomemError(int);
004534  # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
004535  # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
004536  #else
004537  # define SQLITE_NOMEM_BKPT SQLITE_NOMEM
004538  # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
004539  #endif
004540  #if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO)
004541    int sqlite3CorruptPgnoError(int,Pgno);
004542  # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P))
004543  #else
004544  # define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__)
004545  #endif
004546  
004547  /*
004548  ** FTS3 and FTS4 both require virtual table support
004549  */
004550  #if defined(SQLITE_OMIT_VIRTUALTABLE)
004551  # undef SQLITE_ENABLE_FTS3
004552  # undef SQLITE_ENABLE_FTS4
004553  #endif
004554  
004555  /*
004556  ** FTS4 is really an extension for FTS3.  It is enabled using the
004557  ** SQLITE_ENABLE_FTS3 macro.  But to avoid confusion we also call
004558  ** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
004559  */
004560  #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
004561  # define SQLITE_ENABLE_FTS3 1
004562  #endif
004563  
004564  /*
004565  ** The ctype.h header is needed for non-ASCII systems.  It is also
004566  ** needed by FTS3 when FTS3 is included in the amalgamation.
004567  */
004568  #if !defined(SQLITE_ASCII) || \
004569      (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
004570  # include <ctype.h>
004571  #endif
004572  
004573  /*
004574  ** The following macros mimic the standard library functions toupper(),
004575  ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
004576  ** sqlite versions only work for ASCII characters, regardless of locale.
004577  */
004578  #ifdef SQLITE_ASCII
004579  # define sqlite3Toupper(x)  ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
004580  # define sqlite3Isspace(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
004581  # define sqlite3Isalnum(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
004582  # define sqlite3Isalpha(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
004583  # define sqlite3Isdigit(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
004584  # define sqlite3Isxdigit(x)  (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
004585  # define sqlite3Tolower(x)   (sqlite3UpperToLower[(unsigned char)(x)])
004586  # define sqlite3Isquote(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
004587  # define sqlite3JsonId1(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x42)
004588  # define sqlite3JsonId2(x)   (sqlite3CtypeMap[(unsigned char)(x)]&0x46)
004589  #else
004590  # define sqlite3Toupper(x)   toupper((unsigned char)(x))
004591  # define sqlite3Isspace(x)   isspace((unsigned char)(x))
004592  # define sqlite3Isalnum(x)   isalnum((unsigned char)(x))
004593  # define sqlite3Isalpha(x)   isalpha((unsigned char)(x))
004594  # define sqlite3Isdigit(x)   isdigit((unsigned char)(x))
004595  # define sqlite3Isxdigit(x)  isxdigit((unsigned char)(x))
004596  # define sqlite3Tolower(x)   tolower((unsigned char)(x))
004597  # define sqlite3Isquote(x)   ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
004598  # define sqlite3JsonId1(x)   (sqlite3IsIdChar(x)&&(x)<'0')
004599  # define sqlite3JsonId2(x)   sqlite3IsIdChar(x)
004600  #endif
004601  int sqlite3IsIdChar(u8);
004602  
004603  /*
004604  ** Internal function prototypes
004605  */
004606  int sqlite3StrICmp(const char*,const char*);
004607  int sqlite3Strlen30(const char*);
004608  #define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff)
004609  char *sqlite3ColumnType(Column*,char*);
004610  #define sqlite3StrNICmp sqlite3_strnicmp
004611  
004612  int sqlite3MallocInit(void);
004613  void sqlite3MallocEnd(void);
004614  void *sqlite3Malloc(u64);
004615  void *sqlite3MallocZero(u64);
004616  void *sqlite3DbMallocZero(sqlite3*, u64);
004617  void *sqlite3DbMallocRaw(sqlite3*, u64);
004618  void *sqlite3DbMallocRawNN(sqlite3*, u64);
004619  char *sqlite3DbStrDup(sqlite3*,const char*);
004620  char *sqlite3DbStrNDup(sqlite3*,const char*, u64);
004621  char *sqlite3DbSpanDup(sqlite3*,const char*,const char*);
004622  void *sqlite3Realloc(void*, u64);
004623  void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64);
004624  void *sqlite3DbRealloc(sqlite3 *, void *, u64);
004625  void sqlite3DbFree(sqlite3*, void*);
004626  void sqlite3DbFreeNN(sqlite3*, void*);
004627  void sqlite3DbNNFreeNN(sqlite3*, void*);
004628  int sqlite3MallocSize(const void*);
004629  int sqlite3DbMallocSize(sqlite3*, const void*);
004630  void *sqlite3PageMalloc(int);
004631  void sqlite3PageFree(void*);
004632  void sqlite3MemSetDefault(void);
004633  #ifndef SQLITE_UNTESTABLE
004634  void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
004635  #endif
004636  int sqlite3HeapNearlyFull(void);
004637  
004638  /*
004639  ** On systems with ample stack space and that support alloca(), make
004640  ** use of alloca() to obtain space for large automatic objects.  By default,
004641  ** obtain space from malloc().
004642  **
004643  ** The alloca() routine never returns NULL.  This will cause code paths
004644  ** that deal with sqlite3StackAlloc() failures to be unreachable.
004645  */
004646  #ifdef SQLITE_USE_ALLOCA
004647  # define sqlite3StackAllocRaw(D,N)   alloca(N)
004648  # define sqlite3StackAllocRawNN(D,N) alloca(N)
004649  # define sqlite3StackFree(D,P)
004650  # define sqlite3StackFreeNN(D,P)
004651  #else
004652  # define sqlite3StackAllocRaw(D,N)   sqlite3DbMallocRaw(D,N)
004653  # define sqlite3StackAllocRawNN(D,N) sqlite3DbMallocRawNN(D,N)
004654  # define sqlite3StackFree(D,P)       sqlite3DbFree(D,P)
004655  # define sqlite3StackFreeNN(D,P)     sqlite3DbFreeNN(D,P)
004656  #endif
004657  
004658  /* Do not allow both MEMSYS5 and MEMSYS3 to be defined together.  If they
004659  ** are, disable MEMSYS3
004660  */
004661  #ifdef SQLITE_ENABLE_MEMSYS5
004662  const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
004663  #undef SQLITE_ENABLE_MEMSYS3
004664  #endif
004665  #ifdef SQLITE_ENABLE_MEMSYS3
004666  const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
004667  #endif
004668  
004669  
004670  #ifndef SQLITE_MUTEX_OMIT
004671    sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
004672    sqlite3_mutex_methods const *sqlite3NoopMutex(void);
004673    sqlite3_mutex *sqlite3MutexAlloc(int);
004674    int sqlite3MutexInit(void);
004675    int sqlite3MutexEnd(void);
004676  #endif
004677  #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
004678    void sqlite3MemoryBarrier(void);
004679  #else
004680  # define sqlite3MemoryBarrier()
004681  #endif
004682  
004683  sqlite3_int64 sqlite3StatusValue(int);
004684  void sqlite3StatusUp(int, int);
004685  void sqlite3StatusDown(int, int);
004686  void sqlite3StatusHighwater(int, int);
004687  int sqlite3LookasideUsed(sqlite3*,int*);
004688  
004689  /* Access to mutexes used by sqlite3_status() */
004690  sqlite3_mutex *sqlite3Pcache1Mutex(void);
004691  sqlite3_mutex *sqlite3MallocMutex(void);
004692  
004693  #if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT)
004694  void sqlite3MutexWarnOnContention(sqlite3_mutex*);
004695  #else
004696  # define sqlite3MutexWarnOnContention(x)
004697  #endif
004698  
004699  #ifndef SQLITE_OMIT_FLOATING_POINT
004700  # define EXP754 (((u64)0x7ff)<<52)
004701  # define MAN754 ((((u64)1)<<52)-1)
004702  # define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)
004703    int sqlite3IsNaN(double);
004704  #else
004705  # define IsNaN(X)         0
004706  # define sqlite3IsNaN(X)  0
004707  #endif
004708  
004709  /*
004710  ** An instance of the following structure holds information about SQL
004711  ** functions arguments that are the parameters to the printf() function.
004712  */
004713  struct PrintfArguments {
004714    int nArg;                /* Total number of arguments */
004715    int nUsed;               /* Number of arguments used so far */
004716    sqlite3_value **apArg;   /* The argument values */
004717  };
004718  
004719  /*
004720  ** An instance of this object receives the decoding of a floating point
004721  ** value into an approximate decimal representation.
004722  */
004723  struct FpDecode {
004724    char sign;           /* '+' or '-' */
004725    char isSpecial;      /* 1: Infinity  2: NaN */
004726    int n;               /* Significant digits in the decode */
004727    int iDP;             /* Location of the decimal point */
004728    char *z;             /* Start of significant digits */
004729    char zBuf[24];       /* Storage for significant digits */
004730  };
004731  
004732  void sqlite3FpDecode(FpDecode*,double,int,int);
004733  char *sqlite3MPrintf(sqlite3*,const char*, ...);
004734  char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
004735  #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
004736    void sqlite3DebugPrintf(const char*, ...);
004737  #endif
004738  #if defined(SQLITE_TEST)
004739    void *sqlite3TestTextToPtr(const char*);
004740  #endif
004741  
004742  #if defined(SQLITE_DEBUG)
004743    void sqlite3TreeViewLine(TreeView*, const char *zFormat, ...);
004744    void sqlite3TreeViewExpr(TreeView*, const Expr*, u8);
004745    void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*);
004746    void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*);
004747    void sqlite3TreeViewBareIdList(TreeView*, const IdList*, const char*);
004748    void sqlite3TreeViewIdList(TreeView*, const IdList*, u8, const char*);
004749    void sqlite3TreeViewColumnList(TreeView*, const Column*, int, u8);
004750    void sqlite3TreeViewSrcList(TreeView*, const SrcList*);
004751    void sqlite3TreeViewSelect(TreeView*, const Select*, u8);
004752    void sqlite3TreeViewWith(TreeView*, const With*, u8);
004753    void sqlite3TreeViewUpsert(TreeView*, const Upsert*, u8);
004754  #if TREETRACE_ENABLED
004755    void sqlite3TreeViewDelete(const With*, const SrcList*, const Expr*,
004756                               const ExprList*,const Expr*, const Trigger*);
004757    void sqlite3TreeViewInsert(const With*, const SrcList*,
004758                               const IdList*, const Select*, const ExprList*,
004759                               int, const Upsert*, const Trigger*);
004760    void sqlite3TreeViewUpdate(const With*, const SrcList*, const ExprList*,
004761                               const Expr*, int, const ExprList*, const Expr*,
004762                               const Upsert*, const Trigger*);
004763  #endif
004764  #ifndef SQLITE_OMIT_TRIGGER
004765    void sqlite3TreeViewTriggerStep(TreeView*, const TriggerStep*, u8, u8);
004766    void sqlite3TreeViewTrigger(TreeView*, const Trigger*, u8, u8);
004767  #endif
004768  #ifndef SQLITE_OMIT_WINDOWFUNC
004769    void sqlite3TreeViewWindow(TreeView*, const Window*, u8);
004770    void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8);
004771  #endif
004772    void sqlite3ShowExpr(const Expr*);
004773    void sqlite3ShowExprList(const ExprList*);
004774    void sqlite3ShowIdList(const IdList*);
004775    void sqlite3ShowSrcList(const SrcList*);
004776    void sqlite3ShowSelect(const Select*);
004777    void sqlite3ShowWith(const With*);
004778    void sqlite3ShowUpsert(const Upsert*);
004779  #ifndef SQLITE_OMIT_TRIGGER
004780    void sqlite3ShowTriggerStep(const TriggerStep*);
004781    void sqlite3ShowTriggerStepList(const TriggerStep*);
004782    void sqlite3ShowTrigger(const Trigger*);
004783    void sqlite3ShowTriggerList(const Trigger*);
004784  #endif
004785  #ifndef SQLITE_OMIT_WINDOWFUNC
004786    void sqlite3ShowWindow(const Window*);
004787    void sqlite3ShowWinFunc(const Window*);
004788  #endif
004789  #endif
004790  
004791  void sqlite3SetString(char **, sqlite3*, const char*);
004792  void sqlite3ProgressCheck(Parse*);
004793  void sqlite3ErrorMsg(Parse*, const char*, ...);
004794  int sqlite3ErrorToParser(sqlite3*,int);
004795  void sqlite3Dequote(char*);
004796  void sqlite3DequoteExpr(Expr*);
004797  void sqlite3DequoteToken(Token*);
004798  void sqlite3TokenInit(Token*,char*);
004799  int sqlite3KeywordCode(const unsigned char*, int);
004800  int sqlite3RunParser(Parse*, const char*);
004801  void sqlite3FinishCoding(Parse*);
004802  int sqlite3GetTempReg(Parse*);
004803  void sqlite3ReleaseTempReg(Parse*,int);
004804  int sqlite3GetTempRange(Parse*,int);
004805  void sqlite3ReleaseTempRange(Parse*,int,int);
004806  void sqlite3ClearTempRegCache(Parse*);
004807  void sqlite3TouchRegister(Parse*,int);
004808  #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
004809  int sqlite3FirstAvailableRegister(Parse*,int);
004810  #endif
004811  #ifdef SQLITE_DEBUG
004812  int sqlite3NoTempsInRange(Parse*,int,int);
004813  #endif
004814  Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int);
004815  Expr *sqlite3Expr(sqlite3*,int,const char*);
004816  void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
004817  Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*);
004818  void sqlite3PExprAddSelect(Parse*, Expr*, Select*);
004819  Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*);
004820  Expr *sqlite3ExprSimplifiedAndOr(Expr*);
004821  Expr *sqlite3ExprFunction(Parse*,ExprList*, const Token*, int);
004822  void sqlite3ExprAddFunctionOrderBy(Parse*,Expr*,ExprList*);
004823  void sqlite3ExprOrderByAggregateError(Parse*,Expr*);
004824  void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*);
004825  void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32);
004826  void sqlite3ExprDelete(sqlite3*, Expr*);
004827  void sqlite3ExprDeleteGeneric(sqlite3*,void*);
004828  void sqlite3ExprDeferredDelete(Parse*, Expr*);
004829  void sqlite3ExprUnmapAndDelete(Parse*, Expr*);
004830  ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
004831  ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*);
004832  Select *sqlite3ExprListToValues(Parse*, int, ExprList*);
004833  void sqlite3ExprListSetSortOrder(ExprList*,int,int);
004834  void sqlite3ExprListSetName(Parse*,ExprList*,const Token*,int);
004835  void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*);
004836  void sqlite3ExprListDelete(sqlite3*, ExprList*);
004837  void sqlite3ExprListDeleteGeneric(sqlite3*,void*);
004838  u32 sqlite3ExprListFlags(const ExprList*);
004839  int sqlite3IndexHasDuplicateRootPage(Index*);
004840  int sqlite3Init(sqlite3*, char**);
004841  int sqlite3InitCallback(void*, int, char**, char**);
004842  int sqlite3InitOne(sqlite3*, int, char**, u32);
004843  void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
004844  #ifndef SQLITE_OMIT_VIRTUALTABLE
004845  Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
004846  #endif
004847  void sqlite3ResetAllSchemasOfConnection(sqlite3*);
004848  void sqlite3ResetOneSchema(sqlite3*,int);
004849  void sqlite3CollapseDatabaseArray(sqlite3*);
004850  void sqlite3CommitInternalChanges(sqlite3*);
004851  void sqlite3ColumnSetExpr(Parse*,Table*,Column*,Expr*);
004852  Expr *sqlite3ColumnExpr(Table*,Column*);
004853  void sqlite3ColumnSetColl(sqlite3*,Column*,const char*zColl);
004854  const char *sqlite3ColumnColl(Column*);
004855  void sqlite3DeleteColumnNames(sqlite3*,Table*);
004856  void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect);
004857  int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);
004858  void sqlite3SubqueryColumnTypes(Parse*,Table*,Select*,char);
004859  Table *sqlite3ResultSetOfSelect(Parse*,Select*,char);
004860  void sqlite3OpenSchemaTable(Parse *, int);
004861  Index *sqlite3PrimaryKeyIndex(Table*);
004862  i16 sqlite3TableColumnToIndex(Index*, i16);
004863  #ifdef SQLITE_OMIT_GENERATED_COLUMNS
004864  # define sqlite3TableColumnToStorage(T,X) (X)  /* No-op pass-through */
004865  # define sqlite3StorageColumnToTable(T,X) (X)  /* No-op pass-through */
004866  #else
004867    i16 sqlite3TableColumnToStorage(Table*, i16);
004868    i16 sqlite3StorageColumnToTable(Table*, i16);
004869  #endif
004870  void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
004871  #if SQLITE_ENABLE_HIDDEN_COLUMNS
004872    void sqlite3ColumnPropertiesFromName(Table*, Column*);
004873  #else
004874  # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
004875  #endif
004876  void sqlite3AddColumn(Parse*,Token,Token);
004877  void sqlite3AddNotNull(Parse*, int);
004878  void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
004879  void sqlite3AddCheckConstraint(Parse*, Expr*, const char*, const char*);
004880  void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*);
004881  void sqlite3AddCollateType(Parse*, Token*);
004882  void sqlite3AddGenerated(Parse*,Expr*,Token*);
004883  void sqlite3EndTable(Parse*,Token*,Token*,u32,Select*);
004884  void sqlite3AddReturning(Parse*,ExprList*);
004885  int sqlite3ParseUri(const char*,const char*,unsigned int*,
004886                      sqlite3_vfs**,char**,char **);
004887  #define sqlite3CodecQueryParameters(A,B,C) 0
004888  Btree *sqlite3DbNameToBtree(sqlite3*,const char*);
004889  
004890  #ifdef SQLITE_UNTESTABLE
004891  # define sqlite3FaultSim(X) SQLITE_OK
004892  #else
004893    int sqlite3FaultSim(int);
004894  #endif
004895  
004896  Bitvec *sqlite3BitvecCreate(u32);
004897  int sqlite3BitvecTest(Bitvec*, u32);
004898  int sqlite3BitvecTestNotNull(Bitvec*, u32);
004899  int sqlite3BitvecSet(Bitvec*, u32);
004900  void sqlite3BitvecClear(Bitvec*, u32, void*);
004901  void sqlite3BitvecDestroy(Bitvec*);
004902  u32 sqlite3BitvecSize(Bitvec*);
004903  #ifndef SQLITE_UNTESTABLE
004904  int sqlite3BitvecBuiltinTest(int,int*);
004905  #endif
004906  
004907  RowSet *sqlite3RowSetInit(sqlite3*);
004908  void sqlite3RowSetDelete(void*);
004909  void sqlite3RowSetClear(void*);
004910  void sqlite3RowSetInsert(RowSet*, i64);
004911  int sqlite3RowSetTest(RowSet*, int iBatch, i64);
004912  int sqlite3RowSetNext(RowSet*, i64*);
004913  
004914  void sqlite3CreateView(Parse*,Token*,Token*,Token*,ExprList*,Select*,int,int);
004915  
004916  #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
004917    int sqlite3ViewGetColumnNames(Parse*,Table*);
004918  #else
004919  # define sqlite3ViewGetColumnNames(A,B) 0
004920  #endif
004921  
004922  #if SQLITE_MAX_ATTACHED>30
004923    int sqlite3DbMaskAllZero(yDbMask);
004924  #endif
004925  void sqlite3DropTable(Parse*, SrcList*, int, int);
004926  void sqlite3CodeDropTable(Parse*, Table*, int, int);
004927  void sqlite3DeleteTable(sqlite3*, Table*);
004928  void sqlite3DeleteTableGeneric(sqlite3*, void*);
004929  void sqlite3FreeIndex(sqlite3*, Index*);
004930  #ifndef SQLITE_OMIT_AUTOINCREMENT
004931    void sqlite3AutoincrementBegin(Parse *pParse);
004932    void sqlite3AutoincrementEnd(Parse *pParse);
004933  #else
004934  # define sqlite3AutoincrementBegin(X)
004935  # define sqlite3AutoincrementEnd(X)
004936  #endif
004937  void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*);
004938  #ifndef SQLITE_OMIT_GENERATED_COLUMNS
004939    void sqlite3ComputeGeneratedColumns(Parse*, int, Table*);
004940  #endif
004941  void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*);
004942  IdList *sqlite3IdListAppend(Parse*, IdList*, Token*);
004943  int sqlite3IdListIndex(IdList*,const char*);
004944  SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int);
004945  SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
004946  SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*);
004947  SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
004948                                        Token*, Select*, OnOrUsing*);
004949  void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
004950  void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*);
004951  int sqlite3IndexedByLookup(Parse *, SrcItem *);
004952  void sqlite3SrcListShiftJoinType(Parse*,SrcList*);
004953  void sqlite3SrcListAssignCursors(Parse*, SrcList*);
004954  void sqlite3IdListDelete(sqlite3*, IdList*);
004955  void sqlite3ClearOnOrUsing(sqlite3*, OnOrUsing*);
004956  void sqlite3SrcListDelete(sqlite3*, SrcList*);
004957  Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**);
004958  void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
004959                            Expr*, int, int, u8);
004960  void sqlite3DropIndex(Parse*, SrcList*, int);
004961  int sqlite3Select(Parse*, Select*, SelectDest*);
004962  Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
004963                           Expr*,ExprList*,u32,Expr*);
004964  void sqlite3SelectDelete(sqlite3*, Select*);
004965  void sqlite3SelectDeleteGeneric(sqlite3*,void*);
004966  Table *sqlite3SrcListLookup(Parse*, SrcList*);
004967  int sqlite3IsReadOnly(Parse*, Table*, Trigger*);
004968  void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
004969  #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
004970  Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,char*);
004971  #endif
004972  void sqlite3CodeChangeCount(Vdbe*,int,const char*);
004973  void sqlite3DeleteFrom(Parse*, SrcList*, Expr*, ExprList*, Expr*);
004974  void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*,
004975                     Upsert*);
004976  WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,
004977                               ExprList*,Select*,u16,int);
004978  void sqlite3WhereEnd(WhereInfo*);
004979  LogEst sqlite3WhereOutputRowCount(WhereInfo*);
004980  int sqlite3WhereIsDistinct(WhereInfo*);
004981  int sqlite3WhereIsOrdered(WhereInfo*);
004982  int sqlite3WhereOrderByLimitOptLabel(WhereInfo*);
004983  void sqlite3WhereMinMaxOptEarlyOut(Vdbe*,WhereInfo*);
004984  int sqlite3WhereIsSorted(WhereInfo*);
004985  int sqlite3WhereContinueLabel(WhereInfo*);
004986  int sqlite3WhereBreakLabel(WhereInfo*);
004987  int sqlite3WhereOkOnePass(WhereInfo*, int*);
004988  #define ONEPASS_OFF      0        /* Use of ONEPASS not allowed */
004989  #define ONEPASS_SINGLE   1        /* ONEPASS valid for a single row update */
004990  #define ONEPASS_MULTI    2        /* ONEPASS is valid for multiple rows */
004991  int sqlite3WhereUsesDeferredSeek(WhereInfo*);
004992  void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*, int, int, int);
004993  int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8);
004994  void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
004995  void sqlite3ExprCodeMove(Parse*, int, int, int);
004996  void sqlite3ExprCode(Parse*, Expr*, int);
004997  #ifndef SQLITE_OMIT_GENERATED_COLUMNS
004998  void sqlite3ExprCodeGeneratedColumn(Parse*, Table*, Column*, int);
004999  #endif
005000  void sqlite3ExprCodeCopy(Parse*, Expr*, int);
005001  void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
005002  int sqlite3ExprCodeRunJustOnce(Parse*, Expr*, int);
005003  int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
005004  int sqlite3ExprCodeTarget(Parse*, Expr*, int);
005005  int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8);
005006  #define SQLITE_ECEL_DUP      0x01  /* Deep, not shallow copies */
005007  #define SQLITE_ECEL_FACTOR   0x02  /* Factor out constant terms */
005008  #define SQLITE_ECEL_REF      0x04  /* Use ExprList.u.x.iOrderByCol */
005009  #define SQLITE_ECEL_OMITREF  0x08  /* Omit if ExprList.u.x.iOrderByCol */
005010  void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
005011  void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
005012  void sqlite3ExprIfFalseDup(Parse*, Expr*, int, int);
005013  Table *sqlite3FindTable(sqlite3*,const char*, const char*);
005014  #define LOCATE_VIEW    0x01
005015  #define LOCATE_NOERR   0x02
005016  Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*);
005017  const char *sqlite3PreferredTableName(const char*);
005018  Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *);
005019  Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
005020  void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
005021  void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
005022  void sqlite3Vacuum(Parse*,Token*,Expr*);
005023  int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*);
005024  char *sqlite3NameFromToken(sqlite3*, const Token*);
005025  int sqlite3ExprCompare(const Parse*,const Expr*,const Expr*, int);
005026  int sqlite3ExprCompareSkip(Expr*,Expr*,int);
005027  int sqlite3ExprListCompare(const ExprList*,const ExprList*, int);
005028  int sqlite3ExprImpliesExpr(const Parse*,const Expr*,const Expr*, int);
005029  int sqlite3ExprImpliesNonNullRow(Expr*,int,int);
005030  void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*);
005031  void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
005032  void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
005033  int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx);
005034  int sqlite3ReferencesSrcList(Parse*, Expr*, SrcList*);
005035  Vdbe *sqlite3GetVdbe(Parse*);
005036  #ifndef SQLITE_UNTESTABLE
005037  void sqlite3PrngSaveState(void);
005038  void sqlite3PrngRestoreState(void);
005039  #endif
005040  void sqlite3RollbackAll(sqlite3*,int);
005041  void sqlite3CodeVerifySchema(Parse*, int);
005042  void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);
005043  void sqlite3BeginTransaction(Parse*, int);
005044  void sqlite3EndTransaction(Parse*,int);
005045  void sqlite3Savepoint(Parse*, int, Token*);
005046  void sqlite3CloseSavepoints(sqlite3 *);
005047  void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
005048  u32 sqlite3IsTrueOrFalse(const char*);
005049  int sqlite3ExprIdToTrueFalse(Expr*);
005050  int sqlite3ExprTruthValue(const Expr*);
005051  int sqlite3ExprIsConstant(Expr*);
005052  int sqlite3ExprIsConstantNotJoin(Expr*);
005053  int sqlite3ExprIsConstantOrFunction(Expr*, u8);
005054  int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
005055  int sqlite3ExprIsTableConstant(Expr*,int);
005056  int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int);
005057  #ifdef SQLITE_ENABLE_CURSOR_HINTS
005058  int sqlite3ExprContainsSubquery(Expr*);
005059  #endif
005060  int sqlite3ExprIsInteger(const Expr*, int*);
005061  int sqlite3ExprCanBeNull(const Expr*);
005062  int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
005063  int sqlite3IsRowid(const char*);
005064  const char *sqlite3RowidAlias(Table *pTab);
005065  void sqlite3GenerateRowDelete(
005066      Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8,int);
005067  void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int);
005068  int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
005069  void sqlite3ResolvePartIdxLabel(Parse*,int);
005070  int sqlite3ExprReferencesUpdatedColumn(Expr*,int*,int);
005071  void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
005072                                       u8,u8,int,int*,int*,Upsert*);
005073  #ifdef SQLITE_ENABLE_NULL_TRIM
005074    void sqlite3SetMakeRecordP5(Vdbe*,Table*);
005075  #else
005076  # define sqlite3SetMakeRecordP5(A,B)
005077  #endif
005078  void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);
005079  int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*);
005080  void sqlite3BeginWriteOperation(Parse*, int, int);
005081  void sqlite3MultiWrite(Parse*);
005082  void sqlite3MayAbort(Parse*);
005083  void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8);
005084  void sqlite3UniqueConstraint(Parse*, int, Index*);
005085  void sqlite3RowidConstraint(Parse*, int, Table*);
005086  Expr *sqlite3ExprDup(sqlite3*,const Expr*,int);
005087  ExprList *sqlite3ExprListDup(sqlite3*,const ExprList*,int);
005088  SrcList *sqlite3SrcListDup(sqlite3*,const SrcList*,int);
005089  IdList *sqlite3IdListDup(sqlite3*,const IdList*);
005090  Select *sqlite3SelectDup(sqlite3*,const Select*,int);
005091  FuncDef *sqlite3FunctionSearch(int,const char*);
005092  void sqlite3InsertBuiltinFuncs(FuncDef*,int);
005093  FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8);
005094  void sqlite3QuoteValue(StrAccum*,sqlite3_value*);
005095  void sqlite3RegisterBuiltinFunctions(void);
005096  void sqlite3RegisterDateTimeFunctions(void);
005097  void sqlite3RegisterJsonFunctions(void);
005098  void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*);
005099  #if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON)
005100    int sqlite3JsonTableFunctions(sqlite3*);
005101  #endif
005102  int sqlite3SafetyCheckOk(sqlite3*);
005103  int sqlite3SafetyCheckSickOrOk(sqlite3*);
005104  void sqlite3ChangeCookie(Parse*, int);
005105  With *sqlite3WithDup(sqlite3 *db, With *p);
005106  
005107  #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
005108  void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int);
005109  #endif
005110  
005111  #ifndef SQLITE_OMIT_TRIGGER
005112    void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
005113                             Expr*,int, int);
005114    void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
005115    void sqlite3DropTrigger(Parse*, SrcList*, int);
005116    void sqlite3DropTriggerPtr(Parse*, Trigger*);
005117    Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask);
005118    Trigger *sqlite3TriggerList(Parse *, Table *);
005119    void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
005120                              int, int, int);
005121    void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
005122    void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
005123    void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
005124    TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*,
005125                                          const char*,const char*);
005126    TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*,
005127                                          Select*,u8,Upsert*,
005128                                          const char*,const char*);
005129    TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*,
005130                                          Expr*, u8, const char*,const char*);
005131    TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*,
005132                                          const char*,const char*);
005133    void sqlite3DeleteTrigger(sqlite3*, Trigger*);
005134    void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
005135    u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
005136    SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*);
005137  # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
005138  # define sqlite3IsToplevel(p) ((p)->pToplevel==0)
005139  #else
005140  # define sqlite3TriggersExist(B,C,D,E,F) 0
005141  # define sqlite3DeleteTrigger(A,B)
005142  # define sqlite3DropTriggerPtr(A,B)
005143  # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
005144  # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
005145  # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
005146  # define sqlite3TriggerList(X, Y) 0
005147  # define sqlite3ParseToplevel(p) p
005148  # define sqlite3IsToplevel(p) 1
005149  # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
005150  # define sqlite3TriggerStepSrc(A,B) 0
005151  #endif
005152  
005153  int sqlite3JoinType(Parse*, Token*, Token*, Token*);
005154  int sqlite3ColumnIndex(Table *pTab, const char *zCol);
005155  void sqlite3SrcItemColumnUsed(SrcItem*,int);
005156  void sqlite3SetJoinExpr(Expr*,int,u32);
005157  void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
005158  void sqlite3DeferForeignKey(Parse*, int);
005159  #ifndef SQLITE_OMIT_AUTHORIZATION
005160    void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
005161    int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
005162    void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
005163    void sqlite3AuthContextPop(AuthContext*);
005164    int sqlite3AuthReadCol(Parse*, const char *, const char *, int);
005165  #else
005166  # define sqlite3AuthRead(a,b,c,d)
005167  # define sqlite3AuthCheck(a,b,c,d,e)    SQLITE_OK
005168  # define sqlite3AuthContextPush(a,b,c)
005169  # define sqlite3AuthContextPop(a)  ((void)(a))
005170  #endif
005171  int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
005172  void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
005173  void sqlite3Detach(Parse*, Expr*);
005174  void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
005175  int sqlite3FixSrcList(DbFixer*, SrcList*);
005176  int sqlite3FixSelect(DbFixer*, Select*);
005177  int sqlite3FixExpr(DbFixer*, Expr*);
005178  int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
005179  
005180  int sqlite3RealSameAsInt(double,sqlite3_int64);
005181  i64 sqlite3RealToI64(double);
005182  int sqlite3Int64ToText(i64,char*);
005183  int sqlite3AtoF(const char *z, double*, int, u8);
005184  int sqlite3GetInt32(const char *, int*);
005185  int sqlite3GetUInt32(const char*, u32*);
005186  int sqlite3Atoi(const char*);
005187  #ifndef SQLITE_OMIT_UTF16
005188  int sqlite3Utf16ByteLen(const void *pData, int nChar);
005189  #endif
005190  int sqlite3Utf8CharLen(const char *pData, int nByte);
005191  u32 sqlite3Utf8Read(const u8**);
005192  int sqlite3Utf8ReadLimited(const u8*, int, u32*);
005193  LogEst sqlite3LogEst(u64);
005194  LogEst sqlite3LogEstAdd(LogEst,LogEst);
005195  LogEst sqlite3LogEstFromDouble(double);
005196  u64 sqlite3LogEstToInt(LogEst);
005197  VList *sqlite3VListAdd(sqlite3*,VList*,const char*,int,int);
005198  const char *sqlite3VListNumToName(VList*,int);
005199  int sqlite3VListNameToNum(VList*,const char*,int);
005200  
005201  /*
005202  ** Routines to read and write variable-length integers.  These used to
005203  ** be defined locally, but now we use the varint routines in the util.c
005204  ** file.
005205  */
005206  int sqlite3PutVarint(unsigned char*, u64);
005207  u8 sqlite3GetVarint(const unsigned char *, u64 *);
005208  u8 sqlite3GetVarint32(const unsigned char *, u32 *);
005209  int sqlite3VarintLen(u64 v);
005210  
005211  /*
005212  ** The common case is for a varint to be a single byte.  They following
005213  ** macros handle the common case without a procedure call, but then call
005214  ** the procedure for larger varints.
005215  */
005216  #define getVarint32(A,B)  \
005217    (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
005218  #define getVarint32NR(A,B) \
005219    B=(u32)*(A);if(B>=0x80)sqlite3GetVarint32((A),(u32*)&(B))
005220  #define putVarint32(A,B)  \
005221    (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
005222    sqlite3PutVarint((A),(B)))
005223  #define getVarint    sqlite3GetVarint
005224  #define putVarint    sqlite3PutVarint
005225  
005226  
005227  const char *sqlite3IndexAffinityStr(sqlite3*, Index*);
005228  char *sqlite3TableAffinityStr(sqlite3*,const Table*);
005229  void sqlite3TableAffinity(Vdbe*, Table*, int);
005230  char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
005231  int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
005232  char sqlite3TableColumnAffinity(const Table*,int);
005233  char sqlite3ExprAffinity(const Expr *pExpr);
005234  int sqlite3ExprDataType(const Expr *pExpr);
005235  int sqlite3Atoi64(const char*, i64*, int, u8);
005236  int sqlite3DecOrHexToI64(const char*, i64*);
005237  void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);
005238  void sqlite3Error(sqlite3*,int);
005239  void sqlite3ErrorClear(sqlite3*);
005240  void sqlite3SystemError(sqlite3*,int);
005241  void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
005242  u8 sqlite3HexToInt(int h);
005243  int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
005244  
005245  #if defined(SQLITE_NEED_ERR_NAME)
005246  const char *sqlite3ErrName(int);
005247  #endif
005248  
005249  #ifndef SQLITE_OMIT_DESERIALIZE
005250  int sqlite3MemdbInit(void);
005251  int sqlite3IsMemdb(const sqlite3_vfs*);
005252  #else
005253  # define sqlite3IsMemdb(X) 0
005254  #endif
005255  
005256  const char *sqlite3ErrStr(int);
005257  int sqlite3ReadSchema(Parse *pParse);
005258  CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
005259  int sqlite3IsBinary(const CollSeq*);
005260  CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
005261  void sqlite3SetTextEncoding(sqlite3 *db, u8);
005262  CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
005263  CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
005264  int sqlite3ExprCollSeqMatch(Parse*,const Expr*,const Expr*);
005265  Expr *sqlite3ExprAddCollateToken(const Parse *pParse, Expr*, const Token*, int);
005266  Expr *sqlite3ExprAddCollateString(const Parse*,Expr*,const char*);
005267  Expr *sqlite3ExprSkipCollate(Expr*);
005268  Expr *sqlite3ExprSkipCollateAndLikely(Expr*);
005269  int sqlite3CheckCollSeq(Parse *, CollSeq *);
005270  int sqlite3WritableSchema(sqlite3*);
005271  int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*);
005272  void sqlite3VdbeSetChanges(sqlite3 *, i64);
005273  int sqlite3AddInt64(i64*,i64);
005274  int sqlite3SubInt64(i64*,i64);
005275  int sqlite3MulInt64(i64*,i64);
005276  int sqlite3AbsInt32(int);
005277  #ifdef SQLITE_ENABLE_8_3_NAMES
005278  void sqlite3FileSuffix3(const char*, char*);
005279  #else
005280  # define sqlite3FileSuffix3(X,Y)
005281  #endif
005282  u8 sqlite3GetBoolean(const char *z,u8);
005283  
005284  const void *sqlite3ValueText(sqlite3_value*, u8);
005285  int sqlite3ValueIsOfClass(const sqlite3_value*, void(*)(void*));
005286  int sqlite3ValueBytes(sqlite3_value*, u8);
005287  void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
005288                          void(*)(void*));
005289  void sqlite3ValueSetNull(sqlite3_value*);
005290  void sqlite3ValueFree(sqlite3_value*);
005291  #ifndef SQLITE_UNTESTABLE
005292  void sqlite3ResultIntReal(sqlite3_context*);
005293  #endif
005294  sqlite3_value *sqlite3ValueNew(sqlite3 *);
005295  #ifndef SQLITE_OMIT_UTF16
005296  char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
005297  #endif
005298  int sqlite3ValueFromExpr(sqlite3 *, const Expr *, u8, u8, sqlite3_value **);
005299  void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
005300  #ifndef SQLITE_AMALGAMATION
005301  extern const unsigned char sqlite3OpcodeProperty[];
005302  extern const char sqlite3StrBINARY[];
005303  extern const unsigned char sqlite3StdTypeLen[];
005304  extern const char sqlite3StdTypeAffinity[];
005305  extern const char *sqlite3StdType[];
005306  extern const unsigned char sqlite3UpperToLower[];
005307  extern const unsigned char *sqlite3aLTb;
005308  extern const unsigned char *sqlite3aEQb;
005309  extern const unsigned char *sqlite3aGTb;
005310  extern const unsigned char sqlite3CtypeMap[];
005311  extern SQLITE_WSD struct Sqlite3Config sqlite3Config;
005312  extern FuncDefHash sqlite3BuiltinFunctions;
005313  #ifndef SQLITE_OMIT_WSD
005314  extern int sqlite3PendingByte;
005315  #endif
005316  #endif /* SQLITE_AMALGAMATION */
005317  #ifdef VDBE_PROFILE
005318  extern sqlite3_uint64 sqlite3NProfileCnt;
005319  #endif
005320  void sqlite3RootPageMoved(sqlite3*, int, Pgno, Pgno);
005321  void sqlite3Reindex(Parse*, Token*, Token*);
005322  void sqlite3AlterFunctions(void);
005323  void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
005324  void sqlite3AlterRenameColumn(Parse*, SrcList*, Token*, Token*);
005325  int sqlite3GetToken(const unsigned char *, int *);
005326  void sqlite3NestedParse(Parse*, const char*, ...);
005327  void sqlite3ExpirePreparedStatements(sqlite3*, int);
005328  void sqlite3CodeRhsOfIN(Parse*, Expr*, int);
005329  int sqlite3CodeSubselect(Parse*, Expr*);
005330  void sqlite3SelectPrep(Parse*, Select*, NameContext*);
005331  int sqlite3ExpandSubquery(Parse*, SrcItem*);
005332  void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
005333  int sqlite3MatchEName(
005334    const struct ExprList_item*,
005335    const char*,
005336    const char*,
005337    const char*,
005338    int*
005339  );
005340  Bitmask sqlite3ExprColUsed(Expr*);
005341  u8 sqlite3StrIHash(const char*);
005342  int sqlite3ResolveExprNames(NameContext*, Expr*);
005343  int sqlite3ResolveExprListNames(NameContext*, ExprList*);
005344  void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
005345  int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*);
005346  int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
005347  void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
005348  void sqlite3AlterFinishAddColumn(Parse *, Token *);
005349  void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
005350  void sqlite3AlterDropColumn(Parse*, SrcList*, const Token*);
005351  const void *sqlite3RenameTokenMap(Parse*, const void*, const Token*);
005352  void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom);
005353  void sqlite3RenameExprUnmap(Parse*, Expr*);
005354  void sqlite3RenameExprlistUnmap(Parse*, ExprList*);
005355  CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
005356  char sqlite3AffinityType(const char*, Column*);
005357  void sqlite3Analyze(Parse*, Token*, Token*);
005358  int sqlite3InvokeBusyHandler(BusyHandler*);
005359  int sqlite3FindDb(sqlite3*, Token*);
005360  int sqlite3FindDbName(sqlite3 *, const char *);
005361  int sqlite3AnalysisLoad(sqlite3*,int iDB);
005362  void sqlite3DeleteIndexSamples(sqlite3*,Index*);
005363  void sqlite3DefaultRowEst(Index*);
005364  void sqlite3RegisterLikeFunctions(sqlite3*, int);
005365  int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
005366  void sqlite3SchemaClear(void *);
005367  Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
005368  int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
005369  KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int);
005370  void sqlite3KeyInfoUnref(KeyInfo*);
005371  KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
005372  KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
005373  KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int);
005374  const char *sqlite3SelectOpName(int);
005375  int sqlite3HasExplicitNulls(Parse*, ExprList*);
005376  
005377  #ifdef SQLITE_DEBUG
005378  int sqlite3KeyInfoIsWriteable(KeyInfo*);
005379  #endif
005380  int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
005381    void (*)(sqlite3_context*,int,sqlite3_value **),
005382    void (*)(sqlite3_context*,int,sqlite3_value **),
005383    void (*)(sqlite3_context*),
005384    void (*)(sqlite3_context*),
005385    void (*)(sqlite3_context*,int,sqlite3_value **),
005386    FuncDestructor *pDestructor
005387  );
005388  void sqlite3NoopDestructor(void*);
005389  void *sqlite3OomFault(sqlite3*);
005390  void sqlite3OomClear(sqlite3*);
005391  int sqlite3ApiExit(sqlite3 *db, int);
005392  int sqlite3OpenTempDatabase(Parse *);
005393  
005394  char *sqlite3RCStrRef(char*);
005395  void sqlite3RCStrUnref(void*);
005396  char *sqlite3RCStrNew(u64);
005397  char *sqlite3RCStrResize(char*,u64);
005398  
005399  void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int);
005400  int sqlite3StrAccumEnlarge(StrAccum*, i64);
005401  char *sqlite3StrAccumFinish(StrAccum*);
005402  void sqlite3StrAccumSetError(StrAccum*, u8);
005403  void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*);
005404  void sqlite3SelectDestInit(SelectDest*,int,int);
005405  Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
005406  void sqlite3RecordErrorByteOffset(sqlite3*,const char*);
005407  void sqlite3RecordErrorOffsetOfExpr(sqlite3*,const Expr*);
005408  
005409  void sqlite3BackupRestart(sqlite3_backup *);
005410  void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
005411  
005412  #ifndef SQLITE_OMIT_SUBQUERY
005413  int sqlite3ExprCheckIN(Parse*, Expr*);
005414  #else
005415  # define sqlite3ExprCheckIN(x,y) SQLITE_OK
005416  #endif
005417  
005418  #ifdef SQLITE_ENABLE_STAT4
005419  int sqlite3Stat4ProbeSetValue(
005420      Parse*,Index*,UnpackedRecord**,Expr*,int,int,int*);
005421  int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**);
005422  void sqlite3Stat4ProbeFree(UnpackedRecord*);
005423  int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**);
005424  char sqlite3IndexColumnAffinity(sqlite3*, Index*, int);
005425  #endif
005426  
005427  /*
005428  ** The interface to the LEMON-generated parser
005429  */
005430  #ifndef SQLITE_AMALGAMATION
005431    void *sqlite3ParserAlloc(void*(*)(u64), Parse*);
005432    void sqlite3ParserFree(void*, void(*)(void*));
005433  #endif
005434  void sqlite3Parser(void*, int, Token);
005435  int sqlite3ParserFallback(int);
005436  #ifdef YYTRACKMAXSTACKDEPTH
005437    int sqlite3ParserStackPeak(void*);
005438  #endif
005439  
005440  void sqlite3AutoLoadExtensions(sqlite3*);
005441  #ifndef SQLITE_OMIT_LOAD_EXTENSION
005442    void sqlite3CloseExtensions(sqlite3*);
005443  #else
005444  # define sqlite3CloseExtensions(X)
005445  #endif
005446  
005447  #ifndef SQLITE_OMIT_SHARED_CACHE
005448    void sqlite3TableLock(Parse *, int, Pgno, u8, const char *);
005449  #else
005450    #define sqlite3TableLock(v,w,x,y,z)
005451  #endif
005452  
005453  #ifdef SQLITE_TEST
005454    int sqlite3Utf8To8(unsigned char*);
005455  #endif
005456  
005457  #ifdef SQLITE_OMIT_VIRTUALTABLE
005458  #  define sqlite3VtabClear(D,T)
005459  #  define sqlite3VtabSync(X,Y) SQLITE_OK
005460  #  define sqlite3VtabRollback(X)
005461  #  define sqlite3VtabCommit(X)
005462  #  define sqlite3VtabInSync(db) 0
005463  #  define sqlite3VtabLock(X)
005464  #  define sqlite3VtabUnlock(X)
005465  #  define sqlite3VtabModuleUnref(D,X)
005466  #  define sqlite3VtabUnlockList(X)
005467  #  define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
005468  #  define sqlite3GetVTable(X,Y)  ((VTable*)0)
005469  #else
005470     void sqlite3VtabClear(sqlite3 *db, Table*);
005471     void sqlite3VtabDisconnect(sqlite3 *db, Table *p);
005472     int sqlite3VtabSync(sqlite3 *db, Vdbe*);
005473     int sqlite3VtabRollback(sqlite3 *db);
005474     int sqlite3VtabCommit(sqlite3 *db);
005475     void sqlite3VtabLock(VTable *);
005476     void sqlite3VtabUnlock(VTable *);
005477     void sqlite3VtabModuleUnref(sqlite3*,Module*);
005478     void sqlite3VtabUnlockList(sqlite3*);
005479     int sqlite3VtabSavepoint(sqlite3 *, int, int);
005480     void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*);
005481     VTable *sqlite3GetVTable(sqlite3*, Table*);
005482     Module *sqlite3VtabCreateModule(
005483       sqlite3*,
005484       const char*,
005485       const sqlite3_module*,
005486       void*,
005487       void(*)(void*)
005488     );
005489  #  define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
005490  #endif
005491  int sqlite3ReadOnlyShadowTables(sqlite3 *db);
005492  #ifndef SQLITE_OMIT_VIRTUALTABLE
005493    int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
005494    int sqlite3IsShadowTableOf(sqlite3*,Table*,const char*);
005495    void sqlite3MarkAllShadowTablesOf(sqlite3*, Table*);
005496  #else
005497  # define sqlite3ShadowTableName(A,B) 0
005498  # define sqlite3IsShadowTableOf(A,B,C) 0
005499  # define sqlite3MarkAllShadowTablesOf(A,B)
005500  #endif
005501  int sqlite3VtabEponymousTableInit(Parse*,Module*);
005502  void sqlite3VtabEponymousTableClear(sqlite3*,Module*);
005503  void sqlite3VtabMakeWritable(Parse*,Table*);
005504  void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int);
005505  void sqlite3VtabFinishParse(Parse*, Token*);
005506  void sqlite3VtabArgInit(Parse*);
005507  void sqlite3VtabArgExtend(Parse*, Token*);
005508  int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
005509  int sqlite3VtabCallConnect(Parse*, Table*);
005510  int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
005511  int sqlite3VtabBegin(sqlite3 *, VTable *);
005512  
005513  FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
005514  void sqlite3VtabUsesAllSchemas(Parse*);
005515  sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
005516  int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
005517  int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
005518  void sqlite3ParseObjectInit(Parse*,sqlite3*);
005519  void sqlite3ParseObjectReset(Parse*);
005520  void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*);
005521  #ifdef SQLITE_ENABLE_NORMALIZE
005522  char *sqlite3Normalize(Vdbe*, const char*);
005523  #endif
005524  int sqlite3Reprepare(Vdbe*);
005525  void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
005526  CollSeq *sqlite3ExprCompareCollSeq(Parse*,const Expr*);
005527  CollSeq *sqlite3BinaryCompareCollSeq(Parse *, const Expr*, const Expr*);
005528  int sqlite3TempInMemory(const sqlite3*);
005529  const char *sqlite3JournalModename(int);
005530  #ifndef SQLITE_OMIT_WAL
005531    int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
005532    int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
005533  #endif
005534  #ifndef SQLITE_OMIT_CTE
005535    Cte *sqlite3CteNew(Parse*,Token*,ExprList*,Select*,u8);
005536    void sqlite3CteDelete(sqlite3*,Cte*);
005537    With *sqlite3WithAdd(Parse*,With*,Cte*);
005538    void sqlite3WithDelete(sqlite3*,With*);
005539    void sqlite3WithDeleteGeneric(sqlite3*,void*);
005540    With *sqlite3WithPush(Parse*, With*, u8);
005541  #else
005542  # define sqlite3CteNew(P,T,E,S)   ((void*)0)
005543  # define sqlite3CteDelete(D,C)
005544  # define sqlite3CteWithAdd(P,W,C) ((void*)0)
005545  # define sqlite3WithDelete(x,y)
005546  # define sqlite3WithPush(x,y,z) ((void*)0)
005547  #endif
005548  #ifndef SQLITE_OMIT_UPSERT
005549    Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*);
005550    void sqlite3UpsertDelete(sqlite3*,Upsert*);
005551    Upsert *sqlite3UpsertDup(sqlite3*,Upsert*);
005552    int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*,Upsert*);
005553    void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int);
005554    Upsert *sqlite3UpsertOfIndex(Upsert*,Index*);
005555    int sqlite3UpsertNextIsIPK(Upsert*);
005556  #else
005557  #define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0)
005558  #define sqlite3UpsertDelete(x,y)
005559  #define sqlite3UpsertDup(x,y)         ((Upsert*)0)
005560  #define sqlite3UpsertOfIndex(x,y)     ((Upsert*)0)
005561  #define sqlite3UpsertNextIsIPK(x)     0
005562  #endif
005563  
005564  
005565  /* Declarations for functions in fkey.c. All of these are replaced by
005566  ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
005567  ** key functionality is available. If OMIT_TRIGGER is defined but
005568  ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
005569  ** this case foreign keys are parsed, but no other functionality is
005570  ** provided (enforcement of FK constraints requires the triggers sub-system).
005571  */
005572  #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
005573    void sqlite3FkCheck(Parse*, Table*, int, int, int*, int);
005574    void sqlite3FkDropTable(Parse*, SrcList *, Table*);
005575    void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int);
005576    int sqlite3FkRequired(Parse*, Table*, int*, int);
005577    u32 sqlite3FkOldmask(Parse*, Table*);
005578    FKey *sqlite3FkReferences(Table *);
005579    void sqlite3FkClearTriggerCache(sqlite3*,int);
005580  #else
005581    #define sqlite3FkActions(a,b,c,d,e,f)
005582    #define sqlite3FkCheck(a,b,c,d,e,f)
005583    #define sqlite3FkDropTable(a,b,c)
005584    #define sqlite3FkOldmask(a,b)         0
005585    #define sqlite3FkRequired(a,b,c,d)    0
005586    #define sqlite3FkReferences(a)        0
005587    #define sqlite3FkClearTriggerCache(a,b)
005588  #endif
005589  #ifndef SQLITE_OMIT_FOREIGN_KEY
005590    void sqlite3FkDelete(sqlite3 *, Table*);
005591    int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**);
005592  #else
005593    #define sqlite3FkDelete(a,b)
005594    #define sqlite3FkLocateIndex(a,b,c,d,e)
005595  #endif
005596  
005597  
005598  /*
005599  ** Available fault injectors.  Should be numbered beginning with 0.
005600  */
005601  #define SQLITE_FAULTINJECTOR_MALLOC     0
005602  #define SQLITE_FAULTINJECTOR_COUNT      1
005603  
005604  /*
005605  ** The interface to the code in fault.c used for identifying "benign"
005606  ** malloc failures. This is only present if SQLITE_UNTESTABLE
005607  ** is not defined.
005608  */
005609  #ifndef SQLITE_UNTESTABLE
005610    void sqlite3BeginBenignMalloc(void);
005611    void sqlite3EndBenignMalloc(void);
005612  #else
005613    #define sqlite3BeginBenignMalloc()
005614    #define sqlite3EndBenignMalloc()
005615  #endif
005616  
005617  /*
005618  ** Allowed return values from sqlite3FindInIndex()
005619  */
005620  #define IN_INDEX_ROWID        1   /* Search the rowid of the table */
005621  #define IN_INDEX_EPH          2   /* Search an ephemeral b-tree */
005622  #define IN_INDEX_INDEX_ASC    3   /* Existing index ASCENDING */
005623  #define IN_INDEX_INDEX_DESC   4   /* Existing index DESCENDING */
005624  #define IN_INDEX_NOOP         5   /* No table available. Use comparisons */
005625  /*
005626  ** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
005627  */
005628  #define IN_INDEX_NOOP_OK     0x0001  /* OK to return IN_INDEX_NOOP */
005629  #define IN_INDEX_MEMBERSHIP  0x0002  /* IN operator used for membership test */
005630  #define IN_INDEX_LOOP        0x0004  /* IN operator used as a loop */
005631  int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*);
005632  
005633  int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
005634  int sqlite3JournalSize(sqlite3_vfs *);
005635  #if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
005636   || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
005637    int sqlite3JournalCreate(sqlite3_file *);
005638  #endif
005639  
005640  int sqlite3JournalIsInMemory(sqlite3_file *p);
005641  void sqlite3MemJournalOpen(sqlite3_file *);
005642  
005643  void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
005644  #if SQLITE_MAX_EXPR_DEPTH>0
005645    int sqlite3SelectExprHeight(const Select *);
005646    int sqlite3ExprCheckHeight(Parse*, int);
005647  #else
005648    #define sqlite3SelectExprHeight(x) 0
005649    #define sqlite3ExprCheckHeight(x,y)
005650  #endif
005651  void sqlite3ExprSetErrorOffset(Expr*,int);
005652  
005653  u32 sqlite3Get4byte(const u8*);
005654  void sqlite3Put4byte(u8*, u32);
005655  
005656  #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
005657    void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
005658    void sqlite3ConnectionUnlocked(sqlite3 *db);
005659    void sqlite3ConnectionClosed(sqlite3 *db);
005660  #else
005661    #define sqlite3ConnectionBlocked(x,y)
005662    #define sqlite3ConnectionUnlocked(x)
005663    #define sqlite3ConnectionClosed(x)
005664  #endif
005665  
005666  #ifdef SQLITE_DEBUG
005667    void sqlite3ParserTrace(FILE*, char *);
005668  #endif
005669  #if defined(YYCOVERAGE)
005670    int sqlite3ParserCoverage(FILE*);
005671  #endif
005672  
005673  /*
005674  ** If the SQLITE_ENABLE IOTRACE exists then the global variable
005675  ** sqlite3IoTrace is a pointer to a printf-like routine used to
005676  ** print I/O tracing messages.
005677  */
005678  #ifdef SQLITE_ENABLE_IOTRACE
005679  # define IOTRACE(A)  if( sqlite3IoTrace ){ sqlite3IoTrace A; }
005680    void sqlite3VdbeIOTraceSql(Vdbe*);
005681  SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
005682  #else
005683  # define IOTRACE(A)
005684  # define sqlite3VdbeIOTraceSql(X)
005685  #endif
005686  
005687  /*
005688  ** These routines are available for the mem2.c debugging memory allocator
005689  ** only.  They are used to verify that different "types" of memory
005690  ** allocations are properly tracked by the system.
005691  **
005692  ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
005693  ** the MEMTYPE_* macros defined below.  The type must be a bitmask with
005694  ** a single bit set.
005695  **
005696  ** sqlite3MemdebugHasType() returns true if any of the bits in its second
005697  ** argument match the type set by the previous sqlite3MemdebugSetType().
005698  ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
005699  **
005700  ** sqlite3MemdebugNoType() returns true if none of the bits in its second
005701  ** argument match the type set by the previous sqlite3MemdebugSetType().
005702  **
005703  ** Perhaps the most important point is the difference between MEMTYPE_HEAP
005704  ** and MEMTYPE_LOOKASIDE.  If an allocation is MEMTYPE_LOOKASIDE, that means
005705  ** it might have been allocated by lookaside, except the allocation was
005706  ** too large or lookaside was already full.  It is important to verify
005707  ** that allocations that might have been satisfied by lookaside are not
005708  ** passed back to non-lookaside free() routines.  Asserts such as the
005709  ** example above are placed on the non-lookaside free() routines to verify
005710  ** this constraint.
005711  **
005712  ** All of this is no-op for a production build.  It only comes into
005713  ** play when the SQLITE_MEMDEBUG compile-time option is used.
005714  */
005715  #ifdef SQLITE_MEMDEBUG
005716    void sqlite3MemdebugSetType(void*,u8);
005717    int sqlite3MemdebugHasType(const void*,u8);
005718    int sqlite3MemdebugNoType(const void*,u8);
005719  #else
005720  # define sqlite3MemdebugSetType(X,Y)  /* no-op */
005721  # define sqlite3MemdebugHasType(X,Y)  1
005722  # define sqlite3MemdebugNoType(X,Y)   1
005723  #endif
005724  #define MEMTYPE_HEAP       0x01  /* General heap allocations */
005725  #define MEMTYPE_LOOKASIDE  0x02  /* Heap that might have been lookaside */
005726  #define MEMTYPE_PCACHE     0x04  /* Page cache allocations */
005727  
005728  /*
005729  ** Threading interface
005730  */
005731  #if SQLITE_MAX_WORKER_THREADS>0
005732  int sqlite3ThreadCreate(SQLiteThread**,void*(*)(void*),void*);
005733  int sqlite3ThreadJoin(SQLiteThread*, void**);
005734  #endif
005735  
005736  #if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)
005737  int sqlite3DbpageRegister(sqlite3*);
005738  #endif
005739  #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
005740  int sqlite3DbstatRegister(sqlite3*);
005741  #endif
005742  
005743  int sqlite3ExprVectorSize(const Expr *pExpr);
005744  int sqlite3ExprIsVector(const Expr *pExpr);
005745  Expr *sqlite3VectorFieldSubexpr(Expr*, int);
005746  Expr *sqlite3ExprForVectorField(Parse*,Expr*,int,int);
005747  void sqlite3VectorErrorMsg(Parse*, Expr*);
005748  
005749  #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
005750  const char **sqlite3CompileOptions(int *pnOpt);
005751  #endif
005752  
005753  #if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL)
005754  int sqlite3KvvfsInit(void);
005755  #endif
005756  
005757  #if defined(VDBE_PROFILE) \
005758   || defined(SQLITE_PERFORMANCE_TRACE) \
005759   || defined(SQLITE_ENABLE_STMT_SCANSTATUS)
005760  sqlite3_uint64 sqlite3Hwtime(void);
005761  #endif
005762  
005763  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
005764  # define IS_STMT_SCANSTATUS(db) (db->flags & SQLITE_StmtScanStatus)
005765  #else
005766  # define IS_STMT_SCANSTATUS(db) 0
005767  #endif
005768  
005769  #endif /* SQLITEINT_H */