| Index: third_party/sqlite/src/src/sqliteInt.h
|
| diff --git a/third_party/sqlite/src/src/sqliteInt.h b/third_party/sqlite/src/src/sqliteInt.h
|
| index c01bbc78698e35a70acbb169aaf9d6be21a88468..ee58edad775c046bef6193a8f550105a3cf968f1 100644
|
| --- a/third_party/sqlite/src/src/sqliteInt.h
|
| +++ b/third_party/sqlite/src/src/sqliteInt.h
|
| @@ -12,8 +12,54 @@
|
| ** Internal interface definitions for SQLite.
|
| **
|
| */
|
| -#ifndef _SQLITEINT_H_
|
| -#define _SQLITEINT_H_
|
| +#ifndef SQLITEINT_H
|
| +#define SQLITEINT_H
|
| +
|
| +/* Special Comments:
|
| +**
|
| +** Some comments have special meaning to the tools that measure test
|
| +** coverage:
|
| +**
|
| +** NO_TEST - The branches on this line are not
|
| +** measured by branch coverage. This is
|
| +** used on lines of code that actually
|
| +** implement parts of coverage testing.
|
| +**
|
| +** OPTIMIZATION-IF-TRUE - This branch is allowed to alway be false
|
| +** and the correct answer is still obtained,
|
| +** though perhaps more slowly.
|
| +**
|
| +** OPTIMIZATION-IF-FALSE - This branch is allowed to alway be true
|
| +** and the correct answer is still obtained,
|
| +** though perhaps more slowly.
|
| +**
|
| +** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread
|
| +** that would be harmless and undetectable
|
| +** if it did occur.
|
| +**
|
| +** In all cases, the special comment must be enclosed in the usual
|
| +** slash-asterisk...asterisk-slash comment marks, with no spaces between the
|
| +** asterisks and the comment text.
|
| +*/
|
| +
|
| +/*
|
| +** Make sure the Tcl calling convention macro is defined. This macro is
|
| +** only used by test code and Tcl integration code.
|
| +*/
|
| +#ifndef SQLITE_TCLAPI
|
| +# define SQLITE_TCLAPI
|
| +#endif
|
| +
|
| +/*
|
| +** Make sure that rand_s() is available on Windows systems with MSVC 2005
|
| +** or higher.
|
| +*/
|
| +#if defined(_MSC_VER) && _MSC_VER>=1400
|
| +/* TODO(shess): Already defined by build/config/win/BUILD.gn */
|
| +#ifndef _CRT_RAND_S
|
| +# define _CRT_RAND_S
|
| +#endif
|
| +#endif
|
|
|
| /*
|
| ** Include the header file used to customize the compiler options for MSVC.
|
| @@ -60,12 +106,28 @@
|
| # define _LARGEFILE_SOURCE 1
|
| #endif
|
|
|
| -/* What version of GCC is being used. 0 means GCC is not being used */
|
| -#ifdef __GNUC__
|
| +/* The GCC_VERSION, CLANG_VERSION, and MSVC_VERSION macros are used to
|
| +** conditionally include optimizations for each of these compilers. A
|
| +** value of 0 means that compiler is not being used. The
|
| +** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific
|
| +** optimizations, and hence set all compiler macros to 0
|
| +*/
|
| +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)
|
| # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
|
| #else
|
| # define GCC_VERSION 0
|
| #endif
|
| +#if defined(__clang__) && !defined(_WIN32) && !defined(SQLITE_DISABLE_INTRINSIC)
|
| +# define CLANG_VERSION \
|
| + (__clang_major__*1000000+__clang_minor__*1000+__clang_patchlevel__)
|
| +#else
|
| +# define CLANG_VERSION 0
|
| +#endif
|
| +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
|
| +# define MSVC_VERSION _MSC_VER
|
| +#else
|
| +# define MSVC_VERSION 0
|
| +#endif
|
|
|
| /* Needed for various definitions... */
|
| #if defined(__GNUC__) && !defined(_GNU_SOURCE)
|
| @@ -149,7 +211,7 @@
|
| ** to the next, so we have developed the following set of #if statements
|
| ** to generate appropriate macros for a wide range of compilers.
|
| **
|
| -** The correct "ANSI" way to do this is to use the intptr_t type.
|
| +** The correct "ANSI" way to do this is to use the intptr_t type.
|
| ** Unfortunately, that typedef is not available on all compilers, or
|
| ** if it is available, it requires an #include of specific headers
|
| ** that vary from one machine to the next.
|
| @@ -174,21 +236,6 @@
|
| #endif
|
|
|
| /*
|
| -** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
|
| -** something between S (inclusive) and E (exclusive).
|
| -**
|
| -** In other words, S is a buffer and E is a pointer to the first byte after
|
| -** the end of buffer S. This macro returns true if P points to something
|
| -** contained within the buffer S.
|
| -*/
|
| -#if defined(HAVE_STDINT_H)
|
| -# define SQLITE_WITHIN(P,S,E) \
|
| - ((uintptr_t)(P)>=(uintptr_t)(S) && (uintptr_t)(P)<(uintptr_t)(E))
|
| -#else
|
| -# define SQLITE_WITHIN(P,S,E) ((P)>=(S) && (P)<(E))
|
| -#endif
|
| -
|
| -/*
|
| ** A macro to hint to the compiler that a function should not be
|
| ** inlined.
|
| */
|
| @@ -206,11 +253,12 @@
|
| ** the SQLITE_DISABLE_INTRINSIC define.
|
| */
|
| #if !defined(SQLITE_DISABLE_INTRINSIC)
|
| -# if defined(_MSC_VER) && _MSC_VER>=1300
|
| +# if defined(_MSC_VER) && _MSC_VER>=1400
|
| # if !defined(_WIN32_WCE)
|
| # include <intrin.h>
|
| # pragma intrinsic(_byteswap_ushort)
|
| # pragma intrinsic(_byteswap_ulong)
|
| +# pragma intrinsic(_byteswap_uint64)
|
| # pragma intrinsic(_ReadWriteBarrier)
|
| # else
|
| # include <cmnintrin.h>
|
| @@ -316,7 +364,7 @@
|
| ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
|
| ** feature.
|
| */
|
| -#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
|
| +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
|
| # define NDEBUG 1
|
| #endif
|
| #if defined(NDEBUG) && defined(SQLITE_DEBUG)
|
| @@ -331,7 +379,7 @@
|
| #endif
|
|
|
| /*
|
| -** The testcase() macro is used to aid in coverage testing. When
|
| +** The testcase() macro is used to aid in coverage testing. When
|
| ** doing coverage testing, the condition inside the argument to
|
| ** testcase() must be evaluated both true and false in order to
|
| ** get full branch coverage. The testcase() macro is inserted
|
| @@ -377,7 +425,7 @@
|
| #endif
|
|
|
| /*
|
| -** The ALWAYS and NEVER macros surround boolean expressions which
|
| +** The ALWAYS and NEVER macros surround boolean expressions which
|
| ** are intended to always be true or false, respectively. Such
|
| ** expressions could be omitted from the code completely. But they
|
| ** are included in a few cases in order to enhance the resilience
|
| @@ -391,7 +439,7 @@
|
| ** be true and false so that the unreachable code they specify will
|
| ** not be counted as untested code.
|
| */
|
| -#if defined(SQLITE_COVERAGE_TEST)
|
| +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
|
| # define ALWAYS(X) (1)
|
| # define NEVER(X) (0)
|
| #elif !defined(NDEBUG)
|
| @@ -403,6 +451,21 @@
|
| #endif
|
|
|
| /*
|
| +** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
|
| +** defined. We need to defend against those failures when testing with
|
| +** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
|
| +** during a normal build. The following macro can be used to disable tests
|
| +** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
|
| +*/
|
| +#if defined(SQLITE_TEST_REALLOC_STRESS)
|
| +# define ONLY_IF_REALLOC_STRESS(X) (X)
|
| +#elif !defined(NDEBUG)
|
| +# define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0)
|
| +#else
|
| +# define ONLY_IF_REALLOC_STRESS(X) (0)
|
| +#endif
|
| +
|
| +/*
|
| ** Declarations used for tracing the operating system interfaces.
|
| */
|
| #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \
|
| @@ -429,6 +492,13 @@
|
| #endif
|
|
|
| /*
|
| +** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN
|
| +*/
|
| +#ifdef SQLITE_OMIT_EXPLAIN
|
| +# undef SQLITE_ENABLE_EXPLAIN_COMMENTS
|
| +#endif
|
| +
|
| +/*
|
| ** Return true (non-zero) if the input is an integer that is too large
|
| ** to fit in 32-bits. This macro is used inside of various testcase()
|
| ** macros to verify that we have tested SQLite for large-file support.
|
| @@ -454,6 +524,18 @@
|
| #include <stddef.h>
|
|
|
| /*
|
| +** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY.
|
| +** This allows better measurements of where memcpy() is used when running
|
| +** cachegrind. But this macro version of memcpy() is very slow so it
|
| +** should not be used in production. This is a performance measurement
|
| +** hack only.
|
| +*/
|
| +#ifdef SQLITE_INLINE_MEMCPY
|
| +# define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\
|
| + int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);}
|
| +#endif
|
| +
|
| +/*
|
| ** If compiling for a processor that lacks floating point support,
|
| ** substitute integer for floating-point
|
| */
|
| @@ -475,7 +557,7 @@
|
|
|
| /*
|
| ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
|
| -** afterward. Having this macro allows us to cause the C compiler
|
| +** afterward. Having this macro allows us to cause the C compiler
|
| ** to omit code used by TEMP tables without messy #ifndef statements.
|
| */
|
| #ifdef SQLITE_OMIT_TEMPDB
|
| @@ -514,7 +596,7 @@
|
|
|
| /*
|
| ** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
|
| -** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
|
| +** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
|
| ** to zero.
|
| */
|
| #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
|
| @@ -537,9 +619,12 @@
|
| ** pagecaches for each database connection. A positive number is the
|
| ** number of pages. A negative number N translations means that a buffer
|
| ** of -1024*N bytes is allocated and used for as many pages as it will hold.
|
| +**
|
| +** The default value of "20" was choosen to minimize the run-time of the
|
| +** speedtest1 test program with options: --shrink-memory --reprepare
|
| */
|
| #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
|
| -# define SQLITE_DEFAULT_PCACHE_INITSZ 100
|
| +# define SQLITE_DEFAULT_PCACHE_INITSZ 20
|
| #endif
|
|
|
| /*
|
| @@ -553,8 +638,12 @@
|
| /*
|
| ** Macros to compute minimum and maximum of two numbers.
|
| */
|
| -#define MIN(A,B) ((A)<(B)?(A):(B))
|
| -#define MAX(A,B) ((A)>(B)?(A):(B))
|
| +#ifndef MIN
|
| +# define MIN(A,B) ((A)<(B)?(A):(B))
|
| +#endif
|
| +#ifndef MAX
|
| +# define MAX(A,B) ((A)>(B)?(A):(B))
|
| +#endif
|
|
|
| /*
|
| ** Swap two objects of type TYPE.
|
| @@ -662,7 +751,7 @@ typedef INT8_TYPE i8; /* 1-byte signed integer */
|
| ** 4 -> 20 1000 -> 99 1048576 -> 200
|
| ** 10 -> 33 1024 -> 100 4294967296 -> 320
|
| **
|
| -** The LogEst can be negative to indicate fractional values.
|
| +** The LogEst can be negative to indicate fractional values.
|
| ** Examples:
|
| **
|
| ** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
|
| @@ -683,38 +772,62 @@ typedef INT16_TYPE LogEst;
|
| # endif
|
| #endif
|
|
|
| +/* The uptr type is an unsigned integer large enough to hold a pointer
|
| +*/
|
| +#if defined(HAVE_STDINT_H)
|
| + typedef uintptr_t uptr;
|
| +#elif SQLITE_PTRSIZE==4
|
| + typedef u32 uptr;
|
| +#else
|
| + typedef u64 uptr;
|
| +#endif
|
| +
|
| +/*
|
| +** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
|
| +** something between S (inclusive) and E (exclusive).
|
| +**
|
| +** In other words, S is a buffer and E is a pointer to the first byte after
|
| +** the end of buffer S. This macro returns true if P points to something
|
| +** contained within the buffer S.
|
| +*/
|
| +#define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E)))
|
| +
|
| +
|
| /*
|
| ** Macros to determine whether the machine is big or little endian,
|
| ** and whether or not that determination is run-time or compile-time.
|
| **
|
| ** For best performance, an attempt is made to guess at the byte-order
|
| ** using C-preprocessor macros. If that is unsuccessful, or if
|
| -** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
|
| +** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
|
| ** at run-time.
|
| */
|
| -#if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \
|
| +#ifndef SQLITE_BYTEORDER
|
| +# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \
|
| defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
|
| defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
|
| - defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)
|
| -# define SQLITE_BYTEORDER 1234
|
| -# define SQLITE_BIGENDIAN 0
|
| -# define SQLITE_LITTLEENDIAN 1
|
| -# define SQLITE_UTF16NATIVE SQLITE_UTF16LE
|
| + defined(__arm__)
|
| +# define SQLITE_BYTEORDER 1234
|
| +# elif defined(sparc) || defined(__ppc__)
|
| +# define SQLITE_BYTEORDER 4321
|
| +# else
|
| +# define SQLITE_BYTEORDER 0
|
| +# endif
|
| #endif
|
| -#if (defined(sparc) || defined(__ppc__)) \
|
| - && !defined(SQLITE_RUNTIME_BYTEORDER)
|
| -# define SQLITE_BYTEORDER 4321
|
| +#if SQLITE_BYTEORDER==4321
|
| # define SQLITE_BIGENDIAN 1
|
| # define SQLITE_LITTLEENDIAN 0
|
| # define SQLITE_UTF16NATIVE SQLITE_UTF16BE
|
| -#endif
|
| -#if !defined(SQLITE_BYTEORDER)
|
| +#elif SQLITE_BYTEORDER==1234
|
| +# define SQLITE_BIGENDIAN 0
|
| +# define SQLITE_LITTLEENDIAN 1
|
| +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE
|
| +#else
|
| # ifdef SQLITE_AMALGAMATION
|
| const int sqlite3one = 1;
|
| # else
|
| extern const int sqlite3one;
|
| # endif
|
| -# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */
|
| # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
|
| # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
|
| # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
|
| @@ -728,7 +841,7 @@ typedef INT16_TYPE LogEst;
|
| #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
|
| #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
|
|
|
| -/*
|
| +/*
|
| ** Round up a number to the next larger multiple of 8. This is used
|
| ** to force 8-byte alignment on 64-bit architectures.
|
| */
|
| @@ -767,10 +880,6 @@ typedef INT16_TYPE LogEst;
|
| */
|
| #ifdef __APPLE__
|
| # include <TargetConditionals.h>
|
| -# if TARGET_OS_IPHONE
|
| -# undef SQLITE_MAX_MMAP_SIZE
|
| -# define SQLITE_MAX_MMAP_SIZE 0
|
| -# endif
|
| #endif
|
| #ifndef SQLITE_MAX_MMAP_SIZE
|
| # if defined(__linux__) \
|
| @@ -826,7 +935,7 @@ typedef INT16_TYPE LogEst;
|
|
|
| /*
|
| ** An instance of the following structure is used to store the busy-handler
|
| -** callback for a given sqlite handle.
|
| +** callback for a given sqlite handle.
|
| **
|
| ** The sqlite.busyHandler member of the sqlite struct contains the busy
|
| ** callback for the database handle. Each pager opened via the sqlite
|
| @@ -871,9 +980,9 @@ struct BusyHandler {
|
|
|
| /*
|
| ** The following value as a destructor means to use sqlite3DbFree().
|
| -** The sqlite3DbFree() routine requires two parameters instead of the
|
| -** one parameter that destructors normally want. So we have to introduce
|
| -** this magic value that the code knows to handle differently. Any
|
| +** The sqlite3DbFree() routine requires two parameters instead of the
|
| +** one parameter that destructors normally want. So we have to introduce
|
| +** this magic value that the code knows to handle differently. Any
|
| ** pointer will work here as long as it is distinct from SQLITE_STATIC
|
| ** and SQLITE_TRANSIENT.
|
| */
|
| @@ -900,16 +1009,16 @@ struct BusyHandler {
|
| int sqlite3_wsd_init(int N, int J);
|
| void *sqlite3_wsd_find(void *K, int L);
|
| #else
|
| - #define SQLITE_WSD
|
| + #define SQLITE_WSD
|
| #define GLOBAL(t,v) v
|
| #define sqlite3GlobalConfig sqlite3Config
|
| #endif
|
|
|
| /*
|
| ** The following macros are used to suppress compiler warnings and to
|
| -** make it clear to human readers when a function parameter is deliberately
|
| +** make it clear to human readers when a function parameter is deliberately
|
| ** left unused within the body of a function. This usually happens when
|
| -** a function is called via a function pointer. For example the
|
| +** a function is called via a function pointer. For example the
|
| ** implementation of an SQL aggregate step callback may not use the
|
| ** parameter indicating the number of arguments passed to the aggregate,
|
| ** if it knows that this is enforced elsewhere.
|
| @@ -952,6 +1061,7 @@ typedef struct LookasideSlot LookasideSlot;
|
| typedef struct Module Module;
|
| typedef struct NameContext NameContext;
|
| typedef struct Parse Parse;
|
| +typedef struct PreUpdate PreUpdate;
|
| typedef struct PrintfArguments PrintfArguments;
|
| typedef struct RowSet RowSet;
|
| typedef struct Savepoint Savepoint;
|
| @@ -974,8 +1084,16 @@ typedef struct Walker Walker;
|
| typedef struct WhereInfo WhereInfo;
|
| typedef struct With With;
|
|
|
| +/* A VList object records a mapping between parameters/variables/wildcards
|
| +** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
|
| +** variable number associated with that parameter. See the format description
|
| +** on the sqlite3VListAdd() routine for more information. A VList is really
|
| +** just an array of integers.
|
| +*/
|
| +typedef int VList;
|
| +
|
| /*
|
| -** Defer sourcing vdbe.h and btree.h until after the "u8" and
|
| +** Defer sourcing vdbe.h and btree.h until after the "u8" and
|
| ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
|
| ** pointer types (i.e. FuncDef) defined above.
|
| */
|
| @@ -983,10 +1101,39 @@ typedef struct With With;
|
| #include "vdbe.h"
|
| #include "pager.h"
|
| #include "pcache.h"
|
| -
|
| #include "os.h"
|
| #include "mutex.h"
|
|
|
| +/* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
|
| +** synchronous setting to EXTRA. It is no longer supported.
|
| +*/
|
| +#ifdef SQLITE_EXTRA_DURABLE
|
| +# warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE
|
| +# define SQLITE_DEFAULT_SYNCHRONOUS 3
|
| +#endif
|
| +
|
| +/*
|
| +** Default synchronous levels.
|
| +**
|
| +** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ
|
| +** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1.
|
| +**
|
| +** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS
|
| +** OFF 1 0
|
| +** NORMAL 2 1
|
| +** FULL 3 2
|
| +** EXTRA 4 3
|
| +**
|
| +** The "PRAGMA synchronous" statement also uses the zero-based numbers.
|
| +** In other words, the zero-based numbers are used for all external interfaces
|
| +** and the one-based values are used internally.
|
| +*/
|
| +#ifndef SQLITE_DEFAULT_SYNCHRONOUS
|
| +# define SQLITE_DEFAULT_SYNCHRONOUS (PAGER_SYNCHRONOUS_FULL-1)
|
| +#endif
|
| +#ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
|
| +# define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
|
| +#endif
|
|
|
| /*
|
| ** Each database file to be accessed by the system is an instance
|
| @@ -996,9 +1143,10 @@ typedef struct With With;
|
| ** databases may be attached.
|
| */
|
| struct Db {
|
| - char *zName; /* Name of this database */
|
| + char *zDbSName; /* Name of this database. (schema name, not filename) */
|
| Btree *pBt; /* The B*Tree structure for this database file */
|
| u8 safety_level; /* How aggressive at syncing data to disk */
|
| + u8 bSyncSet; /* True if "PRAGMA synchronous=N" has been run */
|
| Schema *pSchema; /* Pointer to database schema (possibly shared) */
|
| };
|
|
|
| @@ -1009,7 +1157,7 @@ struct Db {
|
| ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
|
| ** In shared cache mode, a single Schema object can be shared by multiple
|
| ** Btrees that refer to the same underlying BtShared object.
|
| -**
|
| +**
|
| ** Schema objects are automatically deallocated when the last Btree that
|
| ** references them is destroyed. The TEMP Schema is manually freed by
|
| ** sqlite3_close().
|
| @@ -1034,7 +1182,7 @@ struct Schema {
|
| };
|
|
|
| /*
|
| -** These macros can be used to test, set, or clear bits in the
|
| +** These macros can be used to test, set, or clear bits in the
|
| ** Db.pSchema->flags field.
|
| */
|
| #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
|
| @@ -1083,8 +1231,8 @@ struct Schema {
|
| ** lookaside allocations are not used to construct the schema objects.
|
| */
|
| struct Lookaside {
|
| + u32 bDisable; /* Only operate the lookaside when zero */
|
| u16 sz; /* Size of each buffer in bytes */
|
| - u8 bEnabled; /* False to disable new lookaside allocations */
|
| u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */
|
| int nOut; /* Number of buffers currently checked out */
|
| int mxOut; /* Highwater mark for nOut */
|
| @@ -1098,13 +1246,15 @@ struct LookasideSlot {
|
| };
|
|
|
| /*
|
| -** A hash table for function definitions.
|
| +** A hash table for built-in function definitions. (Application-defined
|
| +** functions use a regular table table from hash.h.)
|
| **
|
| ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
|
| -** Collisions are on the FuncDef.pHash chain.
|
| +** Collisions are on the FuncDef.u.pHash chain.
|
| */
|
| +#define SQLITE_FUNC_HASH_SZ 23
|
| struct FuncDefHash {
|
| - FuncDef *a[23]; /* Hash table for functions */
|
| + FuncDef *a[SQLITE_FUNC_HASH_SZ]; /* Hash table for functions */
|
| };
|
|
|
| #ifdef SQLITE_USER_AUTHENTICATION
|
| @@ -1145,6 +1295,15 @@ void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
|
| const char*);
|
| #endif
|
|
|
| +#ifndef SQLITE_OMIT_DEPRECATED
|
| +/* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
|
| +** in the style of sqlite3_trace()
|
| +*/
|
| +#define SQLITE_TRACE_LEGACY 0x80
|
| +#else
|
| +#define SQLITE_TRACE_LEGACY 0
|
| +#endif /* SQLITE_OMIT_DEPRECATED */
|
| +
|
|
|
| /*
|
| ** Each database connection is an instance of the following structure.
|
| @@ -1162,16 +1321,20 @@ struct sqlite3 {
|
| unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */
|
| int errCode; /* Most recent error code (SQLITE_*) */
|
| int errMask; /* & result codes with this before returning */
|
| + int iSysErrno; /* Errno value from last system error */
|
| u16 dbOptFlags; /* Flags to enable/disable optimizations */
|
| u8 enc; /* Text encoding */
|
| u8 autoCommit; /* The auto-commit flag. */
|
| u8 temp_store; /* 1: file 2: memory 0: default */
|
| u8 mallocFailed; /* True if we have seen a malloc failure */
|
| + u8 bBenignMalloc; /* Do not require OOMs if true */
|
| u8 dfltLockMode; /* Default locking-mode for attached dbs */
|
| signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */
|
| u8 suppressErr; /* Do not issue error messages if true */
|
| u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
|
| u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
|
| + u8 mTrace; /* zero or more SQLITE_TRACE flags */
|
| + u8 skipBtreeMutex; /* True if no shared-cache backends */
|
| int nextPagesize; /* Pagesize after VACUUM if >0 */
|
| u32 magic; /* Magic number for detect library misuse */
|
| int nChange; /* Value returned by sqlite3_changes() */
|
| @@ -1192,16 +1355,23 @@ struct sqlite3 {
|
| int nVDestroy; /* Number of active OP_VDestroy operations */
|
| int nExtension; /* Number of loaded extensions */
|
| void **aExtension; /* Array of shared library handles */
|
| - void (*xTrace)(void*,const char*); /* Trace function */
|
| + int (*xTrace)(u32,void*,void*,void*); /* Trace function */
|
| void *pTraceArg; /* Argument to the trace function */
|
| void (*xProfile)(void*,const char*,u64); /* Profiling function */
|
| void *pProfileArg; /* Argument to profile function */
|
| - void *pCommitArg; /* Argument to xCommitCallback() */
|
| + void *pCommitArg; /* Argument to xCommitCallback() */
|
| int (*xCommitCallback)(void*); /* Invoked at every commit. */
|
| - void *pRollbackArg; /* Argument to xRollbackCallback() */
|
| + void *pRollbackArg; /* Argument to xRollbackCallback() */
|
| void (*xRollbackCallback)(void*); /* Invoked at every commit. */
|
| void *pUpdateArg;
|
| void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
|
| +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
|
| + void *pPreUpdateArg; /* First argument to xPreUpdateCallback */
|
| + void (*xPreUpdateCallback)( /* Registered using sqlite3_preupdate_hook() */
|
| + void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64
|
| + );
|
| + PreUpdate *pPreUpdate; /* Context for active pre-update callback */
|
| +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
|
| #ifndef SQLITE_OMIT_WAL
|
| int (*xWalCallback)(void *, sqlite3 *, const char *, int);
|
| void *pWalArg;
|
| @@ -1231,7 +1401,7 @@ struct sqlite3 {
|
| VTable **aVTrans; /* Virtual tables with open transactions */
|
| VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
|
| #endif
|
| - FuncDefHash aFunc; /* Hash table of connection functions */
|
| + Hash aFunc; /* Hash table of connection functions */
|
| Hash aCollSeq; /* All collating sequences */
|
| BusyHandler busyHandler; /* Busy callback */
|
| Db aDbStatic[2]; /* Static space for the 2 default backends */
|
| @@ -1243,8 +1413,8 @@ struct sqlite3 {
|
| i64 nDeferredImmCons; /* Net deferred immediate constraints */
|
| int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
|
| #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
|
| - /* The following variables are all protected by the STATIC_MASTER
|
| - ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
|
| + /* The following variables are all protected by the STATIC_MASTER
|
| + ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
|
| **
|
| ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
|
| ** unlock so that it can proceed.
|
| @@ -1272,13 +1442,18 @@ struct sqlite3 {
|
|
|
| /*
|
| ** Possible values for the sqlite3.flags.
|
| +**
|
| +** Value constraints (enforced via assert()):
|
| +** SQLITE_FullFSync == PAGER_FULLFSYNC
|
| +** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC
|
| +** SQLITE_CacheSpill == PAGER_CACHE_SPILL
|
| */
|
| #define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */
|
| #define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */
|
| -#define SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */
|
| -#define SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */
|
| -#define SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */
|
| -#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */
|
| +#define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */
|
| +#define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */
|
| +#define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */
|
| +#define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */
|
| #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
|
| #define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */
|
| /* DELETE, or UPDATE and return */
|
| @@ -1299,12 +1474,15 @@ struct sqlite3 {
|
| #define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */
|
| #define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */
|
| #define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */
|
| -#define SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */
|
| -#define SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */
|
| -#define SQLITE_QueryOnly 0x02000000 /* Disable database changes */
|
| -#define SQLITE_VdbeEQP 0x04000000 /* Debug EXPLAIN QUERY PLAN */
|
| -#define SQLITE_Vacuum 0x08000000 /* Currently in a VACUUM */
|
| -#define SQLITE_CellSizeCk 0x10000000 /* Check btree cell sizes on load */
|
| +#define SQLITE_LoadExtFunc 0x00800000 /* Enable load_extension() SQL func */
|
| +#define SQLITE_EnableTrigger 0x01000000 /* True to enable triggers */
|
| +#define SQLITE_DeferFKs 0x02000000 /* Defer all FK constraints */
|
| +#define SQLITE_QueryOnly 0x04000000 /* Disable database changes */
|
| +#define SQLITE_VdbeEQP 0x08000000 /* Debug EXPLAIN QUERY PLAN */
|
| +#define SQLITE_Vacuum 0x10000000 /* Currently in a VACUUM */
|
| +#define SQLITE_CellSizeCk 0x20000000 /* Check btree cell sizes on load */
|
| +#define SQLITE_Fts3Tokenizer 0x40000000 /* Enable fts3_tokenizer(2) */
|
| +#define SQLITE_NoCkptOnClose 0x80000000 /* No checkpoint on close()/DETACH */
|
|
|
|
|
| /*
|
| @@ -1330,13 +1508,8 @@ struct sqlite3 {
|
| /*
|
| ** Macros for testing whether or not optimizations are enabled or disabled.
|
| */
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
|
| #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
|
| -#else
|
| -#define OptimizationDisabled(db, mask) 0
|
| -#define OptimizationEnabled(db, mask) 1
|
| -#endif
|
|
|
| /*
|
| ** Return true if it OK to factor constant expressions into the initialization
|
| @@ -1358,28 +1531,33 @@ struct sqlite3 {
|
|
|
| /*
|
| ** Each SQL function is defined by an instance of the following
|
| -** structure. A pointer to this structure is stored in the sqlite.aFunc
|
| -** hash table. When multiple functions have the same name, the hash table
|
| -** points to a linked list of these structures.
|
| +** structure. For global built-in functions (ex: substr(), max(), count())
|
| +** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
|
| +** For per-connection application-defined functions, a pointer to this
|
| +** structure is held in the db->aHash hash table.
|
| +**
|
| +** The u.pHash field is used by the global built-ins. The u.pDestructor
|
| +** field is used by per-connection app-def functions.
|
| */
|
| struct FuncDef {
|
| - i16 nArg; /* Number of arguments. -1 means unlimited */
|
| + i8 nArg; /* Number of arguments. -1 means unlimited */
|
| u16 funcFlags; /* Some combination of SQLITE_FUNC_* */
|
| void *pUserData; /* User data parameter */
|
| FuncDef *pNext; /* Next function with same name */
|
| - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
|
| - void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
|
| - void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
|
| - char *zName; /* SQL name of the function. */
|
| - FuncDef *pHash; /* Next with a different name but the same hash */
|
| - FuncDestructor *pDestructor; /* Reference counted destructor function */
|
| + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
|
| + void (*xFinalize)(sqlite3_context*); /* Agg finalizer */
|
| + const char *zName; /* SQL name of the function. */
|
| + union {
|
| + FuncDef *pHash; /* Next with a different name but the same hash */
|
| + FuncDestructor *pDestructor; /* Reference counted destructor function */
|
| + } u;
|
| };
|
|
|
| /*
|
| ** This structure encapsulates a user-function destructor callback (as
|
| ** configured using create_function_v2()) and a reference counter. When
|
| ** create_function_v2() is called to create a function with a destructor,
|
| -** a single object of this type is allocated. FuncDestructor.nRef is set to
|
| +** a single object of this type is allocated. FuncDestructor.nRef is set to
|
| ** the number of FuncDef objects created (either 1 or 3, depending on whether
|
| ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
|
| ** member of each of the new FuncDef objects is set to point to the allocated
|
| @@ -1400,6 +1578,13 @@ struct FuncDestructor {
|
| ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And
|
| ** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There
|
| ** are assert() statements in the code to verify this.
|
| +**
|
| +** Value constraints (enforced via assert()):
|
| +** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg
|
| +** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG
|
| +** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG
|
| +** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API
|
| +** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API
|
| */
|
| #define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
|
| #define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */
|
| @@ -1415,16 +1600,17 @@ struct FuncDestructor {
|
| #define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
|
| #define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a
|
| ** single query - might change over time */
|
| +#define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
|
|
|
| /*
|
| ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
|
| ** used to create the initializers for the FuncDef structures.
|
| **
|
| ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
|
| -** Used to create a scalar function definition of a function zName
|
| +** Used to create a scalar function definition of a function zName
|
| ** implemented by C function xFunc that accepts nArg arguments. The
|
| ** value passed as iArg is cast to a (void*) and made available
|
| -** as the user-data (sqlite3_user_data()) for the function. If
|
| +** as the user-data (sqlite3_user_data()) for the function. If
|
| ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
|
| **
|
| ** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
|
| @@ -1443,8 +1629,8 @@ struct FuncDestructor {
|
| ** FUNCTION().
|
| **
|
| ** LIKEFUNC(zName, nArg, pArg, flags)
|
| -** Used to create a scalar function definition of a function zName
|
| -** that accepts nArg arguments and is implemented by a call to C
|
| +** Used to create a scalar function definition of a function zName
|
| +** that accepts nArg arguments and is implemented by a call to C
|
| ** function likeFunc. Argument pArg is cast to a (void *) and made
|
| ** available as the function user-data (sqlite3_user_data()). The
|
| ** FuncDef.flags variable is set to the value passed as the flags
|
| @@ -1452,28 +1638,28 @@ struct FuncDestructor {
|
| */
|
| #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
|
| {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
|
| - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
|
| + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
|
| #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
|
| {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
|
| - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
|
| + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
|
| #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
|
| {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
|
| - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
|
| + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
|
| #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
|
| {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
|
| - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
|
| + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} }
|
| #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
|
| {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
|
| - pArg, 0, xFunc, 0, 0, #zName, 0, 0}
|
| + pArg, 0, xFunc, 0, #zName, }
|
| #define LIKEFUNC(zName, nArg, arg, flags) \
|
| {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
|
| - (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
|
| + (void *)arg, 0, likeFunc, 0, #zName, {0} }
|
| #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
|
| {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
|
| - SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
|
| + SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
|
| #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
|
| {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
|
| - SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
|
| + SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}}
|
|
|
| /*
|
| ** All current savepoints are stored in a linked list starting at
|
| @@ -1515,10 +1701,8 @@ struct Module {
|
| ** of this structure.
|
| */
|
| struct Column {
|
| - char *zName; /* Name of this column */
|
| + char *zName; /* Name of this column, \000, then the type */
|
| Expr *pDflt; /* Default value of this column */
|
| - char *zDflt; /* Original text of the default value */
|
| - char *zType; /* Data type for this column */
|
| char *zColl; /* Collating sequence. If NULL, use the default */
|
| u8 notNull; /* An OE_ code for handling a NOT NULL constraint */
|
| char affinity; /* One of the SQLITE_AFF_... values */
|
| @@ -1530,6 +1714,7 @@ struct Column {
|
| */
|
| #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
|
| #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
|
| +#define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */
|
|
|
| /*
|
| ** A "Collating Sequence" is defined by an instance of the following
|
| @@ -1560,7 +1745,7 @@ struct CollSeq {
|
| **
|
| ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
|
| ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
|
| -** the speed a little by numbering the values consecutively.
|
| +** the speed a little by numbering the values consecutively.
|
| **
|
| ** But rather than start with 0 or 1, we begin with 'A'. That way,
|
| ** when multiple affinity types are concatenated into a string and
|
| @@ -1579,7 +1764,7 @@ struct CollSeq {
|
|
|
| /*
|
| ** The SQLITE_AFF_MASK values masks off the significant bits of an
|
| -** affinity value.
|
| +** affinity value.
|
| */
|
| #define SQLITE_AFF_MASK 0x47
|
|
|
| @@ -1592,6 +1777,7 @@ struct CollSeq {
|
| ** operator is NULL. It is added to certain comparison operators to
|
| ** prove that the operands are always NOT NULL.
|
| */
|
| +#define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */
|
| #define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
|
| #define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */
|
| #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
|
| @@ -1599,20 +1785,20 @@ struct CollSeq {
|
|
|
| /*
|
| ** An object of this type is created for each virtual table present in
|
| -** the database schema.
|
| +** the database schema.
|
| **
|
| ** If the database schema is shared, then there is one instance of this
|
| ** structure for each database connection (sqlite3*) that uses the shared
|
| ** schema. This is because each database connection requires its own unique
|
| -** instance of the sqlite3_vtab* handle used to access the virtual table
|
| -** implementation. sqlite3_vtab* handles can not be shared between
|
| -** database connections, even when the rest of the in-memory database
|
| +** instance of the sqlite3_vtab* handle used to access the virtual table
|
| +** implementation. sqlite3_vtab* handles can not be shared between
|
| +** database connections, even when the rest of the in-memory database
|
| ** schema is shared, as the implementation often stores the database
|
| ** connection handle passed to it via the xConnect() or xCreate() method
|
| ** during initialization internally. This database connection handle may
|
| -** then be used by the virtual table implementation to access real tables
|
| -** within the database. So that they appear as part of the callers
|
| -** transaction, these accesses need to be made via the same database
|
| +** then be used by the virtual table implementation to access real tables
|
| +** within the database. So that they appear as part of the callers
|
| +** transaction, these accesses need to be made via the same database
|
| ** connection as that used to execute SQL operations on the virtual table.
|
| **
|
| ** All VTable objects that correspond to a single table in a shared
|
| @@ -1624,19 +1810,19 @@ struct CollSeq {
|
| ** sqlite3_vtab* handle in the compiled query.
|
| **
|
| ** When an in-memory Table object is deleted (for example when the
|
| -** schema is being reloaded for some reason), the VTable objects are not
|
| -** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
|
| +** schema is being reloaded for some reason), the VTable objects are not
|
| +** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
|
| ** immediately. Instead, they are moved from the Table.pVTable list to
|
| ** another linked list headed by the sqlite3.pDisconnect member of the
|
| -** corresponding sqlite3 structure. They are then deleted/xDisconnected
|
| +** corresponding sqlite3 structure. They are then deleted/xDisconnected
|
| ** next time a statement is prepared using said sqlite3*. This is done
|
| ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
|
| ** Refer to comments above function sqlite3VtabUnlockList() for an
|
| ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
|
| ** list without holding the corresponding sqlite3.mutex mutex.
|
| **
|
| -** The memory for objects of this type is always allocated by
|
| -** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
|
| +** The memory for objects of this type is always allocated by
|
| +** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
|
| ** the first argument.
|
| */
|
| struct VTable {
|
| @@ -1663,9 +1849,9 @@ struct Table {
|
| ExprList *pCheck; /* All CHECK constraints */
|
| /* ... also used as column name list in a VIEW */
|
| int tnum; /* Root BTree page for this table */
|
| + u32 nTabRef; /* Number of pointers to this Table */
|
| i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */
|
| i16 nCol; /* Number of columns in this table */
|
| - u16 nRef; /* Number of pointers to this Table */
|
| LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
|
| LogEst szTabRow; /* Estimated size of each table row in bytes */
|
| #ifdef SQLITE_ENABLE_COSTMULT
|
| @@ -1804,7 +1990,7 @@ struct FKey {
|
| ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
|
| ** referenced table row is propagated into the row that holds the
|
| ** foreign key.
|
| -**
|
| +**
|
| ** The following symbolic values are used to record which type
|
| ** of action to take.
|
| */
|
| @@ -1825,7 +2011,7 @@ struct FKey {
|
|
|
| /*
|
| ** An instance of the following structure is passed as the first
|
| -** argument to sqlite3VdbeKeyCompare and is used to control the
|
| +** argument to sqlite3VdbeKeyCompare and is used to control the
|
| ** comparison of the two index keys.
|
| **
|
| ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
|
| @@ -1866,7 +2052,7 @@ struct KeyInfo {
|
| ** The key comparison functions actually return default_rc when they find
|
| ** an equals comparison. default_rc can be -1, 0, or +1. If there are
|
| ** multiple entries in the b-tree with the same key (when only looking
|
| -** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
|
| +** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
|
| ** cause the search to find the last match, or +1 to cause the search to
|
| ** find the first match.
|
| **
|
| @@ -1903,7 +2089,7 @@ struct UnpackedRecord {
|
| ** In the Table structure describing Ex1, nCol==3 because there are
|
| ** three columns in the table. In the Index structure describing
|
| ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
|
| -** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
|
| +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
|
| ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
|
| ** The second column to be indexed (c1) has an index of 0 in
|
| ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
|
| @@ -1911,7 +2097,7 @@ struct UnpackedRecord {
|
| ** The Index.onError field determines whether or not the indexed columns
|
| ** must be unique and what to do if they are not. When Index.onError=OE_None,
|
| ** it means this is not a unique index. Otherwise it is a unique index
|
| -** and the value of Index.onError indicate the which conflict resolution
|
| +** and the value of Index.onError indicate the which conflict resolution
|
| ** algorithm to employ whenever an attempt is made to insert a non-unique
|
| ** element.
|
| **
|
| @@ -1976,7 +2162,7 @@ struct Index {
|
| #define XN_EXPR (-2) /* Indexed column is an expression */
|
|
|
| /*
|
| -** Each sample stored in the sqlite_stat3 table is represented in memory
|
| +** Each sample stored in the sqlite_stat3 table is represented in memory
|
| ** using a structure of this type. See documentation at the top of the
|
| ** analyze.c source file for additional information.
|
| */
|
| @@ -2071,9 +2257,9 @@ typedef int ynVar;
|
| ** to represent the greater-than-or-equal-to operator in the expression
|
| ** tree.
|
| **
|
| -** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
|
| +** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
|
| ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
|
| -** the expression is a variable (TK_VARIABLE), then Expr.token contains the
|
| +** the expression is a variable (TK_VARIABLE), then Expr.token contains the
|
| ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
|
| ** then Expr.token contains the name of the function.
|
| **
|
| @@ -2084,7 +2270,7 @@ typedef int ynVar;
|
| ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
|
| ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
|
| ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
|
| -** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
|
| +** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
|
| ** valid.
|
| **
|
| ** An expression of the form ID or ID.ID refers to a column in a table.
|
| @@ -2095,8 +2281,8 @@ typedef int ynVar;
|
| ** value is also stored in the Expr.iAgg column in the aggregate so that
|
| ** it can be accessed after all aggregates are computed.
|
| **
|
| -** If the expression is an unbound variable marker (a question mark
|
| -** character '?' in the original SQL) then the Expr.iTable holds the index
|
| +** If the expression is an unbound variable marker (a question mark
|
| +** character '?' in the original SQL) then the Expr.iTable holds the index
|
| ** number for that variable.
|
| **
|
| ** If the expression is a subquery then Expr.iColumn holds an integer
|
| @@ -2135,7 +2321,7 @@ struct Expr {
|
|
|
| /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
|
| ** space is allocated for the fields below this point. An attempt to
|
| - ** access them will result in a segfault or malfunction.
|
| + ** access them will result in a segfault or malfunction.
|
| *********************************************************************/
|
|
|
| Expr *pLeft; /* Left subnode */
|
| @@ -2156,9 +2342,11 @@ struct Expr {
|
| int iTable; /* TK_COLUMN: cursor number of table holding column
|
| ** TK_REGISTER: register number
|
| ** TK_TRIGGER: 1 -> new, 0 -> old
|
| - ** EP_Unlikely: 134217728 times likelihood */
|
| + ** EP_Unlikely: 134217728 times likelihood
|
| + ** TK_SELECT: 1st register of result vector */
|
| ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
|
| - ** TK_VARIABLE: variable number (always >= 1). */
|
| + ** TK_VARIABLE: variable number (always >= 1).
|
| + ** TK_SELECT_COLUMN: column of the result vector */
|
| i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
|
| i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */
|
| u8 op2; /* TK_REGISTER: original value of Expr.op
|
| @@ -2194,6 +2382,7 @@ struct Expr {
|
| #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
|
| #define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
|
| #define EP_Alias 0x400000 /* Is an alias for a result set column */
|
| +#define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
|
|
|
| /*
|
| ** Combinations of two or more EP_* flags
|
| @@ -2201,7 +2390,7 @@ struct Expr {
|
| #define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */
|
|
|
| /*
|
| -** These macros can be used to test, set, or clear bits in the
|
| +** These macros can be used to test, set, or clear bits in the
|
| ** Expr.flags field.
|
| */
|
| #define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
|
| @@ -2220,8 +2409,8 @@ struct Expr {
|
| #endif
|
|
|
| /*
|
| -** Macros to determine the number of bytes required by a normal Expr
|
| -** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
|
| +** Macros to determine the number of bytes required by a normal Expr
|
| +** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
|
| ** and an Expr struct with the EP_TokenOnly flag set.
|
| */
|
| #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
|
| @@ -2229,7 +2418,7 @@ struct Expr {
|
| #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
|
|
|
| /*
|
| -** Flags passed to the sqlite3ExprDup() function. See the header comment
|
| +** Flags passed to the sqlite3ExprDup() function. See the header comment
|
| ** above sqlite3ExprDup() for details.
|
| */
|
| #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
|
| @@ -2311,7 +2500,11 @@ struct IdList {
|
| ** tables in a join to 32 instead of 64. But it also reduces the size
|
| ** of the library by 738 bytes on ix86.
|
| */
|
| -typedef u64 Bitmask;
|
| +#ifdef SQLITE_BITMASK_TYPE
|
| + typedef SQLITE_BITMASK_TYPE Bitmask;
|
| +#else
|
| + typedef u64 Bitmask;
|
| +#endif
|
|
|
| /*
|
| ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
|
| @@ -2323,6 +2516,7 @@ typedef u64 Bitmask;
|
| */
|
| #define MASKBIT(n) (((Bitmask)1)<<(n))
|
| #define MASKBIT32(n) (((unsigned int)1)<<(n))
|
| +#define ALLBITS ((Bitmask)-1)
|
|
|
| /*
|
| ** The following structure describes the FROM clause of a SELECT statement.
|
| @@ -2357,7 +2551,7 @@ struct SrcList {
|
| int regReturn; /* Register holding return address of addrFillSub */
|
| int regResult; /* Registers holding results of a co-routine */
|
| struct {
|
| - u8 jointype; /* Type of join between this able and the previous */
|
| + u8 jointype; /* Type of join between this table and the previous */
|
| unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */
|
| unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */
|
| unsigned isTabFunc :1; /* True if table-valued-function syntax */
|
| @@ -2395,22 +2589,28 @@ struct SrcList {
|
| /*
|
| ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
|
| ** and the WhereInfo.wctrlFlags member.
|
| +**
|
| +** Value constraints (enforced via assert()):
|
| +** WHERE_USE_LIMIT == SF_FixedLimit
|
| */
|
| #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
|
| #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
|
| #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
|
| #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
|
| -#define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */
|
| -#define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */
|
| -#define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */
|
| -#define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */
|
| -#define WHERE_NO_AUTOINDEX 0x0080 /* Disallow automatic indexes */
|
| -#define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */
|
| -#define WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */
|
| -#define WHERE_WANT_DISTINCT 0x0400 /* All output needs to be distinct */
|
| -#define WHERE_SORTBYGROUP 0x0800 /* Support sqlite3WhereIsSorted() */
|
| -#define WHERE_REOPEN_IDX 0x1000 /* Try to use OP_ReopenIdx */
|
| -#define WHERE_ONEPASS_MULTIROW 0x2000 /* ONEPASS is ok with multiple rows */
|
| +#define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */
|
| +#define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */
|
| +#define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of
|
| + ** the OR optimization */
|
| +#define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */
|
| +#define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */
|
| +#define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */
|
| +#define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
|
| +#define WHERE_SEEK_TABLE 0x0400 /* Do not defer seeks on main table */
|
| +#define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
|
| +#define WHERE_SEEK_UNIQ_TABLE 0x1000 /* Do not defer seeks if unique */
|
| + /* 0x2000 not currently used */
|
| +#define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
|
| + /* 0x8000 not currently used */
|
|
|
| /* Allowed return values from sqlite3WhereIsDistinct()
|
| */
|
| @@ -2428,12 +2628,12 @@ struct SrcList {
|
| ** pEList corresponds to the result set of a SELECT and is NULL for
|
| ** other statements.
|
| **
|
| -** NameContexts can be nested. When resolving names, the inner-most
|
| +** NameContexts can be nested. When resolving names, the inner-most
|
| ** context is searched first. If no match is found, the next outer
|
| ** context is checked. If there is still no match, the next context
|
| ** is checked. This process continues until either a match is found
|
| ** or all contexts are check. When a match is found, the nRef member of
|
| -** the context containing the match is incremented.
|
| +** the context containing the match is incremented.
|
| **
|
| ** Each subquery gets a new NameContext. The pNext field points to the
|
| ** NameContext in the parent query. Thus the process of scanning the
|
| @@ -2454,16 +2654,18 @@ struct NameContext {
|
| /*
|
| ** Allowed values for the NameContext, ncFlags field.
|
| **
|
| -** Note: NC_MinMaxAgg must have the same value as SF_MinMaxAgg and
|
| -** SQLITE_FUNC_MINMAX.
|
| -**
|
| +** Value constraints (all checked via assert()):
|
| +** NC_HasAgg == SF_HasAgg
|
| +** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
|
| +**
|
| */
|
| #define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */
|
| -#define NC_HasAgg 0x0002 /* One or more aggregate functions seen */
|
| +#define NC_PartIdx 0x0002 /* True if resolving a partial index WHERE */
|
| #define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */
|
| #define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */
|
| -#define NC_PartIdx 0x0010 /* True if resolving a partial index WHERE */
|
| +#define NC_HasAgg 0x0010 /* One or more aggregate functions seen */
|
| #define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */
|
| +#define NC_VarSelect 0x0040 /* A correlated subquery has been seen */
|
| #define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */
|
|
|
| /*
|
| @@ -2489,13 +2691,13 @@ struct NameContext {
|
| struct Select {
|
| ExprList *pEList; /* The fields of the result */
|
| u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
|
| - u16 selFlags; /* Various SF_* values */
|
| + LogEst nSelectRow; /* Estimated number of result rows */
|
| + u32 selFlags; /* Various SF_* values */
|
| int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
|
| #if SELECTTRACE_ENABLED
|
| char zSelName[12]; /* Symbolic name of this SELECT use for debugging */
|
| #endif
|
| int addrOpenEphm[2]; /* OP_OpenEphem opcodes related to this select */
|
| - u64 nSelectRow; /* Estimated number of result rows */
|
| SrcList *pSrc; /* The FROM clause */
|
| Expr *pWhere; /* The WHERE clause */
|
| ExprList *pGroupBy; /* The GROUP BY clause */
|
| @@ -2511,23 +2713,30 @@ struct Select {
|
| /*
|
| ** Allowed values for Select.selFlags. The "SF" prefix stands for
|
| ** "Select Flag".
|
| -*/
|
| -#define SF_Distinct 0x0001 /* Output should be DISTINCT */
|
| -#define SF_All 0x0002 /* Includes the ALL keyword */
|
| -#define SF_Resolved 0x0004 /* Identifiers have been resolved */
|
| -#define SF_Aggregate 0x0008 /* Contains aggregate functions */
|
| -#define SF_UsesEphemeral 0x0010 /* Uses the OpenEphemeral opcode */
|
| -#define SF_Expanded 0x0020 /* sqlite3SelectExpand() called on this */
|
| -#define SF_HasTypeInfo 0x0040 /* FROM subqueries have Table metadata */
|
| -#define SF_Compound 0x0080 /* Part of a compound query */
|
| -#define SF_Values 0x0100 /* Synthesized from VALUES clause */
|
| -#define SF_MultiValue 0x0200 /* Single VALUES term with multiple rows */
|
| -#define SF_NestedFrom 0x0400 /* Part of a parenthesized FROM clause */
|
| -#define SF_MaybeConvert 0x0800 /* Need convertCompoundSelectToSubquery() */
|
| -#define SF_MinMaxAgg 0x1000 /* Aggregate containing min() or max() */
|
| -#define SF_Recursive 0x2000 /* The recursive part of a recursive CTE */
|
| -#define SF_Converted 0x4000 /* By convertCompoundSelectToSubquery() */
|
| -#define SF_IncludeHidden 0x8000 /* Include hidden columns in output */
|
| +**
|
| +** Value constraints (all checked via assert())
|
| +** SF_HasAgg == NC_HasAgg
|
| +** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX
|
| +** SF_FixedLimit == WHERE_USE_LIMIT
|
| +*/
|
| +#define SF_Distinct 0x00001 /* Output should be DISTINCT */
|
| +#define SF_All 0x00002 /* Includes the ALL keyword */
|
| +#define SF_Resolved 0x00004 /* Identifiers have been resolved */
|
| +#define SF_Aggregate 0x00008 /* Contains agg functions or a GROUP BY */
|
| +#define SF_HasAgg 0x00010 /* Contains aggregate functions */
|
| +#define SF_UsesEphemeral 0x00020 /* Uses the OpenEphemeral opcode */
|
| +#define SF_Expanded 0x00040 /* sqlite3SelectExpand() called on this */
|
| +#define SF_HasTypeInfo 0x00080 /* FROM subqueries have Table metadata */
|
| +#define SF_Compound 0x00100 /* Part of a compound query */
|
| +#define SF_Values 0x00200 /* Synthesized from VALUES clause */
|
| +#define SF_MultiValue 0x00400 /* Single VALUES term with multiple rows */
|
| +#define SF_NestedFrom 0x00800 /* Part of a parenthesized FROM clause */
|
| +#define SF_MinMaxAgg 0x01000 /* Aggregate containing min() or max() */
|
| +#define SF_Recursive 0x02000 /* The recursive part of a recursive CTE */
|
| +#define SF_FixedLimit 0x04000 /* nSelectRow set by a constant LIMIT */
|
| +#define SF_MaybeConvert 0x08000 /* Need convertCompoundSelectToSubquery() */
|
| +#define SF_Converted 0x10000 /* By convertCompoundSelectToSubquery() */
|
| +#define SF_IncludeHidden 0x20000 /* Include hidden columns in output */
|
|
|
|
|
| /*
|
| @@ -2535,7 +2744,7 @@ struct Select {
|
| ** by one of the following macros. The "SRT" prefix means "SELECT Result
|
| ** Type".
|
| **
|
| -** SRT_Union Store results as a key in a temporary index
|
| +** SRT_Union Store results as a key in a temporary index
|
| ** identified by pDest->iSDParm.
|
| **
|
| ** SRT_Except Remove results from the temporary index pDest->iSDParm.
|
| @@ -2559,7 +2768,7 @@ struct Select {
|
| ** of the query. This destination implies "LIMIT 1".
|
| **
|
| ** SRT_Set The result must be a single column. Store each
|
| -** row of result as the key in table pDest->iSDParm.
|
| +** row of result as the key in table pDest->iSDParm.
|
| ** Apply the affinity pDest->affSdst before storing
|
| ** results. Used to implement "IN (SELECT ...)".
|
| **
|
| @@ -2619,7 +2828,7 @@ struct Select {
|
| */
|
| struct SelectDest {
|
| u8 eDest; /* How to dispose of the results. On of SRT_* above. */
|
| - char affSdst; /* Affinity used when eDest==SRT_Set */
|
| + char *zAffSdst; /* Affinity used when eDest==SRT_Set */
|
| int iSDParm; /* A parameter used by the eDest disposal method */
|
| int iSdst; /* Base register where results are written */
|
| int nSdst; /* Number of registers allocated */
|
| @@ -2627,11 +2836,11 @@ struct SelectDest {
|
| };
|
|
|
| /*
|
| -** During code generation of statements that do inserts into AUTOINCREMENT
|
| +** During code generation of statements that do inserts into AUTOINCREMENT
|
| ** tables, the following information is attached to the Table.u.autoInc.p
|
| ** pointer of each autoincrement table to record some side information that
|
| ** the code generator needs. We have to keep per-table autoincrement
|
| -** information in case inserts are down within triggers. Triggers do not
|
| +** information in case inserts are done within triggers. Triggers do not
|
| ** normally coordinate their activities, but we do need to coordinate the
|
| ** loading and saving of autoincrement information.
|
| */
|
| @@ -2650,7 +2859,7 @@ struct AutoincInfo {
|
| #endif
|
|
|
| /*
|
| -** At least one instance of the following structure is created for each
|
| +** At least one instance of the following structure is created for each
|
| ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
|
| ** statement. All such objects are stored in the linked list headed at
|
| ** Parse.pTriggerPrg and deleted once statement compilation has been
|
| @@ -2663,7 +2872,7 @@ struct AutoincInfo {
|
| ** values for both pTrigger and orconf.
|
| **
|
| ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
|
| -** accessed (or set to 0 for triggers fired as a result of INSERT
|
| +** accessed (or set to 0 for triggers fired as a result of INSERT
|
| ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
|
| ** a mask of new.* columns used by the program.
|
| */
|
| @@ -2704,7 +2913,7 @@ struct TriggerPrg {
|
| ** is constant but the second part is reset at the beginning and end of
|
| ** each recursion.
|
| **
|
| -** The nTableLock and aTableLock variables are only used if the shared-cache
|
| +** The nTableLock and aTableLock variables are only used if the shared-cache
|
| ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
|
| ** used to store the set of table-locks required by the statement being
|
| ** compiled. Function sqlite3TableLock() is used to add entries to the
|
| @@ -2723,36 +2932,25 @@ struct Parse {
|
| u8 mayAbort; /* True if statement may throw an ABORT exception */
|
| u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */
|
| u8 okConstFactor; /* OK to factor out constants */
|
| - int aTempReg[8]; /* Holding area for temporary registers */
|
| + u8 disableLookaside; /* Number of times lookaside has been disabled */
|
| + u8 nColCache; /* Number of entries in aColCache[] */
|
| int nRangeReg; /* Size of the temporary register block */
|
| int iRangeReg; /* First register in temporary register block */
|
| int nErr; /* Number of errors seen */
|
| int nTab; /* Number of previously allocated VDBE cursors */
|
| int nMem; /* Number of memory cells used so far */
|
| - int nSet; /* Number of sets used so far */
|
| - int nOnce; /* Number of OP_Once instructions so far */
|
| int nOpAlloc; /* Number of slots allocated for Vdbe.aOp[] */
|
| int szOpAlloc; /* Bytes of memory space allocated for Vdbe.aOp[] */
|
| - int iFixedOp; /* Never back out opcodes iFixedOp-1 or earlier */
|
| int ckBase; /* Base register of data during check constraints */
|
| int iSelfTab; /* Table of an index whose exprs are being coded */
|
| int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
|
| int iCacheCnt; /* Counter used to generate aColCache[].lru values */
|
| int nLabel; /* Number of labels used */
|
| int *aLabel; /* Space to hold the labels */
|
| - struct yColCache {
|
| - int iTable; /* Table cursor number */
|
| - i16 iColumn; /* Table column number */
|
| - u8 tempReg; /* iReg is a temp register that needs to be freed */
|
| - int iLevel; /* Nesting level */
|
| - int iReg; /* Reg with value of this column. 0 means none. */
|
| - int lru; /* Least recently used entry has the smallest value */
|
| - } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
|
| ExprList *pConstExpr;/* Constant expressions */
|
| Token constraintName;/* Name of the constraint currently being parsed */
|
| yDbMask writeMask; /* Start a write transaction on these databases */
|
| yDbMask cookieMask; /* Bitmask of schema verified databases */
|
| - int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */
|
| int regRowid; /* Register holding rowid of CREATE TABLE entry */
|
| int regRoot; /* Register holding root page number for new objects */
|
| int nMaxArg; /* Max args passed to user function by sub-program */
|
| @@ -2765,8 +2963,6 @@ struct Parse {
|
| TableLock *aTableLock; /* Required table locks for shared-cache mode */
|
| #endif
|
| AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */
|
| -
|
| - /* Information used while coding trigger programs. */
|
| Parse *pToplevel; /* Parse structure for main program (or NULL) */
|
| Table *pTriggerTab; /* Table triggers are being coded for */
|
| int addrCrTab; /* Address of OP_CreateTable opcode on CREATE TABLE */
|
| @@ -2777,35 +2973,50 @@ struct Parse {
|
| u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */
|
| u8 disableTriggers; /* True to disable triggers */
|
|
|
| + /**************************************************************************
|
| + ** Fields above must be initialized to zero. The fields that follow,
|
| + ** down to the beginning of the recursive section, do not need to be
|
| + ** initialized as they will be set before being used. The boundary is
|
| + ** determined by offsetof(Parse,aColCache).
|
| + **************************************************************************/
|
| +
|
| + struct yColCache {
|
| + int iTable; /* Table cursor number */
|
| + i16 iColumn; /* Table column number */
|
| + u8 tempReg; /* iReg is a temp register that needs to be freed */
|
| + int iLevel; /* Nesting level */
|
| + int iReg; /* Reg with value of this column. 0 means none. */
|
| + int lru; /* Least recently used entry has the smallest value */
|
| + } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
|
| + int aTempReg[8]; /* Holding area for temporary registers */
|
| + Token sNameToken; /* Token with unqualified schema object name */
|
| +
|
| /************************************************************************
|
| ** Above is constant between recursions. Below is reset before and after
|
| ** each recursion. The boundary between these two regions is determined
|
| - ** using offsetof(Parse,nVar) so the nVar field must be the first field
|
| - ** in the recursive region.
|
| + ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
|
| + ** first field in the recursive region.
|
| ************************************************************************/
|
|
|
| - int nVar; /* Number of '?' variables seen in the SQL so far */
|
| - int nzVar; /* Number of available slots in azVar[] */
|
| + Token sLastToken; /* The last token parsed */
|
| + ynVar nVar; /* Number of '?' variables seen in the SQL so far */
|
| u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */
|
| u8 explain; /* True if the EXPLAIN flag is found on the query */
|
| #ifndef SQLITE_OMIT_VIRTUALTABLE
|
| u8 declareVtab; /* True if inside sqlite3_declare_vtab() */
|
| int nVtabLock; /* Number of virtual tables to lock */
|
| #endif
|
| - int nAlias; /* Number of aliased result set columns */
|
| int nHeight; /* Expression tree height of current sub-select */
|
| #ifndef SQLITE_OMIT_EXPLAIN
|
| int iSelectId; /* ID of current select for EXPLAIN output */
|
| int iNextSelectId; /* Next available select ID for EXPLAIN output */
|
| #endif
|
| - char **azVar; /* Pointers to names of parameters */
|
| + VList *pVList; /* Mapping between variable names and numbers */
|
| Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */
|
| const char *zTail; /* All SQL text past the last semicolon parsed */
|
| Table *pNewTable; /* A table being constructed by CREATE TABLE */
|
| Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */
|
| const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
|
| - Token sNameToken; /* Token with unqualified schema object name */
|
| - Token sLastToken; /* The last token parsed */
|
| #ifndef SQLITE_OMIT_VIRTUALTABLE
|
| Token sArg; /* Complete text of a module argument */
|
| Table **apVtabLock; /* Pointer to virtual tables needing locking */
|
| @@ -2817,6 +3028,14 @@ struct Parse {
|
| };
|
|
|
| /*
|
| +** Sizes and pointers of various parts of the Parse object.
|
| +*/
|
| +#define PARSE_HDR_SZ offsetof(Parse,aColCache) /* Recursive part w/o aColCache*/
|
| +#define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */
|
| +#define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
|
| +#define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */
|
| +
|
| +/*
|
| ** Return true if currently inside an sqlite3_declare_vtab() call.
|
| */
|
| #ifdef SQLITE_OMIT_VIRTUALTABLE
|
| @@ -2836,27 +3055,40 @@ struct AuthContext {
|
|
|
| /*
|
| ** Bitfield flags for P5 value in various opcodes.
|
| -*/
|
| -#define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */
|
| +**
|
| +** Value constraints (enforced via assert()):
|
| +** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH
|
| +** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF
|
| +** OPFLAG_BULKCSR == BTREE_BULKLOAD
|
| +** OPFLAG_SEEKEQ == BTREE_SEEK_EQ
|
| +** OPFLAG_FORDELETE == BTREE_FORDELETE
|
| +** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION
|
| +** OPFLAG_AUXDELETE == BTREE_AUXDELETE
|
| +*/
|
| +#define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */
|
| + /* Also used in P2 (not P5) of OP_Delete */
|
| #define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
|
| -#define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */
|
| +#define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */
|
| #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
|
| #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
|
| #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
|
| +#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */
|
| #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
|
| #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
|
| #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
|
| #define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
|
| -#define OPFLAG_FORDELETE 0x08 /* OP_Open is opening for-delete csr */
|
| +#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */
|
| #define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */
|
| #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
|
| +#define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */
|
| +#define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */
|
|
|
| /*
|
| * Each trigger present in the database schema is stored as an instance of
|
| - * struct Trigger.
|
| + * struct Trigger.
|
| *
|
| * Pointers to instances of struct Trigger are stored in two ways.
|
| - * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
|
| + * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
|
| * database). This allows Trigger structures to be retrieved by name.
|
| * 2. All triggers associated with a single table form a linked list, using the
|
| * pNext member of struct Trigger. A pointer to the first element of the
|
| @@ -2882,7 +3114,7 @@ struct Trigger {
|
|
|
| /*
|
| ** A trigger is either a BEFORE or an AFTER trigger. The following constants
|
| -** determine which.
|
| +** determine which.
|
| **
|
| ** If there are multiple triggers, you might of some BEFORE and some AFTER.
|
| ** In that cases, the constants below can be ORed together.
|
| @@ -2892,15 +3124,15 @@ struct Trigger {
|
|
|
| /*
|
| * An instance of struct TriggerStep is used to store a single SQL statement
|
| - * that is a part of a trigger-program.
|
| + * that is a part of a trigger-program.
|
| *
|
| * Instances of struct TriggerStep are stored in a singly linked list (linked
|
| - * using the "pNext" member) referenced by the "step_list" member of the
|
| + * using the "pNext" member) referenced by the "step_list" member of the
|
| * associated struct Trigger instance. The first element of the linked list is
|
| * the first step of the trigger-program.
|
| - *
|
| + *
|
| * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
|
| - * "SELECT" statement. The meanings of the other members is determined by the
|
| + * "SELECT" statement. The meanings of the other members is determined by the
|
| * value of "op" as follows:
|
| *
|
| * (op == TK_INSERT)
|
| @@ -2910,7 +3142,7 @@ struct Trigger {
|
| * zTarget -> Dequoted name of the table to insert into.
|
| * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
|
| * this stores values to be inserted. Otherwise NULL.
|
| - * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
|
| + * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
|
| * statement, then this stores the column-names to be
|
| * inserted into.
|
| *
|
| @@ -2918,7 +3150,7 @@ struct Trigger {
|
| * zTarget -> Dequoted name of the table to delete from.
|
| * pWhere -> The WHERE clause of the DELETE statement if one is specified.
|
| * Otherwise NULL.
|
| - *
|
| + *
|
| * (op == TK_UPDATE)
|
| * zTarget -> Dequoted name of the table to update.
|
| * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
|
| @@ -2926,7 +3158,7 @@ struct Trigger {
|
| * pExprList -> A list of the columns to update and the expressions to update
|
| * them to. See sqlite3Update() documentation of "pChanges"
|
| * argument.
|
| - *
|
| + *
|
| */
|
| struct TriggerStep {
|
| u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
|
| @@ -2944,7 +3176,7 @@ struct TriggerStep {
|
| /*
|
| ** The following structure contains information used by the sqliteFix...
|
| ** routines as they walk the parse tree to make database references
|
| -** explicit.
|
| +** explicit.
|
| */
|
| typedef struct DbFixer DbFixer;
|
| struct DbFixer {
|
| @@ -2968,10 +3200,16 @@ struct StrAccum {
|
| u32 nAlloc; /* Amount of space allocated in zText */
|
| u32 mxAlloc; /* Maximum allowed allocation. 0 for no malloc usage */
|
| u8 accError; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
|
| - u8 bMalloced; /* zText points to allocated space */
|
| + u8 printfFlags; /* SQLITE_PRINTF flags below */
|
| };
|
| #define STRACCUM_NOMEM 1
|
| #define STRACCUM_TOOBIG 2
|
| +#define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */
|
| +#define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */
|
| +#define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */
|
| +
|
| +#define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
|
| +
|
|
|
| /*
|
| ** A pointer to this structure is used to communicate information
|
| @@ -2999,6 +3237,7 @@ struct Sqlite3Config {
|
| int neverCorrupt; /* Database is always well-formed */
|
| int szLookaside; /* Default lookaside buffer size */
|
| int nLookaside; /* Default lookaside buffer count */
|
| + int nStmtSpill; /* Stmt-journal spill-to-disk threshold */
|
| sqlite3_mem_methods m; /* Low-level memory allocation interface */
|
| sqlite3_mutex_methods mutex; /* Low-level mutex interface */
|
| sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */
|
| @@ -3038,10 +3277,11 @@ struct Sqlite3Config {
|
| void (*xVdbeBranch)(void*,int iSrcLine,u8 eThis,u8 eMx); /* Callback */
|
| void *pVdbeBranchArg; /* 1st argument */
|
| #endif
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifndef SQLITE_UNTESTABLE
|
| int (*xTestCallback)(int); /* Invoked by sqlite3FaultSim() */
|
| #endif
|
| int bLocaltimeFault; /* True to fail localtime() calls */
|
| + int iOnceResetThreshold; /* When to reset OP_Once counters */
|
| };
|
|
|
| /*
|
| @@ -3066,10 +3306,10 @@ struct Sqlite3Config {
|
| ** Context pointer passed down through the tree-walk.
|
| */
|
| struct Walker {
|
| + Parse *pParse; /* Parser context. */
|
| int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */
|
| int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */
|
| void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */
|
| - Parse *pParse; /* Parser context. */
|
| int walkerDepth; /* Number of subqueries */
|
| u8 eCode; /* A small processing code */
|
| union { /* Extra data for callback */
|
| @@ -3079,6 +3319,8 @@ struct Walker {
|
| SrcList *pSrcList; /* FROM clause */
|
| struct SrcCount *pSrcCount; /* Counting column references */
|
| struct CCurHint *pCCurHint; /* Used by codeCursorHint() */
|
| + int *aiCol; /* array of column indexes */
|
| + struct IdxCover *pIdxCover; /* Check for index coverage */
|
| } u;
|
| };
|
|
|
| @@ -3147,7 +3389,23 @@ int sqlite3CantopenError(int);
|
| #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
|
| #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
|
| #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
|
| +#ifdef SQLITE_DEBUG
|
| + int sqlite3NomemError(int);
|
| + int sqlite3IoerrnomemError(int);
|
| +# define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__)
|
| +# define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__)
|
| +#else
|
| +# define SQLITE_NOMEM_BKPT SQLITE_NOMEM
|
| +# define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM
|
| +#endif
|
|
|
| +/*
|
| +** FTS3 and FTS4 both require virtual table support
|
| +*/
|
| +#if defined(SQLITE_OMIT_VIRTUALTABLE)
|
| +# undef SQLITE_ENABLE_FTS3
|
| +# undef SQLITE_ENABLE_FTS4
|
| +#endif
|
|
|
| /*
|
| ** FTS4 is really an extension for FTS3. It is enabled using the
|
| @@ -3180,6 +3438,7 @@ int sqlite3CantopenError(int);
|
| # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
|
| # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
|
| # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
|
| +# define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80)
|
| #else
|
| # define sqlite3Toupper(x) toupper((unsigned char)(x))
|
| # define sqlite3Isspace(x) isspace((unsigned char)(x))
|
| @@ -3188,6 +3447,7 @@ int sqlite3CantopenError(int);
|
| # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
|
| # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
|
| # define sqlite3Tolower(x) tolower((unsigned char)(x))
|
| +# define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`')
|
| #endif
|
| #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
|
| int sqlite3IsIdChar(u8);
|
| @@ -3196,8 +3456,9 @@ int sqlite3IsIdChar(u8);
|
| /*
|
| ** Internal function prototypes
|
| */
|
| -#define sqlite3StrICmp sqlite3_stricmp
|
| +int sqlite3StrICmp(const char*,const char*);
|
| int sqlite3Strlen30(const char*);
|
| +char *sqlite3ColumnType(Column*,char*);
|
| #define sqlite3StrNICmp sqlite3_strnicmp
|
|
|
| int sqlite3MallocInit(void);
|
| @@ -3206,6 +3467,7 @@ void *sqlite3Malloc(u64);
|
| void *sqlite3MallocZero(u64);
|
| void *sqlite3DbMallocZero(sqlite3*, u64);
|
| void *sqlite3DbMallocRaw(sqlite3*, u64);
|
| +void *sqlite3DbMallocRawNN(sqlite3*, u64);
|
| char *sqlite3DbStrDup(sqlite3*,const char*);
|
| char *sqlite3DbStrNDup(sqlite3*,const char*, u64);
|
| void *sqlite3Realloc(void*, u64);
|
| @@ -3219,7 +3481,7 @@ void sqlite3ScratchFree(void*);
|
| void *sqlite3PageMalloc(int);
|
| void sqlite3PageFree(void*);
|
| void sqlite3MemSetDefault(void);
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifndef SQLITE_UNTESTABLE
|
| void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
|
| #endif
|
| int sqlite3HeapNearlyFull(void);
|
| @@ -3235,18 +3497,22 @@ int sqlite3HeapNearlyFull(void);
|
| #ifdef SQLITE_USE_ALLOCA
|
| # define sqlite3StackAllocRaw(D,N) alloca(N)
|
| # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
|
| -# define sqlite3StackFree(D,P)
|
| +# define sqlite3StackFree(D,P)
|
| #else
|
| # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
|
| # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
|
| # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
|
| #endif
|
|
|
| -#ifdef SQLITE_ENABLE_MEMSYS3
|
| -const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
|
| -#endif
|
| +/* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they
|
| +** are, disable MEMSYS3
|
| +*/
|
| #ifdef SQLITE_ENABLE_MEMSYS5
|
| const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
|
| +#undef SQLITE_ENABLE_MEMSYS3
|
| +#endif
|
| +#ifdef SQLITE_ENABLE_MEMSYS3
|
| +const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
|
| #endif
|
|
|
|
|
| @@ -3288,10 +3554,8 @@ struct PrintfArguments {
|
| sqlite3_value **apArg; /* The argument values */
|
| };
|
|
|
| -#define SQLITE_PRINTF_INTERNAL 0x01
|
| -#define SQLITE_PRINTF_SQLFUNC 0x02
|
| -void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
|
| -void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
|
| +void sqlite3VXPrintf(StrAccum*, const char*, va_list);
|
| +void sqlite3XPrintf(StrAccum*, const char*, ...);
|
| char *sqlite3MPrintf(sqlite3*,const char*, ...);
|
| char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
|
| #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
|
| @@ -3303,6 +3567,7 @@ char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
|
|
|
| #if defined(SQLITE_DEBUG)
|
| void sqlite3TreeViewExpr(TreeView*, const Expr*, u8);
|
| + void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*);
|
| void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*);
|
| void sqlite3TreeViewSelect(TreeView*, const Select*, u8);
|
| void sqlite3TreeViewWith(TreeView*, const With*, u8);
|
| @@ -3311,7 +3576,8 @@ char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
|
|
|
| void sqlite3SetString(char **, sqlite3*, const char*);
|
| void sqlite3ErrorMsg(Parse*, const char*, ...);
|
| -int sqlite3Dequote(char*);
|
| +void sqlite3Dequote(char*);
|
| +void sqlite3TokenInit(Token*,char*);
|
| int sqlite3KeywordCode(const unsigned char*, int);
|
| int sqlite3RunParser(Parse*, const char*, char **);
|
| void sqlite3FinishCoding(Parse*);
|
| @@ -3320,15 +3586,20 @@ void sqlite3ReleaseTempReg(Parse*,int);
|
| int sqlite3GetTempRange(Parse*,int);
|
| void sqlite3ReleaseTempRange(Parse*,int,int);
|
| void sqlite3ClearTempRegCache(Parse*);
|
| +#ifdef SQLITE_DEBUG
|
| +int sqlite3NoTempsInRange(Parse*,int,int);
|
| +#endif
|
| Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int);
|
| Expr *sqlite3Expr(sqlite3*,int,const char*);
|
| void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
|
| -Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
|
| +Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*);
|
| +void sqlite3PExprAddSelect(Parse*, Expr*, Select*);
|
| Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
|
| Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
|
| -void sqlite3ExprAssignVarNumber(Parse*, Expr*);
|
| +void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32);
|
| void sqlite3ExprDelete(sqlite3*, Expr*);
|
| ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
|
| +ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*);
|
| void sqlite3ExprListSetSortOrder(ExprList*,int);
|
| void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
|
| void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
|
| @@ -3337,13 +3608,16 @@ u32 sqlite3ExprListFlags(const ExprList*);
|
| int sqlite3Init(sqlite3*, char**);
|
| int sqlite3InitCallback(void*, int, char**, char**);
|
| void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| +Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
|
| +#endif
|
| void sqlite3ResetAllSchemasOfConnection(sqlite3*);
|
| void sqlite3ResetOneSchema(sqlite3*,int);
|
| void sqlite3CollapseDatabaseArray(sqlite3*);
|
| -void sqlite3BeginParse(Parse*,int);
|
| void sqlite3CommitInternalChanges(sqlite3*);
|
| void sqlite3DeleteColumnNames(sqlite3*,Table*);
|
| int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);
|
| +void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*);
|
| Table *sqlite3ResultSetOfSelect(Parse*,Select*);
|
| void sqlite3OpenMasterTable(Parse *, int);
|
| Index *sqlite3PrimaryKeyIndex(Table*);
|
| @@ -3354,20 +3628,18 @@ void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
|
| #else
|
| # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
|
| #endif
|
| -void sqlite3AddColumn(Parse*,Token*);
|
| +void sqlite3AddColumn(Parse*,Token*,Token*);
|
| void sqlite3AddNotNull(Parse*, int);
|
| void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
|
| void sqlite3AddCheckConstraint(Parse*, Expr*);
|
| -void sqlite3AddColumnType(Parse*,Token*);
|
| void sqlite3AddDefaultValue(Parse*,ExprSpan*);
|
| void sqlite3AddCollateType(Parse*, Token*);
|
| void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);
|
| int sqlite3ParseUri(const char*,const char*,unsigned int*,
|
| sqlite3_vfs**,char**,char **);
|
| Btree *sqlite3DbNameToBtree(sqlite3*,const char*);
|
| -int sqlite3CodeOnce(Parse *);
|
|
|
| -#ifdef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifdef SQLITE_UNTESTABLE
|
| # define sqlite3FaultSim(X) SQLITE_OK
|
| #else
|
| int sqlite3FaultSim(int);
|
| @@ -3380,7 +3652,7 @@ int sqlite3BitvecSet(Bitvec*, u32);
|
| void sqlite3BitvecClear(Bitvec*, u32, void*);
|
| void sqlite3BitvecDestroy(Bitvec*);
|
| u32 sqlite3BitvecSize(Bitvec*);
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifndef SQLITE_UNTESTABLE
|
| int sqlite3BitvecBuiltinTest(int,int*);
|
| #endif
|
|
|
| @@ -3427,12 +3699,12 @@ void sqlite3SrcListAssignCursors(Parse*, SrcList*);
|
| void sqlite3IdListDelete(sqlite3*, IdList*);
|
| void sqlite3SrcListDelete(sqlite3*, SrcList*);
|
| Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**);
|
| -Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
|
| - Expr*, int, int);
|
| +void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
|
| + Expr*, int, int, u8);
|
| void sqlite3DropIndex(Parse*, SrcList*, int);
|
| int sqlite3Select(Parse*, Select*, SelectDest*);
|
| Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
|
| - Expr*,ExprList*,u16,Expr*,Expr*);
|
| + Expr*,ExprList*,u32,Expr*,Expr*);
|
| void sqlite3SelectDelete(sqlite3*, Select*);
|
| Table *sqlite3SrcListLookup(Parse*, SrcList*);
|
| int sqlite3IsReadOnly(Parse*, Table*, int);
|
| @@ -3444,9 +3716,10 @@ void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
|
| void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
|
| WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int);
|
| void sqlite3WhereEnd(WhereInfo*);
|
| -u64 sqlite3WhereOutputRowCount(WhereInfo*);
|
| +LogEst sqlite3WhereOutputRowCount(WhereInfo*);
|
| int sqlite3WhereIsDistinct(WhereInfo*);
|
| int sqlite3WhereIsOrdered(WhereInfo*);
|
| +int sqlite3WhereOrderedInnerLoop(WhereInfo*);
|
| int sqlite3WhereIsSorted(WhereInfo*);
|
| int sqlite3WhereContinueLabel(WhereInfo*);
|
| int sqlite3WhereBreakLabel(WhereInfo*);
|
| @@ -3468,7 +3741,7 @@ void sqlite3ExprCacheAffinityChange(Parse*, int, int);
|
| void sqlite3ExprCode(Parse*, Expr*, int);
|
| void sqlite3ExprCodeCopy(Parse*, Expr*, int);
|
| void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
|
| -void sqlite3ExprCodeAtInit(Parse*, Expr*, int, u8);
|
| +int sqlite3ExprCodeAtInit(Parse*, Expr*, int);
|
| int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
|
| int sqlite3ExprCodeTarget(Parse*, Expr*, int);
|
| void sqlite3ExprCodeAndCache(Parse*, Expr*, int);
|
| @@ -3476,26 +3749,30 @@ int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8);
|
| #define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
|
| #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
|
| #define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */
|
| +#define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */
|
| void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
|
| void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
|
| void sqlite3ExprIfFalseDup(Parse*, Expr*, int, int);
|
| Table *sqlite3FindTable(sqlite3*,const char*, const char*);
|
| -Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*);
|
| -Table *sqlite3LocateTableItem(Parse*,int isView,struct SrcList_item *);
|
| +#define LOCATE_VIEW 0x01
|
| +#define LOCATE_NOERR 0x02
|
| +Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*);
|
| +Table *sqlite3LocateTableItem(Parse*,u32 flags,struct SrcList_item *);
|
| Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
|
| void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
|
| void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
|
| -void sqlite3Vacuum(Parse*);
|
| -int sqlite3RunVacuum(char**, sqlite3*);
|
| +void sqlite3Vacuum(Parse*,Token*);
|
| +int sqlite3RunVacuum(char**, sqlite3*, int);
|
| char *sqlite3NameFromToken(sqlite3*, Token*);
|
| int sqlite3ExprCompare(Expr*, Expr*, int);
|
| int sqlite3ExprListCompare(ExprList*, ExprList*, int);
|
| int sqlite3ExprImpliesExpr(Expr*, Expr*, int);
|
| void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
|
| void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
|
| +int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx);
|
| int sqlite3FunctionUsesThisSrc(Expr*, SrcList*);
|
| Vdbe *sqlite3GetVdbe(Parse*);
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifndef SQLITE_UNTESTABLE
|
| void sqlite3PrngSaveState(void);
|
| void sqlite3PrngRestoreState(void);
|
| #endif
|
| @@ -3525,7 +3802,12 @@ void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int);
|
| int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
|
| void sqlite3ResolvePartIdxLabel(Parse*,int);
|
| void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
|
| - u8,u8,int,int*);
|
| + u8,u8,int,int*,int*);
|
| +#ifdef SQLITE_ENABLE_NULL_TRIM
|
| + void sqlite3SetMakeRecordP5(Vdbe*,Table*);
|
| +#else
|
| +# define sqlite3SetMakeRecordP5(A,B)
|
| +#endif
|
| void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);
|
| int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*);
|
| void sqlite3BeginWriteOperation(Parse*, int, int);
|
| @@ -3544,11 +3826,11 @@ void sqlite3SelectSetName(Select*,const char*);
|
| #else
|
| # define sqlite3SelectSetName(A,B)
|
| #endif
|
| -void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
|
| -FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,u8);
|
| -void sqlite3RegisterBuiltinFunctions(sqlite3*);
|
| +void sqlite3InsertBuiltinFuncs(FuncDef*,int);
|
| +FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8);
|
| +void sqlite3RegisterBuiltinFunctions(void);
|
| void sqlite3RegisterDateTimeFunctions(void);
|
| -void sqlite3RegisterGlobalFunctions(void);
|
| +void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*);
|
| int sqlite3SafetyCheckOk(sqlite3*);
|
| int sqlite3SafetyCheckSickOrOk(sqlite3*);
|
| void sqlite3ChangeCookie(Parse*, int);
|
| @@ -3627,7 +3909,14 @@ LogEst sqlite3LogEstAdd(LogEst,LogEst);
|
| #ifndef SQLITE_OMIT_VIRTUALTABLE
|
| LogEst sqlite3LogEstFromDouble(double);
|
| #endif
|
| +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
|
| + defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
|
| + defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
|
| u64 sqlite3LogEstToInt(LogEst);
|
| +#endif
|
| +VList *sqlite3VListAdd(sqlite3*,VList*,const char*,int,int);
|
| +const char *sqlite3VListNumToName(VList*,int);
|
| +int sqlite3VListNameToNum(VList*,const char*,int);
|
|
|
| /*
|
| ** Routines to read and write variable-length integers. These used to
|
| @@ -3657,11 +3946,13 @@ const char *sqlite3IndexAffinityStr(sqlite3*, Index*);
|
| void sqlite3TableAffinity(Vdbe*, Table*, int);
|
| char sqlite3CompareAffinity(Expr *pExpr, char aff2);
|
| int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
|
| +char sqlite3TableColumnAffinity(Table*,int);
|
| char sqlite3ExprAffinity(Expr *pExpr);
|
| int sqlite3Atoi64(const char*, i64*, int, u8);
|
| int sqlite3DecOrHexToI64(const char*, i64*);
|
| void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);
|
| void sqlite3Error(sqlite3*,int);
|
| +void sqlite3SystemError(sqlite3*,int);
|
| void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
|
| u8 sqlite3HexToInt(int h);
|
| int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
|
| @@ -3694,7 +3985,7 @@ u8 sqlite3GetBoolean(const char *z,u8);
|
|
|
| const void *sqlite3ValueText(sqlite3_value*, u8);
|
| int sqlite3ValueBytes(sqlite3_value*, u8);
|
| -void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
|
| +void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
|
| void(*)(void*));
|
| void sqlite3ValueSetNull(sqlite3_value*);
|
| void sqlite3ValueFree(sqlite3_value*);
|
| @@ -3709,7 +4000,7 @@ extern const unsigned char sqlite3UpperToLower[];
|
| extern const unsigned char sqlite3CtypeMap[];
|
| extern const Token sqlite3IntTokens[];
|
| extern SQLITE_WSD struct Sqlite3Config sqlite3Config;
|
| -extern SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
|
| +extern FuncDefHash sqlite3BuiltinFunctions;
|
| #ifndef SQLITE_OMIT_WSD
|
| extern int sqlite3PendingByte;
|
| #endif
|
| @@ -3721,7 +4012,7 @@ void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
|
| int sqlite3GetToken(const unsigned char *, int *);
|
| void sqlite3NestedParse(Parse*, const char*, ...);
|
| void sqlite3ExpirePreparedStatements(sqlite3*);
|
| -int sqlite3CodeSubselect(Parse *, Expr *, int, int);
|
| +int sqlite3CodeSubselect(Parse*, Expr *, int, int);
|
| void sqlite3SelectPrep(Parse*, Select*, NameContext*);
|
| void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
|
| int sqlite3MatchSpanName(const char*, const char*, const char*, const char*);
|
| @@ -3744,7 +4035,6 @@ void sqlite3DeleteIndexSamples(sqlite3*,Index*);
|
| void sqlite3DefaultRowEst(Index*);
|
| void sqlite3RegisterLikeFunctions(sqlite3*, int);
|
| int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
|
| -void sqlite3MinimumFileFormat(Parse*, int, int);
|
| void sqlite3SchemaClear(void *);
|
| Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
|
| int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
|
| @@ -3755,11 +4045,13 @@ KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
|
| #ifdef SQLITE_DEBUG
|
| int sqlite3KeyInfoIsWriteable(KeyInfo*);
|
| #endif
|
| -int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
|
| +int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
|
| void (*)(sqlite3_context*,int,sqlite3_value **),
|
| void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
|
| FuncDestructor *pDestructor
|
| );
|
| +void sqlite3OomFault(sqlite3*);
|
| +void sqlite3OomClear(sqlite3*);
|
| int sqlite3ApiExit(sqlite3 *db, int);
|
| int sqlite3OpenTempDatabase(Parse *);
|
|
|
| @@ -3775,19 +4067,29 @@ Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
|
| void sqlite3BackupRestart(sqlite3_backup *);
|
| void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
|
|
|
| +#ifndef SQLITE_OMIT_SUBQUERY
|
| +int sqlite3ExprCheckIN(Parse*, Expr*);
|
| +#else
|
| +# define sqlite3ExprCheckIN(x,y) SQLITE_OK
|
| +#endif
|
| +
|
| #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
|
| void sqlite3AnalyzeFunctions(void);
|
| -int sqlite3Stat4ProbeSetValue(Parse*,Index*,UnpackedRecord**,Expr*,u8,int,int*);
|
| +int sqlite3Stat4ProbeSetValue(
|
| + Parse*,Index*,UnpackedRecord**,Expr*,int,int,int*);
|
| int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**);
|
| void sqlite3Stat4ProbeFree(UnpackedRecord*);
|
| int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**);
|
| +char sqlite3IndexColumnAffinity(sqlite3*, Index*, int);
|
| #endif
|
|
|
| /*
|
| ** The interface to the LEMON-generated parser
|
| */
|
| -void *sqlite3ParserAlloc(void*(*)(u64));
|
| -void sqlite3ParserFree(void*, void(*)(void*));
|
| +#ifndef SQLITE_AMALGAMATION
|
| + void *sqlite3ParserAlloc(void*(*)(u64));
|
| + void sqlite3ParserFree(void*, void(*)(void*));
|
| +#endif
|
| void sqlite3Parser(void*, int, Token, Parse*);
|
| #ifdef YYTRACKMAXSTACKDEPTH
|
| int sqlite3ParserStackPeak(void*);
|
| @@ -3816,7 +4118,7 @@ void sqlite3AutoLoadExtensions(sqlite3*);
|
| # define sqlite3VtabRollback(X)
|
| # define sqlite3VtabCommit(X)
|
| # define sqlite3VtabInSync(db) 0
|
| -# define sqlite3VtabLock(X)
|
| +# define sqlite3VtabLock(X)
|
| # define sqlite3VtabUnlock(X)
|
| # define sqlite3VtabUnlockList(X)
|
| # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
|
| @@ -3833,6 +4135,13 @@ void sqlite3AutoLoadExtensions(sqlite3*);
|
| int sqlite3VtabSavepoint(sqlite3 *, int, int);
|
| void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*);
|
| VTable *sqlite3GetVTable(sqlite3*, Table*);
|
| + Module *sqlite3VtabCreateModule(
|
| + sqlite3*,
|
| + const char*,
|
| + const sqlite3_module*,
|
| + void*,
|
| + void(*)(void*)
|
| + );
|
| # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
|
| #endif
|
| int sqlite3VtabEponymousTableInit(Parse*,Module*);
|
| @@ -3874,7 +4183,7 @@ const char *sqlite3JournalModename(int);
|
| ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
|
| ** key functionality is available. If OMIT_TRIGGER is defined but
|
| ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
|
| -** this case foreign keys are parsed, but no other functionality is
|
| +** this case foreign keys are parsed, but no other functionality is
|
| ** provided (enforcement of FK constraints requires the triggers sub-system).
|
| */
|
| #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
|
| @@ -3890,6 +4199,7 @@ const char *sqlite3JournalModename(int);
|
| #define sqlite3FkDropTable(a,b,c)
|
| #define sqlite3FkOldmask(a,b) 0
|
| #define sqlite3FkRequired(a,b,c,d) 0
|
| + #define sqlite3FkReferences(a) 0
|
| #endif
|
| #ifndef SQLITE_OMIT_FOREIGN_KEY
|
| void sqlite3FkDelete(sqlite3 *, Table*);
|
| @@ -3908,10 +4218,10 @@ const char *sqlite3JournalModename(int);
|
|
|
| /*
|
| ** The interface to the code in fault.c used for identifying "benign"
|
| -** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST
|
| +** malloc failures. This is only present if SQLITE_UNTESTABLE
|
| ** is not defined.
|
| */
|
| -#ifndef SQLITE_OMIT_BUILTIN_TEST
|
| +#ifndef SQLITE_UNTESTABLE
|
| void sqlite3BeginBenignMalloc(void);
|
| void sqlite3EndBenignMalloc(void);
|
| #else
|
| @@ -3933,21 +4243,16 @@ const char *sqlite3JournalModename(int);
|
| #define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
|
| #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
|
| #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
|
| -int sqlite3FindInIndex(Parse *, Expr *, u32, int*);
|
| +int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*);
|
|
|
| +int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
|
| +int sqlite3JournalSize(sqlite3_vfs *);
|
| #ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| - int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
|
| - int sqlite3JournalSize(sqlite3_vfs *);
|
| int sqlite3JournalCreate(sqlite3_file *);
|
| - int sqlite3JournalExists(sqlite3_file *p);
|
| -#else
|
| - #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)
|
| - #define sqlite3JournalExists(p) 1
|
| #endif
|
|
|
| +int sqlite3JournalIsInMemory(sqlite3_file *p);
|
| void sqlite3MemJournalOpen(sqlite3_file *);
|
| -int sqlite3MemJournalSize(void);
|
| -int sqlite3IsMemJournal(sqlite3_file *);
|
|
|
| void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
|
| #if SQLITE_MAX_EXPR_DEPTH>0
|
| @@ -3978,7 +4283,7 @@ void sqlite3Put4byte(u8*, u32);
|
| /*
|
| ** If the SQLITE_ENABLE IOTRACE exists then the global variable
|
| ** sqlite3IoTrace is a pointer to a printf-like routine used to
|
| -** print I/O tracing messages.
|
| +** print I/O tracing messages.
|
| */
|
| #ifdef SQLITE_ENABLE_IOTRACE
|
| # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
|
| @@ -4012,7 +4317,7 @@ SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
|
| ** that allocations that might have been satisfied by lookaside are not
|
| ** passed back to non-lookaside free() routines. Asserts such as the
|
| ** example above are placed on the non-lookaside free() routines to verify
|
| -** this constraint.
|
| +** this constraint.
|
| **
|
| ** All of this is no-op for a production build. It only comes into
|
| ** play when the SQLITE_MEMDEBUG compile-time option is used.
|
| @@ -4043,4 +4348,10 @@ int sqlite3ThreadJoin(SQLiteThread*, void**);
|
| int sqlite3DbstatRegister(sqlite3*);
|
| #endif
|
|
|
| -#endif /* _SQLITEINT_H_ */
|
| +int sqlite3ExprVectorSize(Expr *pExpr);
|
| +int sqlite3ExprIsVector(Expr *pExpr);
|
| +Expr *sqlite3VectorFieldSubexpr(Expr*, int);
|
| +Expr *sqlite3ExprForVectorField(Parse*,Expr*,int);
|
| +void sqlite3VectorErrorMsg(Parse*, Expr*);
|
| +
|
| +#endif /* SQLITEINT_H */
|
|
|
Chromium Code Reviews
Issue 2751253002:
[sql] Import SQLite 3.17.0. (Closed)
