blob: 3841c91f1441eddcd5eda4e5c0a2ed7b6bad129c [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh75897232000-05-29 14:26:00 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
drh75897232000-05-29 14:26:00 +000010**
11*************************************************************************
12** Internal interface definitions for SQLite.
13**
drh75897232000-05-29 14:26:00 +000014*/
danielk1977e3026632004-06-22 11:29:02 +000015#ifndef _SQLITEINT_H_
16#define _SQLITEINT_H_
drh71674ce2007-10-23 15:51:26 +000017
mlcreechbd0ae112008-03-06 09:16:24 +000018/*
mistachkin2318d332015-01-12 18:02:52 +000019** Include the header file used to customize the compiler options for MSVC.
20** This should be done first so that it can successfully prevent spurious
21** compiler warnings due to subsequent content in this file and other files
22** that are included by this file.
23*/
24#include "msvc.h"
25
26/*
drh8cd5b252015-03-02 22:06:43 +000027** Special setup for VxWorks
28*/
29#include "vxworks.h"
30
31/*
drh2210dcc2009-08-12 11:45:40 +000032** These #defines should enable >2GB file support on POSIX if the
33** underlying operating system supports it. If the OS lacks
34** large file support, or if the OS is windows, these should be no-ops.
35**
36** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
37** system #includes. Hence, this block of code must be the very first
38** code in all source files.
39**
40** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
41** on the compiler command line. This is necessary if you are compiling
42** on a recent machine (ex: Red Hat 7.2) but you want your code to work
43** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
44** without this option, LFS is enable. But LFS does not exist in the kernel
45** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
46** portability you should omit LFS.
47**
drhdddf6972014-02-07 19:33:31 +000048** The previous paragraph was written in 2005. (This paragraph is written
49** on 2008-11-28.) These days, all Linux kernels support large files, so
50** you should probably leave LFS enabled. But some embedded platforms might
51** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
52**
drh2210dcc2009-08-12 11:45:40 +000053** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
54*/
55#ifndef SQLITE_DISABLE_LFS
56# define _LARGE_FILE 1
57# ifndef _FILE_OFFSET_BITS
58# define _FILE_OFFSET_BITS 64
59# endif
60# define _LARGEFILE_SOURCE 1
61#endif
62
mistachkin33ac4c82014-09-20 00:02:23 +000063/* Needed for various definitions... */
64#if defined(__GNUC__) && !defined(_GNU_SOURCE)
65# define _GNU_SOURCE
66#endif
67
68#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
69# define _BSD_SOURCE
70#endif
71
drh2210dcc2009-08-12 11:45:40 +000072/*
mistachkina7b3b632014-02-14 23:35:49 +000073** For MinGW, check to see if we can include the header file containing its
74** version information, among other things. Normally, this internal MinGW
75** header file would [only] be included automatically by other MinGW header
76** files; however, the contained version information is now required by this
77** header file to work around binary compatibility issues (see below) and
78** this is the only known way to reliably obtain it. This entire #if block
79** would be completely unnecessary if there was any other way of detecting
80** MinGW via their preprocessor (e.g. if they customized their GCC to define
81** some MinGW-specific macros). When compiling for MinGW, either the
82** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
83** defined; otherwise, detection of conditions specific to MinGW will be
84** disabled.
85*/
86#if defined(_HAVE_MINGW_H)
87# include "mingw.h"
88#elif defined(_HAVE__MINGW_H)
89# include "_mingw.h"
90#endif
91
92/*
93** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
94** define is required to maintain binary compatibility with the MSVC runtime
95** library in use (e.g. for Windows XP).
96*/
97#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
98 defined(_WIN32) && !defined(_WIN64) && \
mistachkin65acf372014-02-16 19:20:00 +000099 defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
mistachkina7b3b632014-02-14 23:35:49 +0000100 defined(__MSVCRT__)
101# define _USE_32BIT_TIME_T
102#endif
103
drh5e990be2014-02-25 14:52:01 +0000104/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear
mistachkin0d71d122014-03-06 00:28:57 +0000105** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for
106** MinGW.
drh5e990be2014-02-25 14:52:01 +0000107*/
108#include "sqlite3.h"
109
mlcreechbd0ae112008-03-06 09:16:24 +0000110/*
mlcreech1e12d432008-05-07 02:42:01 +0000111** Include the configuration header output by 'configure' if we're using the
112** autoconf-based build
mlcreechbd0ae112008-03-06 09:16:24 +0000113*/
mlcreech1e12d432008-05-07 02:42:01 +0000114#ifdef _HAVE_SQLITE_CONFIG_H
mlcreech98dc4b12008-03-06 16:28:58 +0000115#include "config.h"
mlcreech1e12d432008-05-07 02:42:01 +0000116#endif
117
drhbb4957f2008-03-20 14:03:29 +0000118#include "sqliteLimit.h"
mlcreech98dc4b12008-03-06 16:28:58 +0000119
drhe2965822008-04-10 16:47:41 +0000120/* Disable nuisance warnings on Borland compilers */
121#if defined(__BORLANDC__)
122#pragma warn -rch /* unreachable code */
123#pragma warn -ccc /* Condition is always true or false */
124#pragma warn -aus /* Assigned value is never used */
125#pragma warn -csu /* Comparing signed and unsigned */
shane467bcf32008-11-24 20:01:32 +0000126#pragma warn -spa /* Suspicious pointer arithmetic */
drhe2965822008-04-10 16:47:41 +0000127#endif
128
mlcreech98dc4b12008-03-06 16:28:58 +0000129/*
drh06af7632008-04-28 12:54:15 +0000130** Include standard header files as necessary
131*/
132#ifdef HAVE_STDINT_H
133#include <stdint.h>
134#endif
135#ifdef HAVE_INTTYPES_H
136#include <inttypes.h>
137#endif
138
drha2460e02010-01-14 00:39:26 +0000139/*
drhc05a9a82010-03-04 16:12:34 +0000140** The following macros are used to cast pointers to integers and
141** integers to pointers. The way you do this varies from one compiler
142** to the next, so we have developed the following set of #if statements
143** to generate appropriate macros for a wide range of compilers.
drh875e9e72009-05-16 17:38:21 +0000144**
drhc05a9a82010-03-04 16:12:34 +0000145** The correct "ANSI" way to do this is to use the intptr_t type.
146** Unfortunately, that typedef is not available on all compilers, or
147** if it is available, it requires an #include of specific headers
drhc92271c2010-03-10 14:06:35 +0000148** that vary from one machine to the next.
drh875e9e72009-05-16 17:38:21 +0000149**
150** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
151** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
drh5e49edc2009-05-18 13:34:37 +0000152** So we have to define the macros in different ways depending on the
drh875e9e72009-05-16 17:38:21 +0000153** compiler.
154*/
drhc05a9a82010-03-04 16:12:34 +0000155#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
156# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
157# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
158#elif !defined(__GNUC__) /* Works for compilers other than LLVM */
159# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
160# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
161#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
162# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
163# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
164#else /* Generates a warning - but it always works */
165# define SQLITE_INT_TO_PTR(X) ((void*)(X))
166# define SQLITE_PTR_TO_INT(X) ((int)(X))
drh875e9e72009-05-16 17:38:21 +0000167#endif
drhb6dbc002007-11-27 02:38:00 +0000168
drhe5e7a902007-10-01 17:47:00 +0000169/*
drh14a924a2014-08-22 14:34:05 +0000170** A macro to hint to the compiler that a function should not be
171** inlined.
172*/
173#if defined(__GNUC__)
174# define SQLITE_NOINLINE __attribute__((noinline))
drhab993382014-10-10 18:09:52 +0000175#elif defined(_MSC_VER) && _MSC_VER>=1310
drh14a924a2014-08-22 14:34:05 +0000176# define SQLITE_NOINLINE __declspec(noinline)
177#else
178# define SQLITE_NOINLINE
179#endif
180
181/*
drh38c67c32010-09-08 02:30:27 +0000182** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
183** 0 means mutexes are permanently disable and the library is never
184** threadsafe. 1 means the library is serialized which is the highest
drhf7b54962013-05-28 12:11:54 +0000185** level of threadsafety. 2 means the library is multithreaded - multiple
drh38c67c32010-09-08 02:30:27 +0000186** threads can use SQLite as long as no two threads try to use the same
187** database connection at the same time.
188**
drhe5e7a902007-10-01 17:47:00 +0000189** Older versions of SQLite used an optional THREADSAFE macro.
drh38c67c32010-09-08 02:30:27 +0000190** We support that for legacy.
drhe5e7a902007-10-01 17:47:00 +0000191*/
192#if !defined(SQLITE_THREADSAFE)
drhd16d0bc2013-04-16 18:24:34 +0000193# if defined(THREADSAFE)
194# define SQLITE_THREADSAFE THREADSAFE
195# else
196# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
197# endif
drhe5e7a902007-10-01 17:47:00 +0000198#endif
199
drh67080612007-10-01 14:30:14 +0000200/*
drhcb15f352011-12-23 01:04:17 +0000201** Powersafe overwrite is on by default. But can be turned off using
202** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
203*/
204#ifndef SQLITE_POWERSAFE_OVERWRITE
205# define SQLITE_POWERSAFE_OVERWRITE 1
206#endif
207
208/*
drhd1dcb232014-11-01 18:32:18 +0000209** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by
210** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in
211** which case memory allocation statistics are disabled by default.
danielk19770a732f52008-09-04 17:17:38 +0000212*/
213#if !defined(SQLITE_DEFAULT_MEMSTATUS)
214# define SQLITE_DEFAULT_MEMSTATUS 1
215#endif
216
217/*
drh0d180202008-02-14 23:26:56 +0000218** Exactly one of the following macros must be defined in order to
219** specify which memory allocation subsystem to use.
220**
221** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
mistachkin1b186a92011-08-24 16:13:57 +0000222** SQLITE_WIN32_MALLOC // Use Win32 native heap API
drhd1b0afc2012-06-21 14:25:17 +0000223** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails
drh0d180202008-02-14 23:26:56 +0000224** SQLITE_MEMDEBUG // Debugging version of system malloc()
drha2460e02010-01-14 00:39:26 +0000225**
mistachkin753c5442011-08-25 02:02:25 +0000226** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
227** assert() macro is enabled, each call into the Win32 native heap subsystem
228** will cause HeapValidate to be called. If heap validation should fail, an
229** assertion will be triggered.
230**
drh0d180202008-02-14 23:26:56 +0000231** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
232** the default.
233*/
drhd1b0afc2012-06-21 14:25:17 +0000234#if defined(SQLITE_SYSTEM_MALLOC) \
235 + defined(SQLITE_WIN32_MALLOC) \
236 + defined(SQLITE_ZERO_MALLOC) \
237 + defined(SQLITE_MEMDEBUG)>1
238# error "Two or more of the following compile-time configuration options\
mistachkin20b1ff02012-06-21 15:12:30 +0000239 are defined but at most one is allowed:\
drhd1b0afc2012-06-21 14:25:17 +0000240 SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\
241 SQLITE_ZERO_MALLOC"
drh0d180202008-02-14 23:26:56 +0000242#endif
drhd1b0afc2012-06-21 14:25:17 +0000243#if defined(SQLITE_SYSTEM_MALLOC) \
244 + defined(SQLITE_WIN32_MALLOC) \
245 + defined(SQLITE_ZERO_MALLOC) \
246 + defined(SQLITE_MEMDEBUG)==0
drh0d180202008-02-14 23:26:56 +0000247# define SQLITE_SYSTEM_MALLOC 1
248#endif
249
250/*
drh8a1e5942009-04-28 15:43:45 +0000251** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
drheee4c8c2008-02-18 22:24:57 +0000252** sizes of memory allocations below this value where possible.
253*/
drh8a1e5942009-04-28 15:43:45 +0000254#if !defined(SQLITE_MALLOC_SOFT_LIMIT)
drheee4c8c2008-02-18 22:24:57 +0000255# define SQLITE_MALLOC_SOFT_LIMIT 1024
256#endif
257
258/*
drh67080612007-10-01 14:30:14 +0000259** We need to define _XOPEN_SOURCE as follows in order to enable
drh40b521f2013-05-24 12:47:26 +0000260** recursive mutexes on most Unix systems and fchmod() on OpenBSD.
261** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
262** it.
drh67080612007-10-01 14:30:14 +0000263*/
drh40b521f2013-05-24 12:47:26 +0000264#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
265# define _XOPEN_SOURCE 600
drh824d7c12006-01-06 12:03:19 +0000266#endif
267
268/*
drh1b28b892012-05-29 19:25:20 +0000269** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that
270** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,
271** make it true by defining or undefining NDEBUG.
272**
drh443dbcf2013-07-29 15:54:06 +0000273** Setting NDEBUG makes the code smaller and faster by disabling the
274** assert() statements in the code. So we want the default action
drh1b28b892012-05-29 19:25:20 +0000275** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
276** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
drh4b529d92005-09-13 00:00:00 +0000277** feature.
278*/
danielk1977771151b2006-01-17 13:21:40 +0000279#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
drh4b529d92005-09-13 00:00:00 +0000280# define NDEBUG 1
281#endif
drh1b28b892012-05-29 19:25:20 +0000282#if defined(NDEBUG) && defined(SQLITE_DEBUG)
283# undef NDEBUG
284#endif
drh4b529d92005-09-13 00:00:00 +0000285
drh64022502009-01-09 14:11:04 +0000286/*
drhc7379ce2013-10-30 02:28:23 +0000287** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
288*/
289#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
290# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
291#endif
292
293/*
drh47c3b3e2009-01-10 16:15:20 +0000294** The testcase() macro is used to aid in coverage testing. When
295** doing coverage testing, the condition inside the argument to
296** testcase() must be evaluated both true and false in order to
297** get full branch coverage. The testcase() macro is inserted
298** to help ensure adequate test coverage in places where simple
299** condition/decision coverage is inadequate. For example, testcase()
300** can be used to make sure boundary values are tested. For
301** bitmask tests, testcase() can be used to make sure each bit
302** is significant and used at least once. On switch statements
303** where multiple cases go to the same block of code, testcase()
304** can insure that all cases are evaluated.
305**
drh47c3b3e2009-01-10 16:15:20 +0000306*/
307#ifdef SQLITE_COVERAGE_TEST
308 void sqlite3Coverage(int);
309# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
drh47c3b3e2009-01-10 16:15:20 +0000310#else
311# define testcase(X)
drh8f941bc2009-01-14 23:03:40 +0000312#endif
313
314/*
315** The TESTONLY macro is used to enclose variable declarations or
316** other bits of code that are needed to support the arguments
317** within testcase() and assert() macros.
318*/
319#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
320# define TESTONLY(X) X
321#else
drh47c3b3e2009-01-10 16:15:20 +0000322# define TESTONLY(X)
323#endif
324
325/*
drh61495262009-04-22 15:32:59 +0000326** Sometimes we need a small amount of code such as a variable initialization
327** to setup for a later assert() statement. We do not want this code to
328** appear when assert() is disabled. The following macro is therefore
329** used to contain that setup code. The "VVA" acronym stands for
330** "Verification, Validation, and Accreditation". In other words, the
331** code within VVA_ONLY() will only run during verification processes.
332*/
333#ifndef NDEBUG
334# define VVA_ONLY(X) X
335#else
336# define VVA_ONLY(X)
337#endif
338
339/*
drh47c3b3e2009-01-10 16:15:20 +0000340** The ALWAYS and NEVER macros surround boolean expressions which
341** are intended to always be true or false, respectively. Such
342** expressions could be omitted from the code completely. But they
343** are included in a few cases in order to enhance the resilience
344** of SQLite to unexpected behavior - to make the code "self-healing"
345** or "ductile" rather than being "brittle" and crashing at the first
346** hint of unplanned behavior.
347**
348** In other words, ALWAYS and NEVER are added for defensive code.
349**
350** When doing coverage testing ALWAYS and NEVER are hard-coded to
drh443dbcf2013-07-29 15:54:06 +0000351** be true and false so that the unreachable code they specify will
drh47c3b3e2009-01-10 16:15:20 +0000352** not be counted as untested code.
353*/
354#if defined(SQLITE_COVERAGE_TEST)
355# define ALWAYS(X) (1)
356# define NEVER(X) (0)
357#elif !defined(NDEBUG)
drh2de80f42009-06-24 10:26:32 +0000358# define ALWAYS(X) ((X)?1:(assert(0),0))
359# define NEVER(X) ((X)?(assert(0),1):0)
drh47c3b3e2009-01-10 16:15:20 +0000360#else
361# define ALWAYS(X) (X)
362# define NEVER(X) (X)
363#endif
364
365/*
peter.d.reid60ec9142014-09-06 16:39:46 +0000366** Return true (non-zero) if the input is an integer that is too large
drh3e8e7ec2010-07-07 13:43:19 +0000367** to fit in 32-bits. This macro is used inside of various testcase()
368** macros to verify that we have tested SQLite for large-file support.
369*/
danb31a6af2010-07-14 06:20:26 +0000370#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
drh3e8e7ec2010-07-07 13:43:19 +0000371
372/*
drh47c3b3e2009-01-10 16:15:20 +0000373** The macro unlikely() is a hint that surrounds a boolean
374** expression that is usually false. Macro likely() surrounds
drh443dbcf2013-07-29 15:54:06 +0000375** a boolean expression that is usually true. These hints could,
376** in theory, be used by the compiler to generate better code, but
377** currently they are just comments for human readers.
drh47c3b3e2009-01-10 16:15:20 +0000378*/
drh443dbcf2013-07-29 15:54:06 +0000379#define likely(X) (X)
380#define unlikely(X) (X)
drh47c3b3e2009-01-10 16:15:20 +0000381
drhbeae3192001-09-22 18:12:08 +0000382#include "hash.h"
drh75897232000-05-29 14:26:00 +0000383#include "parse.h"
drh75897232000-05-29 14:26:00 +0000384#include <stdio.h>
385#include <stdlib.h>
386#include <string.h>
387#include <assert.h>
drh52370e22005-01-21 21:31:40 +0000388#include <stddef.h>
drh75897232000-05-29 14:26:00 +0000389
drh967e8b72000-06-21 13:59:10 +0000390/*
drhb37df7b2005-10-13 02:09:49 +0000391** If compiling for a processor that lacks floating point support,
392** substitute integer for floating-point
393*/
394#ifdef SQLITE_OMIT_FLOATING_POINT
395# define double sqlite_int64
drh8b307fb2010-04-06 15:57:05 +0000396# define float sqlite_int64
drhb37df7b2005-10-13 02:09:49 +0000397# define LONGDOUBLE_TYPE sqlite_int64
drhd1167392006-01-23 13:00:35 +0000398# ifndef SQLITE_BIG_DBL
drhcdaca552009-08-20 13:45:07 +0000399# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
drhd1167392006-01-23 13:00:35 +0000400# endif
drhb37df7b2005-10-13 02:09:49 +0000401# define SQLITE_OMIT_DATETIME_FUNCS 1
402# define SQLITE_OMIT_TRACE 1
drh110daac2007-05-04 11:59:31 +0000403# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
drh0b3bf922009-06-15 20:45:34 +0000404# undef SQLITE_HAVE_ISNAN
drhb37df7b2005-10-13 02:09:49 +0000405#endif
drhd1167392006-01-23 13:00:35 +0000406#ifndef SQLITE_BIG_DBL
407# define SQLITE_BIG_DBL (1e99)
408#endif
drhb37df7b2005-10-13 02:09:49 +0000409
410/*
danielk197753c0f742005-03-29 03:10:59 +0000411** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
412** afterward. Having this macro allows us to cause the C compiler
413** to omit code used by TEMP tables without messy #ifndef statements.
414*/
415#ifdef SQLITE_OMIT_TEMPDB
416#define OMIT_TEMPDB 1
417#else
418#define OMIT_TEMPDB 0
419#endif
420
421/*
drhd946db02005-12-29 19:23:06 +0000422** The "file format" number is an integer that is incremented whenever
423** the VDBE-level file format changes. The following macros define the
424** the default file format for new databases and the maximum file format
425** that the library can read.
426*/
427#define SQLITE_MAX_FILE_FORMAT 4
428#ifndef SQLITE_DEFAULT_FILE_FORMAT
drhbf3f5f82011-11-07 13:05:23 +0000429# define SQLITE_DEFAULT_FILE_FORMAT 4
drhd946db02005-12-29 19:23:06 +0000430#endif
431
drha2460e02010-01-14 00:39:26 +0000432/*
433** Determine whether triggers are recursive by default. This can be
434** changed at run-time using a pragma.
435*/
dan5bde73c2009-09-01 17:11:07 +0000436#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
437# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
438#endif
439
drhd946db02005-12-29 19:23:06 +0000440/*
danielk1977b06a0b62008-06-26 10:54:12 +0000441** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
drh49766d62005-01-08 18:42:28 +0000442** on the command-line
443*/
danielk1977b06a0b62008-06-26 10:54:12 +0000444#ifndef SQLITE_TEMP_STORE
445# define SQLITE_TEMP_STORE 1
drhd16d0bc2013-04-16 18:24:34 +0000446# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */
drh49766d62005-01-08 18:42:28 +0000447#endif
448
449/*
danb3f56fd2014-03-31 19:57:34 +0000450** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if
451** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
452** to zero.
453*/
drh6b2129a2014-08-29 19:06:07 +0000454#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
danb3f56fd2014-03-31 19:57:34 +0000455# undef SQLITE_MAX_WORKER_THREADS
drh028696c2014-08-25 23:44:44 +0000456# define SQLITE_MAX_WORKER_THREADS 0
danb3f56fd2014-03-31 19:57:34 +0000457#endif
458#ifndef SQLITE_MAX_WORKER_THREADS
drh6b2129a2014-08-29 19:06:07 +0000459# define SQLITE_MAX_WORKER_THREADS 8
danb3f56fd2014-03-31 19:57:34 +0000460#endif
drha09c8852014-05-03 11:22:09 +0000461#ifndef SQLITE_DEFAULT_WORKER_THREADS
462# define SQLITE_DEFAULT_WORKER_THREADS 0
463#endif
464#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS
465# undef SQLITE_MAX_WORKER_THREADS
466# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS
467#endif
danb3f56fd2014-03-31 19:57:34 +0000468
469
470/*
drhf1974842004-11-05 03:56:00 +0000471** GCC does not define the offsetof() macro so we'll have to do it
472** ourselves.
473*/
474#ifndef offsetof
475#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
476#endif
477
478/*
drhe1e2e9a2013-06-13 15:16:53 +0000479** Macros to compute minimum and maximum of two numbers.
480*/
481#define MIN(A,B) ((A)<(B)?(A):(B))
482#define MAX(A,B) ((A)>(B)?(A):(B))
483
484/*
drh4fa4a542014-09-30 12:33:33 +0000485** Swap two objects of type TYPE.
486*/
487#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
488
489/*
drh9b8f4472006-04-04 01:54:55 +0000490** Check to see if this machine uses EBCDIC. (Yes, believe it or
491** not, there are still machines out there that use EBCDIC.)
492*/
493#if 'A' == '\301'
494# define SQLITE_EBCDIC 1
495#else
496# define SQLITE_ASCII 1
497#endif
498
499/*
drh5a2c2c22001-11-21 02:21:11 +0000500** Integers of known sizes. These typedefs might change for architectures
501** where the sizes very. Preprocessor macros are available so that the
502** types can be conveniently redefined at compile-type. Like this:
503**
504** cc '-DUINTPTR_TYPE=long long int' ...
drh41a2b482001-01-20 19:52:49 +0000505*/
drh5a2c2c22001-11-21 02:21:11 +0000506#ifndef UINT32_TYPE
mlcreechdda5b682008-03-14 13:02:08 +0000507# ifdef HAVE_UINT32_T
508# define UINT32_TYPE uint32_t
509# else
510# define UINT32_TYPE unsigned int
511# endif
drh5a2c2c22001-11-21 02:21:11 +0000512#endif
513#ifndef UINT16_TYPE
mlcreechdda5b682008-03-14 13:02:08 +0000514# ifdef HAVE_UINT16_T
515# define UINT16_TYPE uint16_t
516# else
517# define UINT16_TYPE unsigned short int
518# endif
drh5a2c2c22001-11-21 02:21:11 +0000519#endif
drh939a16d2004-07-15 13:37:22 +0000520#ifndef INT16_TYPE
mlcreechdda5b682008-03-14 13:02:08 +0000521# ifdef HAVE_INT16_T
522# define INT16_TYPE int16_t
523# else
524# define INT16_TYPE short int
525# endif
drh939a16d2004-07-15 13:37:22 +0000526#endif
drh5a2c2c22001-11-21 02:21:11 +0000527#ifndef UINT8_TYPE
mlcreechdda5b682008-03-14 13:02:08 +0000528# ifdef HAVE_UINT8_T
529# define UINT8_TYPE uint8_t
530# else
531# define UINT8_TYPE unsigned char
532# endif
drh5a2c2c22001-11-21 02:21:11 +0000533#endif
drh905793e2004-02-21 13:31:09 +0000534#ifndef INT8_TYPE
mlcreechdda5b682008-03-14 13:02:08 +0000535# ifdef HAVE_INT8_T
536# define INT8_TYPE int8_t
537# else
538# define INT8_TYPE signed char
539# endif
drh905793e2004-02-21 13:31:09 +0000540#endif
drhefad9992004-06-22 12:13:55 +0000541#ifndef LONGDOUBLE_TYPE
542# define LONGDOUBLE_TYPE long double
543#endif
drhefad9992004-06-22 12:13:55 +0000544typedef sqlite_int64 i64; /* 8-byte signed integer */
drh27436af2006-03-28 23:57:17 +0000545typedef sqlite_uint64 u64; /* 8-byte unsigned integer */
drh5a2c2c22001-11-21 02:21:11 +0000546typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
547typedef UINT16_TYPE u16; /* 2-byte unsigned integer */
drh939a16d2004-07-15 13:37:22 +0000548typedef INT16_TYPE i16; /* 2-byte signed integer */
drh5a2c2c22001-11-21 02:21:11 +0000549typedef UINT8_TYPE u8; /* 1-byte unsigned integer */
drh70a8ca32008-08-21 18:49:27 +0000550typedef INT8_TYPE i8; /* 1-byte signed integer */
drh5a2c2c22001-11-21 02:21:11 +0000551
552/*
drh35cd6432009-06-05 14:17:21 +0000553** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
554** that can be stored in a u32 without loss of data. The value
555** is 0x00000000ffffffff. But because of quirks of some compilers, we
556** have to specify the value in the less intuitive manner shown:
557*/
558#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
559
560/*
drhfaacf172011-08-12 01:51:45 +0000561** The datatype used to store estimates of the number of rows in a
562** table or index. This is an unsigned integer type. For 99.9% of
563** the world, a 32-bit integer is sufficient. But a 64-bit integer
564** can be used at compile-time if desired.
565*/
566#ifdef SQLITE_64BIT_STATS
567 typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */
568#else
569 typedef u32 tRowcnt; /* 32-bit is the default */
570#endif
571
572/*
drhbf539c42013-10-05 18:16:02 +0000573** Estimated quantities used for query planning are stored as 16-bit
574** logarithms. For quantity X, the value stored is 10*log2(X). This
575** gives a possible range of values of approximately 1.0e986 to 1e-986.
576** But the allowed values are "grainy". Not every value is representable.
577** For example, quantities 16 and 17 are both represented by a LogEst
drh97d38982014-11-07 14:37:32 +0000578** of 40. However, since LogEst quantities are suppose to be estimates,
drhbf539c42013-10-05 18:16:02 +0000579** not exact values, this imprecision is not a problem.
580**
drh224155d2014-04-30 13:19:09 +0000581** "LogEst" is short for "Logarithmic Estimate".
drhbf539c42013-10-05 18:16:02 +0000582**
583** Examples:
584** 1 -> 0 20 -> 43 10000 -> 132
585** 2 -> 10 25 -> 46 25000 -> 146
586** 3 -> 16 100 -> 66 1000000 -> 199
587** 4 -> 20 1000 -> 99 1048576 -> 200
588** 10 -> 33 1024 -> 100 4294967296 -> 320
589**
590** The LogEst can be negative to indicate fractional values.
591** Examples:
592**
593** 0.5 -> -10 0.1 -> -33 0.0625 -> -40
594*/
595typedef INT16_TYPE LogEst;
596
597/*
drh2b4905c2015-03-23 18:52:56 +0000598** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
599*/
600#ifndef SQLITE_PTRSIZE
601# if defined(__SIZEOF_POINTER__)
602# define SQLITE_PTRSIZE __SIZEOF_POINTER__
603# elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \
604 defined(_M_ARM) || defined(__arm__) || defined(__x86)
605# define SQLITE_PTRSIZE 4
606# else
607# define SQLITE_PTRSIZE 8
608# endif
609#endif
610
611/*
drhbbd42a62004-05-22 17:41:58 +0000612** Macros to determine whether the machine is big or little endian,
drh71794db2014-04-18 00:49:29 +0000613** and whether or not that determination is run-time or compile-time.
614**
615** For best performance, an attempt is made to guess at the byte-order
616** using C-preprocessor macros. If that is unsuccessful, or if
617** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
618** at run-time.
drhbbd42a62004-05-22 17:41:58 +0000619*/
drh46c99e02007-08-27 23:26:59 +0000620#ifdef SQLITE_AMALGAMATION
drhb3190c12008-12-08 21:37:14 +0000621const int sqlite3one = 1;
drh46c99e02007-08-27 23:26:59 +0000622#else
drhbbd42a62004-05-22 17:41:58 +0000623extern const int sqlite3one;
drh46c99e02007-08-27 23:26:59 +0000624#endif
drh71794db2014-04-18 00:49:29 +0000625#if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \
626 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \
627 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \
628 defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)
drh2cf4acb2014-04-18 00:06:02 +0000629# define SQLITE_BYTEORDER 1234
drh38def052007-03-31 15:27:59 +0000630# define SQLITE_BIGENDIAN 0
631# define SQLITE_LITTLEENDIAN 1
632# define SQLITE_UTF16NATIVE SQLITE_UTF16LE
drh71794db2014-04-18 00:49:29 +0000633#endif
634#if (defined(sparc) || defined(__ppc__)) \
635 && !defined(SQLITE_RUNTIME_BYTEORDER)
636# define SQLITE_BYTEORDER 4321
637# define SQLITE_BIGENDIAN 1
638# define SQLITE_LITTLEENDIAN 0
639# define SQLITE_UTF16NATIVE SQLITE_UTF16BE
640#endif
641#if !defined(SQLITE_BYTEORDER)
drh2cf4acb2014-04-18 00:06:02 +0000642# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */
drh38def052007-03-31 15:27:59 +0000643# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
644# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
drh2cf4acb2014-04-18 00:06:02 +0000645# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
drh38def052007-03-31 15:27:59 +0000646#endif
drhbbd42a62004-05-22 17:41:58 +0000647
648/*
drh0f050352008-05-09 18:03:13 +0000649** Constants for the largest and smallest possible 64-bit signed integers.
650** These macros are designed to work correctly on both 32-bit and 64-bit
651** compilers.
652*/
653#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
654#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
655
danielk1977be229652009-03-20 14:18:51 +0000656/*
657** Round up a number to the next larger multiple of 8. This is used
658** to force 8-byte alignment on 64-bit architectures.
659*/
danielk1977bc739712009-03-23 04:33:32 +0000660#define ROUND8(x) (((x)+7)&~7)
661
662/*
663** Round down to the nearest multiple of 8
664*/
665#define ROUNDDOWN8(x) ((x)&~7)
danielk1977be229652009-03-20 14:18:51 +0000666
drh0f050352008-05-09 18:03:13 +0000667/*
drh8e14c592009-12-04 23:10:12 +0000668** Assert that the pointer X is aligned to an 8-byte boundary. This
669** macro is used only within assert() to verify that the code gets
670** all alignment restrictions correct.
671**
672** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
peter.d.reid60ec9142014-09-06 16:39:46 +0000673** underlying malloc() implementation might return us 4-byte aligned
drh8e14c592009-12-04 23:10:12 +0000674** pointers. In that case, only verify 4-byte alignment.
drhea598cb2009-04-05 12:22:08 +0000675*/
drh8e14c592009-12-04 23:10:12 +0000676#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
677# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
678#else
679# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
680#endif
drhea598cb2009-04-05 12:22:08 +0000681
drh188d4882013-04-08 20:47:49 +0000682/*
drh9b4c59f2013-04-15 17:03:42 +0000683** Disable MMAP on platforms where it is known to not work
drh188d4882013-04-08 20:47:49 +0000684*/
685#if defined(__OpenBSD__) || defined(__QNXNTO__)
drh9b4c59f2013-04-15 17:03:42 +0000686# undef SQLITE_MAX_MMAP_SIZE
687# define SQLITE_MAX_MMAP_SIZE 0
drh188d4882013-04-08 20:47:49 +0000688#endif
689
drh9b4c59f2013-04-15 17:03:42 +0000690/*
691** Default maximum size of memory used by memory-mapped I/O in the VFS
692*/
693#ifdef __APPLE__
694# include <TargetConditionals.h>
695# if TARGET_OS_IPHONE
696# undef SQLITE_MAX_MMAP_SIZE
697# define SQLITE_MAX_MMAP_SIZE 0
698# endif
699#endif
700#ifndef SQLITE_MAX_MMAP_SIZE
701# if defined(__linux__) \
702 || defined(_WIN32) \
703 || (defined(__APPLE__) && defined(__MACH__)) \
704 || defined(__sun)
drh2bba8c22013-04-26 12:08:29 +0000705# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */
drh9b4c59f2013-04-15 17:03:42 +0000706# else
707# define SQLITE_MAX_MMAP_SIZE 0
708# endif
drhd16d0bc2013-04-16 18:24:34 +0000709# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */
drh9b4c59f2013-04-15 17:03:42 +0000710#endif
711
712/*
713** The default MMAP_SIZE is zero on all platforms. Or, even if a larger
714** default MMAP_SIZE is specified at compile-time, make sure that it does
715** not exceed the maximum mmap size.
716*/
717#ifndef SQLITE_DEFAULT_MMAP_SIZE
718# define SQLITE_DEFAULT_MMAP_SIZE 0
drhd16d0bc2013-04-16 18:24:34 +0000719# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */
drh9b4c59f2013-04-15 17:03:42 +0000720#endif
721#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
722# undef SQLITE_DEFAULT_MMAP_SIZE
723# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
724#endif
drhe7b347072009-06-01 18:18:20 +0000725
drhea598cb2009-04-05 12:22:08 +0000726/*
drh1435a9a2013-08-27 23:15:44 +0000727** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.
728** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also
729** define SQLITE_ENABLE_STAT3_OR_STAT4
730*/
731#ifdef SQLITE_ENABLE_STAT4
732# undef SQLITE_ENABLE_STAT3
733# define SQLITE_ENABLE_STAT3_OR_STAT4 1
734#elif SQLITE_ENABLE_STAT3
735# define SQLITE_ENABLE_STAT3_OR_STAT4 1
736#elif SQLITE_ENABLE_STAT3_OR_STAT4
737# undef SQLITE_ENABLE_STAT3_OR_STAT4
738#endif
drh90f5ecb2004-07-22 01:19:35 +0000739
740/*
drhabd4c722014-09-20 18:18:33 +0000741** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
742** the Select query generator tracing logic is turned on.
743*/
drh9300adb2014-09-20 20:24:49 +0000744#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE)
drhabd4c722014-09-20 18:18:33 +0000745# define SELECTTRACE_ENABLED 1
746#else
747# define SELECTTRACE_ENABLED 0
748#endif
749
750/*
drh90f5ecb2004-07-22 01:19:35 +0000751** An instance of the following structure is used to store the busy-handler
752** callback for a given sqlite handle.
753**
754** The sqlite.busyHandler member of the sqlite struct contains the busy
755** callback for the database handle. Each pager opened via the sqlite
756** handle is passed a pointer to sqlite.busyHandler. The busy-handler
757** callback is currently invoked only from within pager.c.
758*/
759typedef struct BusyHandler BusyHandler;
760struct BusyHandler {
761 int (*xFunc)(void *,int); /* The busy callback */
762 void *pArg; /* First arg to busy callback */
drha4afb652005-07-09 02:16:02 +0000763 int nBusy; /* Incremented with each busy call */
drh90f5ecb2004-07-22 01:19:35 +0000764};
765
766/*
drh75897232000-05-29 14:26:00 +0000767** Name of the master database table. The master database table
768** is a special table that holds the names and attributes of all
769** user tables and indices.
770*/
drhe0bc4042002-06-25 01:09:11 +0000771#define MASTER_NAME "sqlite_master"
772#define TEMP_MASTER_NAME "sqlite_temp_master"
drh75897232000-05-29 14:26:00 +0000773
774/*
danielk19778e150812004-05-10 01:17:37 +0000775** The root-page of the master database table.
776*/
777#define MASTER_ROOT 1
778
779/*
drhed6c8672003-01-12 18:02:16 +0000780** The name of the schema table.
781*/
danielk197753c0f742005-03-29 03:10:59 +0000782#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
drhed6c8672003-01-12 18:02:16 +0000783
784/*
drh75897232000-05-29 14:26:00 +0000785** A convenience macro that returns the number of elements in
786** an array.
787*/
danielk197723432972008-11-17 16:42:00 +0000788#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
drh75897232000-05-29 14:26:00 +0000789
790/*
drh7a5bcc02013-01-16 17:08:58 +0000791** Determine if the argument is a power of two
792*/
793#define IsPowerOfTwo(X) (((X)&((X)-1))==0)
794
795/*
drh633e6d52008-07-28 19:34:53 +0000796** The following value as a destructor means to use sqlite3DbFree().
drhaa538a52012-01-19 16:57:16 +0000797** The sqlite3DbFree() routine requires two parameters instead of the
798** one parameter that destructors normally want. So we have to introduce
799** this magic value that the code knows to handle differently. Any
800** pointer will work here as long as it is distinct from SQLITE_STATIC
801** and SQLITE_TRANSIENT.
drh633e6d52008-07-28 19:34:53 +0000802*/
drhaa538a52012-01-19 16:57:16 +0000803#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)
drh633e6d52008-07-28 19:34:53 +0000804
drh78f82d12008-09-02 00:52:52 +0000805/*
806** When SQLITE_OMIT_WSD is defined, it means that the target platform does
807** not support Writable Static Data (WSD) such as global and static variables.
808** All variables must either be on the stack or dynamically allocated from
809** the heap. When WSD is unsupported, the variable declarations scattered
810** throughout the SQLite code must become constants instead. The SQLITE_WSD
811** macro is used for this purpose. And instead of referencing the variable
812** directly, we use its constant as a key to lookup the run-time allocated
813** buffer that holds real variable. The constant is also the initializer
814** for the run-time allocated buffer.
815**
shane2479de32008-11-10 18:05:35 +0000816** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
drh78f82d12008-09-02 00:52:52 +0000817** macros become no-ops and have zero performance impact.
818*/
danielk1977075c23a2008-09-01 18:34:20 +0000819#ifdef SQLITE_OMIT_WSD
820 #define SQLITE_WSD const
821 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
822 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
drhd1d38482008-10-07 23:46:38 +0000823 int sqlite3_wsd_init(int N, int J);
824 void *sqlite3_wsd_find(void *K, int L);
danielk1977075c23a2008-09-01 18:34:20 +0000825#else
826 #define SQLITE_WSD
827 #define GLOBAL(t,v) v
828 #define sqlite3GlobalConfig sqlite3Config
829#endif
830
danielk1977f3d3c272008-11-19 16:52:44 +0000831/*
832** The following macros are used to suppress compiler warnings and to
833** make it clear to human readers when a function parameter is deliberately
834** left unused within the body of a function. This usually happens when
835** a function is called via a function pointer. For example the
836** implementation of an SQL aggregate step callback may not use the
837** parameter indicating the number of arguments passed to the aggregate,
838** if it knows that this is enforced elsewhere.
839**
840** When a function parameter is not used at all within the body of a function,
841** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
842** However, these macros may also be used to suppress warnings related to
843** parameters that may or may not be used depending on compilation options.
844** For example those parameters only used in assert() statements. In these
845** cases the parameters are named as per the usual conventions.
846*/
danielk197762c14b32008-11-19 09:05:26 +0000847#define UNUSED_PARAMETER(x) (void)(x)
danielk1977f3d3c272008-11-19 16:52:44 +0000848#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
danielk197762c14b32008-11-19 09:05:26 +0000849
drh633e6d52008-07-28 19:34:53 +0000850/*
drh75897232000-05-29 14:26:00 +0000851** Forward references to structures
852*/
drh13449892005-09-07 21:22:45 +0000853typedef struct AggInfo AggInfo;
drhfe05af82005-07-21 03:14:59 +0000854typedef struct AuthContext AuthContext;
drh0b9f50d2009-06-23 20:28:53 +0000855typedef struct AutoincInfo AutoincInfo;
drhf5e7bb52008-02-18 14:47:33 +0000856typedef struct Bitvec Bitvec;
drhfe05af82005-07-21 03:14:59 +0000857typedef struct CollSeq CollSeq;
drh7020f652000-06-03 18:06:52 +0000858typedef struct Column Column;
drhfe05af82005-07-21 03:14:59 +0000859typedef struct Db Db;
danielk1977e501b892006-01-09 06:29:47 +0000860typedef struct Schema Schema;
drh75897232000-05-29 14:26:00 +0000861typedef struct Expr Expr;
862typedef struct ExprList ExprList;
drhb7916a72009-05-27 10:31:29 +0000863typedef struct ExprSpan ExprSpan;
drhc2eef3b2002-08-31 18:53:06 +0000864typedef struct FKey FKey;
dand2199f02010-08-27 17:48:52 +0000865typedef struct FuncDestructor FuncDestructor;
drhfe05af82005-07-21 03:14:59 +0000866typedef struct FuncDef FuncDef;
drh70a8ca32008-08-21 18:49:27 +0000867typedef struct FuncDefHash FuncDefHash;
drhfe05af82005-07-21 03:14:59 +0000868typedef struct IdList IdList;
869typedef struct Index Index;
dan02fa4692009-08-17 17:06:58 +0000870typedef struct IndexSample IndexSample;
danielk19778d059842004-05-12 11:24:02 +0000871typedef struct KeyClass KeyClass;
drhd3d39e92004-05-20 22:16:29 +0000872typedef struct KeyInfo KeyInfo;
drh633e6d52008-07-28 19:34:53 +0000873typedef struct Lookaside Lookaside;
874typedef struct LookasideSlot LookasideSlot;
danielk1977d1ab1ba2006-06-15 04:28:13 +0000875typedef struct Module Module;
drh626a8792005-01-17 22:08:19 +0000876typedef struct NameContext NameContext;
drhfe05af82005-07-21 03:14:59 +0000877typedef struct Parse Parse;
drha5c14162013-12-17 15:03:06 +0000878typedef struct PrintfArguments PrintfArguments;
drha2460e02010-01-14 00:39:26 +0000879typedef struct RowSet RowSet;
danielk1977fd7f0452008-12-17 17:30:26 +0000880typedef struct Savepoint Savepoint;
drhfe05af82005-07-21 03:14:59 +0000881typedef struct Select Select;
drhf51446a2012-07-21 19:40:42 +0000882typedef struct SQLiteThread SQLiteThread;
drh634d81d2012-09-20 15:41:31 +0000883typedef struct SelectDest SelectDest;
drhfe05af82005-07-21 03:14:59 +0000884typedef struct SrcList SrcList;
drhade86482007-11-28 22:36:40 +0000885typedef struct StrAccum StrAccum;
drhfe05af82005-07-21 03:14:59 +0000886typedef struct Table Table;
danielk1977c00da102006-01-07 13:21:04 +0000887typedef struct TableLock TableLock;
drhfe05af82005-07-21 03:14:59 +0000888typedef struct Token Token;
drh4fa4a542014-09-30 12:33:33 +0000889typedef struct TreeView TreeView;
drha2460e02010-01-14 00:39:26 +0000890typedef struct Trigger Trigger;
dan2832ad42009-08-31 15:27:27 +0000891typedef struct TriggerPrg TriggerPrg;
drhfe05af82005-07-21 03:14:59 +0000892typedef struct TriggerStep TriggerStep;
drhe63d9992008-08-13 19:11:48 +0000893typedef struct UnpackedRecord UnpackedRecord;
danielk1977595a5232009-07-24 17:58:53 +0000894typedef struct VTable VTable;
danb061d052011-04-25 18:49:57 +0000895typedef struct VtabCtx VtabCtx;
drh7d10d5a2008-08-20 16:35:10 +0000896typedef struct Walker Walker;
drhfe05af82005-07-21 03:14:59 +0000897typedef struct WhereInfo WhereInfo;
dan7d562db2014-01-11 19:19:36 +0000898typedef struct With With;
drhd3d39e92004-05-20 22:16:29 +0000899
danielk19772dca4ac2008-01-03 11:50:29 +0000900/*
901** Defer sourcing vdbe.h and btree.h until after the "u8" and
902** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
903** pointer types (i.e. FuncDef) defined above.
904*/
905#include "btree.h"
906#include "vdbe.h"
907#include "pager.h"
danielk19778c0a7912008-08-20 14:49:23 +0000908#include "pcache.h"
danielk19772dca4ac2008-01-03 11:50:29 +0000909
danielk19771cc5ed82007-05-16 17:28:43 +0000910#include "os.h"
drhc7ce76a2007-08-30 14:10:30 +0000911#include "mutex.h"
danielk19771cc5ed82007-05-16 17:28:43 +0000912
drheee4c8c2008-02-18 22:24:57 +0000913
drh001bbcb2003-03-19 03:14:00 +0000914/*
915** Each database file to be accessed by the system is an instance
916** of the following structure. There are normally two of these structures
917** in the sqlite.aDb[] array. aDb[0] is the main database file and
drha69d9162003-04-17 22:57:53 +0000918** aDb[1] is the database file used to hold temporary tables. Additional
919** databases may be attached.
drh001bbcb2003-03-19 03:14:00 +0000920*/
921struct Db {
922 char *zName; /* Name of this database */
923 Btree *pBt; /* The B*Tree structure for this database file */
shane467bcf32008-11-24 20:01:32 +0000924 u8 safety_level; /* How aggressive at syncing data to disk */
danielk1977e501b892006-01-09 06:29:47 +0000925 Schema *pSchema; /* Pointer to database schema (possibly shared) */
danielk1977da184232006-01-05 11:34:32 +0000926};
927
928/*
929** An instance of the following structure stores a database schema.
drh21206082011-04-04 18:22:02 +0000930**
931** Most Schema objects are associated with a Btree. The exception is
932** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
933** In shared cache mode, a single Schema object can be shared by multiple
934** Btrees that refer to the same underlying BtShared object.
935**
936** Schema objects are automatically deallocated when the last Btree that
937** references them is destroyed. The TEMP Schema is manually freed by
938** sqlite3_close().
939*
940** A thread must be holding a mutex on the corresponding Btree in order
941** to access Schema content. This implies that the thread must also be
942** holding a mutex on the sqlite3 connection pointer that owns the Btree.
drh55a09592011-06-07 18:31:14 +0000943** For a TEMP Schema, only the connection mutex is required.
danielk1977da184232006-01-05 11:34:32 +0000944*/
danielk1977e501b892006-01-09 06:29:47 +0000945struct Schema {
drh001bbcb2003-03-19 03:14:00 +0000946 int schema_cookie; /* Database schema version number for this file */
drhc2a75552011-03-18 21:55:46 +0000947 int iGeneration; /* Generation counter. Incremented with each change */
drhd24cc422003-03-27 12:51:24 +0000948 Hash tblHash; /* All tables indexed by name */
949 Hash idxHash; /* All (named) indices indexed by name */
950 Hash trigHash; /* All triggers indexed by name */
dan1da40a32009-09-19 17:00:31 +0000951 Hash fkeyHash; /* All foreign keys by referenced table name */
drh4794f732004-11-05 17:17:50 +0000952 Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */
danielk1977da184232006-01-05 11:34:32 +0000953 u8 file_format; /* Schema format version for this file */
drh8079a0d2006-01-12 17:20:50 +0000954 u8 enc; /* Text encoding used by this database */
drh2c5e35f2014-08-05 11:04:21 +0000955 u16 schemaFlags; /* Flags associated with this schema */
danielk197714db2662006-01-09 16:12:04 +0000956 int cache_size; /* Number of pages to use in the cache */
drh001bbcb2003-03-19 03:14:00 +0000957};
drh75897232000-05-29 14:26:00 +0000958
959/*
drh8bf8dc92003-05-17 17:35:10 +0000960** These macros can be used to test, set, or clear bits in the
drha2460e02010-01-14 00:39:26 +0000961** Db.pSchema->flags field.
drh8bf8dc92003-05-17 17:35:10 +0000962*/
drh2c5e35f2014-08-05 11:04:21 +0000963#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))
964#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)
965#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)
966#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)
drh8bf8dc92003-05-17 17:35:10 +0000967
968/*
drha2460e02010-01-14 00:39:26 +0000969** Allowed values for the DB.pSchema->flags field.
drh8bf8dc92003-05-17 17:35:10 +0000970**
drh8bf8dc92003-05-17 17:35:10 +0000971** The DB_SchemaLoaded flag is set after the database schema has been
972** read into internal hash tables.
973**
974** DB_UnresetViews means that one or more views have column names that
975** have been filled out. If the schema changes, these column names might
976** changes and so the view will need to be reset.
977*/
drh124b27e2004-06-19 16:06:10 +0000978#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
979#define DB_UnresetViews 0x0002 /* Some views have defined column names */
danielk1977b82e7ed2006-01-11 14:09:31 +0000980#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
drh8bf8dc92003-05-17 17:35:10 +0000981
drhcaa639f2008-03-20 00:32:20 +0000982/*
983** The number of different kinds of things that can be limited
984** using the sqlite3_limit() interface.
985*/
drh111544c2014-08-29 16:20:47 +0000986#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)
drh8bf8dc92003-05-17 17:35:10 +0000987
988/*
drh633e6d52008-07-28 19:34:53 +0000989** Lookaside malloc is a set of fixed-size buffers that can be used
shane467bcf32008-11-24 20:01:32 +0000990** to satisfy small transient memory allocation requests for objects
drh633e6d52008-07-28 19:34:53 +0000991** associated with a particular database connection. The use of
992** lookaside malloc provides a significant performance enhancement
993** (approx 10%) by avoiding numerous malloc/free requests while parsing
994** SQL statements.
995**
996** The Lookaside structure holds configuration information about the
997** lookaside malloc subsystem. Each available memory allocation in
998** the lookaside subsystem is stored on a linked list of LookasideSlot
999** objects.
drhd9da78a2009-03-24 15:08:09 +00001000**
1001** Lookaside allocations are only allowed for objects that are associated
1002** with a particular database connection. Hence, schema information cannot
1003** be stored in lookaside because in shared cache mode the schema information
1004** is shared by multiple database connections. Therefore, while parsing
1005** schema information, the Lookaside.bEnabled flag is cleared so that
1006** lookaside allocations are not used to construct the schema objects.
drh633e6d52008-07-28 19:34:53 +00001007*/
1008struct Lookaside {
1009 u16 sz; /* Size of each buffer in bytes */
drhd9da78a2009-03-24 15:08:09 +00001010 u8 bEnabled; /* False to disable new lookaside allocations */
drhe9d1c722008-08-04 20:13:26 +00001011 u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */
drh633e6d52008-07-28 19:34:53 +00001012 int nOut; /* Number of buffers currently checked out */
1013 int mxOut; /* Highwater mark for nOut */
drh0b12e7f2010-12-20 15:51:58 +00001014 int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */
drh7d10d5a2008-08-20 16:35:10 +00001015 LookasideSlot *pFree; /* List of available buffers */
drh633e6d52008-07-28 19:34:53 +00001016 void *pStart; /* First byte of available memory space */
1017 void *pEnd; /* First byte past end of available space */
1018};
1019struct LookasideSlot {
1020 LookasideSlot *pNext; /* Next buffer in the list of free buffers */
1021};
1022
1023/*
drh70a8ca32008-08-21 18:49:27 +00001024** A hash table for function definitions.
1025**
1026** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
1027** Collisions are on the FuncDef.pHash chain.
1028*/
1029struct FuncDefHash {
1030 FuncDef *a[23]; /* Hash table for functions */
1031};
1032
drhd4530972014-09-09 14:47:53 +00001033#ifdef SQLITE_USER_AUTHENTICATION
1034/*
1035** Information held in the "sqlite3" database connection object and used
1036** to manage user authentication.
1037*/
1038typedef struct sqlite3_userauth sqlite3_userauth;
1039struct sqlite3_userauth {
drhe933b832014-09-10 17:34:28 +00001040 u8 authLevel; /* Current authentication level */
drhd4530972014-09-09 14:47:53 +00001041 int nAuthPW; /* Size of the zAuthPW in bytes */
1042 char *zAuthPW; /* Password used to authenticate */
1043 char *zAuthUser; /* User name used to authenticate */
1044};
1045
drhe933b832014-09-10 17:34:28 +00001046/* Allowed values for sqlite3_userauth.authLevel */
1047#define UAUTH_Unknown 0 /* Authentication not yet checked */
1048#define UAUTH_Fail 1 /* User authentication failed */
1049#define UAUTH_User 2 /* Authenticated as a normal user */
1050#define UAUTH_Admin 3 /* Authenticated as an administrator */
drhd4530972014-09-09 14:47:53 +00001051
1052/* Functions used only by user authorization logic */
1053int sqlite3UserAuthTable(const char*);
drhe933b832014-09-10 17:34:28 +00001054int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*);
drh7883ecf2014-09-11 16:19:31 +00001055void sqlite3UserAuthInit(sqlite3*);
drhf442e332014-09-10 19:01:14 +00001056void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
1057
drhd4530972014-09-09 14:47:53 +00001058#endif /* SQLITE_USER_AUTHENTICATION */
1059
drh32c6a482014-09-11 13:44:52 +00001060/*
1061** typedef for the authorization callback function.
1062*/
1063#ifdef SQLITE_USER_AUTHENTICATION
1064 typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
1065 const char*, const char*);
1066#else
1067 typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
1068 const char*);
1069#endif
1070
drhd4530972014-09-09 14:47:53 +00001071
drh70a8ca32008-08-21 18:49:27 +00001072/*
drha2460e02010-01-14 00:39:26 +00001073** Each database connection is an instance of the following structure.
drh75897232000-05-29 14:26:00 +00001074*/
drh9bb575f2004-09-06 17:24:11 +00001075struct sqlite3 {
drh90f6a5b2007-08-15 13:04:54 +00001076 sqlite3_vfs *pVfs; /* OS Interface */
drha4510172012-02-02 15:50:17 +00001077 struct Vdbe *pVdbe; /* List of active virtual machines */
1078 CollSeq *pDfltColl; /* The default collating sequence (BINARY) */
1079 sqlite3_mutex *mutex; /* Connection mutex */
drh001bbcb2003-03-19 03:14:00 +00001080 Db *aDb; /* All backends */
drha4510172012-02-02 15:50:17 +00001081 int nDb; /* Number of backends currently in use */
shane467bcf32008-11-24 20:01:32 +00001082 int flags; /* Miscellaneous flags. See below */
drha4510172012-02-02 15:50:17 +00001083 i64 lastRowid; /* ROWID of most recent insert (see above) */
drh9b4c59f2013-04-15 17:03:42 +00001084 i64 szMmap; /* Default mmap_size setting */
drh522c26f2011-05-07 14:40:29 +00001085 unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */
drhfcd35c72005-05-21 02:48:08 +00001086 int errCode; /* Most recent error code (SQLITE_*) */
drh4ac285a2006-09-15 07:28:50 +00001087 int errMask; /* & result codes with this before returning */
drha5759672012-10-30 14:39:12 +00001088 u16 dbOptFlags; /* Flags to enable/disable optimizations */
drh9bd3cc42014-12-12 23:17:54 +00001089 u8 enc; /* Text encoding */
drhfcd35c72005-05-21 02:48:08 +00001090 u8 autoCommit; /* The auto-commit flag. */
drh90f5ecb2004-07-22 01:19:35 +00001091 u8 temp_store; /* 1: file 2: memory 0: default */
drh17435752007-08-16 04:30:38 +00001092 u8 mallocFailed; /* True if we have seen a malloc failure */
drh3b020132008-04-17 17:02:01 +00001093 u8 dfltLockMode; /* Default locking-mode for attached dbs */
drh98757152008-01-09 23:04:12 +00001094 signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */
drha7564662010-02-22 19:32:31 +00001095 u8 suppressErr; /* Do not issue error messages if true */
danb061d052011-04-25 18:49:57 +00001096 u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
drha4510172012-02-02 15:50:17 +00001097 u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
danielk1977f653d782008-03-20 11:04:21 +00001098 int nextPagesize; /* Pagesize after VACUUM if >0 */
danielk197764202cf2008-11-17 15:31:47 +00001099 u32 magic; /* Magic number for detect library misuse */
danielk1977b28af712004-06-21 06:50:26 +00001100 int nChange; /* Value returned by sqlite3_changes() */
1101 int nTotalChange; /* Value returned by sqlite3_total_changes() */
drhcaa639f2008-03-20 00:32:20 +00001102 int aLimit[SQLITE_N_LIMIT]; /* Limits */
dan8930c2a2014-04-03 16:25:29 +00001103 int nMaxSorterMmap; /* Maximum size of regions mapped by sorter */
danielk1977b28af712004-06-21 06:50:26 +00001104 struct sqlite3InitInfo { /* Information used during initialization */
danielk1977b28af712004-06-21 06:50:26 +00001105 int newTnum; /* Rootpage of table being initialized */
drha4510172012-02-02 15:50:17 +00001106 u8 iDb; /* Which db file is being initialized */
danielk1977b28af712004-06-21 06:50:26 +00001107 u8 busy; /* TRUE if currently initializing */
drh3d5f74b2009-08-06 17:43:31 +00001108 u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
drh1ffede82015-01-30 20:59:27 +00001109 u8 imposterTable; /* Building an imposter table */
drh1d85d932004-02-14 23:05:52 +00001110 } init;
drh1713afb2013-06-28 01:24:57 +00001111 int nVdbeActive; /* Number of VDBEs currently running */
1112 int nVdbeRead; /* Number of active VDBEs that read or write */
1113 int nVdbeWrite; /* Number of active VDBEs that read and write */
1114 int nVdbeExec; /* Number of nested calls to VdbeExec() */
drh086723a2015-03-24 12:51:52 +00001115 int nVDestroy; /* Number of active OP_VDestroy operations */
drha4510172012-02-02 15:50:17 +00001116 int nExtension; /* Number of loaded extensions */
1117 void **aExtension; /* Array of shared library handles */
drh19e2d372005-08-29 23:00:03 +00001118 void (*xTrace)(void*,const char*); /* Trace function */
1119 void *pTraceArg; /* Argument to the trace function */
1120 void (*xProfile)(void*,const char*,u64); /* Profiling function */
1121 void *pProfileArg; /* Argument to profile function */
danielk197771fd80b2005-12-16 06:54:01 +00001122 void *pCommitArg; /* Argument to xCommitCallback() */
1123 int (*xCommitCallback)(void*); /* Invoked at every commit. */
1124 void *pRollbackArg; /* Argument to xRollbackCallback() */
1125 void (*xRollbackCallback)(void*); /* Invoked at every commit. */
danielk197794eb6a12005-12-15 15:22:08 +00001126 void *pUpdateArg;
1127 void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
dan5cf53532010-05-01 16:40:20 +00001128#ifndef SQLITE_OMIT_WAL
drh7ed91f22010-04-29 22:34:07 +00001129 int (*xWalCallback)(void *, sqlite3 *, const char *, int);
1130 void *pWalArg;
dan5cf53532010-05-01 16:40:20 +00001131#endif
drhfcd35c72005-05-21 02:48:08 +00001132 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
1133 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
1134 void *pCollNeededArg;
drhfcd35c72005-05-21 02:48:08 +00001135 sqlite3_value *pErr; /* Most recent error message */
drh881feaa2006-07-26 01:39:30 +00001136 union {
drh39001e72008-09-12 16:03:47 +00001137 volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
drh881feaa2006-07-26 01:39:30 +00001138 double notUsed1; /* Spacer */
1139 } u1;
drh633e6d52008-07-28 19:34:53 +00001140 Lookaside lookaside; /* Lookaside malloc configuration */
drhed6c8672003-01-12 18:02:16 +00001141#ifndef SQLITE_OMIT_AUTHORIZATION
drh32c6a482014-09-11 13:44:52 +00001142 sqlite3_xauth xAuth; /* Access authorization function */
drhed6c8672003-01-12 18:02:16 +00001143 void *pAuthArg; /* 1st argument to the access auth function */
1144#endif
danielk1977348bb5d2003-10-18 09:37:26 +00001145#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1146 int (*xProgress)(void *); /* The progress callback */
1147 void *pProgressArg; /* Argument to the progress callback */
drh8f8c65f2013-07-10 18:14:29 +00001148 unsigned nProgressOps; /* Number of opcodes for progress callback */
danielk1977348bb5d2003-10-18 09:37:26 +00001149#endif
drhb9bb7c12006-06-11 23:41:55 +00001150#ifndef SQLITE_OMIT_VIRTUALTABLE
drha4510172012-02-02 15:50:17 +00001151 int nVTrans; /* Allocated size of aVTrans */
drhb9bb7c12006-06-11 23:41:55 +00001152 Hash aModule; /* populated by sqlite3_create_module() */
danb061d052011-04-25 18:49:57 +00001153 VtabCtx *pVtabCtx; /* Context for active vtab connect/create */
danielk1977595a5232009-07-24 17:58:53 +00001154 VTable **aVTrans; /* Virtual tables with open transactions */
danielk1977595a5232009-07-24 17:58:53 +00001155 VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
danielk19776b456a22005-03-21 04:04:02 +00001156#endif
drh70a8ca32008-08-21 18:49:27 +00001157 FuncDefHash aFunc; /* Hash table of connection functions */
drhfcd35c72005-05-21 02:48:08 +00001158 Hash aCollSeq; /* All collating sequences */
1159 BusyHandler busyHandler; /* Busy callback */
1160 Db aDbStatic[2]; /* Static space for the 2 default backends */
danielk1977fd7f0452008-12-17 17:30:26 +00001161 Savepoint *pSavepoint; /* List of active savepoints */
drha4510172012-02-02 15:50:17 +00001162 int busyTimeout; /* Busy handler timeout, in msec */
danielk1977fd7f0452008-12-17 17:30:26 +00001163 int nSavepoint; /* Number of non-transaction savepoints */
danielk1977bd434552009-03-18 10:33:00 +00001164 int nStatement; /* Number of nested statement-transactions */
dan1da40a32009-09-19 17:00:31 +00001165 i64 nDeferredCons; /* Net deferred constraints this transaction. */
drh648e2642013-07-11 15:03:32 +00001166 i64 nDeferredImmCons; /* Net deferred immediate constraints */
dand46def72010-07-24 11:28:28 +00001167 int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
danielk1977404ca072009-03-16 13:19:36 +00001168#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
1169 /* The following variables are all protected by the STATIC_MASTER
1170 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
drh65a73ba2009-04-07 22:06:57 +00001171 **
1172 ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
1173 ** unlock so that it can proceed.
1174 **
1175 ** When X.pBlockingConnection==Y, that means that something that X tried
1176 ** tried to do recently failed with an SQLITE_LOCKED error due to locks
1177 ** held by Y.
danielk1977404ca072009-03-16 13:19:36 +00001178 */
1179 sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
1180 sqlite3 *pUnlockConnection; /* Connection to watch for unlock */
1181 void *pUnlockArg; /* Argument to xUnlockNotify */
1182 void (*xUnlockNotify)(void **, int); /* Unlock notify callback */
1183 sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
1184#endif
drhd4530972014-09-09 14:47:53 +00001185#ifdef SQLITE_USER_AUTHENTICATION
1186 sqlite3_userauth auth; /* User authentication information */
1187#endif
drh75897232000-05-29 14:26:00 +00001188};
1189
drh03b808a2006-03-13 15:06:05 +00001190/*
1191** A macro to discover the encoding of a database.
1192*/
drh9bd3cc42014-12-12 23:17:54 +00001193#define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
1194#define ENC(db) ((db)->enc)
danielk197714db2662006-01-09 16:12:04 +00001195
drh75897232000-05-29 14:26:00 +00001196/*
drh07096f62009-12-22 23:52:32 +00001197** Possible values for the sqlite3.flags.
drh75897232000-05-29 14:26:00 +00001198*/
drh7e5418e2012-09-27 15:05:54 +00001199#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */
1200#define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */
drh40c39412013-08-16 20:42:20 +00001201#define SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */
1202#define SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */
1203#define SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */
1204#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */
1205#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */
1206#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */
drh1bee3d72001-10-15 00:44:35 +00001207 /* DELETE, or UPDATE and return */
1208 /* the count using a callback. */
drh40c39412013-08-16 20:42:20 +00001209#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */
drh6a535342001-10-19 16:44:56 +00001210 /* result set is empty */
drh40c39412013-08-16 20:42:20 +00001211#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */
1212#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */
1213#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */
1214#define SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */
1215#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */
1216#define SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */
1217#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */
1218#define SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */
1219#define SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */
1220#define SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */
1221#define SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */
1222#define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */
1223#define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */
1224#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */
1225#define SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */
1226#define SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */
1227#define SQLITE_QueryOnly 0x02000000 /* Disable database changes */
drh84e55a82013-11-13 17:58:23 +00001228#define SQLITE_VdbeEQP 0x04000000 /* Debug EXPLAIN QUERY PLAN */
drhb1eaa712013-07-11 15:22:31 +00001229
drh07096f62009-12-22 23:52:32 +00001230
1231/*
drh7e5418e2012-09-27 15:05:54 +00001232** Bits of the sqlite3.dbOptFlags field that are used by the
1233** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
1234** selectively disable various optimizations.
drh07096f62009-12-22 23:52:32 +00001235*/
drh7e5418e2012-09-27 15:05:54 +00001236#define SQLITE_QueryFlattener 0x0001 /* Query flattening */
1237#define SQLITE_ColumnCache 0x0002 /* Column cache */
1238#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */
1239#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */
drh762c1c42014-01-02 19:35:30 +00001240/* not used 0x0010 // Was: SQLITE_IdxRealAsInt */
drh7e5418e2012-09-27 15:05:54 +00001241#define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */
1242#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
drha9e3fc02012-09-27 23:27:23 +00001243#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
drha5759672012-10-30 14:39:12 +00001244#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
drheb5bc922013-01-17 16:43:33 +00001245#define SQLITE_Transitive 0x0200 /* Transitive constraints */
drh1031bd92013-06-22 15:44:26 +00001246#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */
drhd7d71472014-10-22 19:57:16 +00001247#define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */
drha5759672012-10-30 14:39:12 +00001248#define SQLITE_AllOpts 0xffff /* All optimizations */
drh7e5418e2012-09-27 15:05:54 +00001249
1250/*
1251** Macros for testing whether or not optimizations are enabled or disabled.
1252*/
1253#ifndef SQLITE_OMIT_BUILTIN_TEST
1254#define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
1255#define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
1256#else
1257#define OptimizationDisabled(db, mask) 0
1258#define OptimizationEnabled(db, mask) 1
1259#endif
danielk197734c68fb2007-03-14 15:37:04 +00001260
drh58b95762000-06-02 01:17:37 +00001261/*
drhd9f158e2013-11-21 20:48:42 +00001262** Return true if it OK to factor constant expressions into the initialization
1263** code. The argument is a Parse object for the code generator.
1264*/
drhaceb31b2014-02-08 01:40:27 +00001265#define ConstFactorOk(P) ((P)->okConstFactor)
drh247be432002-05-10 05:44:55 +00001266
1267/*
1268** Possible values for the sqlite.magic field.
1269** The numbers are obtained at random and have no special meaning, other
1270** than being distinct from one another.
1271*/
1272#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
1273#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
drh7e8b8482008-01-23 03:03:05 +00001274#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
drh247be432002-05-10 05:44:55 +00001275#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
1276#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
drh4245c402012-06-02 14:32:21 +00001277#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */
drh247be432002-05-10 05:44:55 +00001278
1279/*
drh0bce8352002-02-28 00:41:10 +00001280** Each SQL function is defined by an instance of the following
1281** structure. A pointer to this structure is stored in the sqlite.aFunc
drh8e0a2f92002-02-23 23:45:45 +00001282** hash table. When multiple functions have the same name, the hash table
1283** points to a linked list of these structures.
drh28037572000-08-02 13:47:41 +00001284*/
drh0bce8352002-02-28 00:41:10 +00001285struct FuncDef {
drhe82f5d02008-10-07 19:53:14 +00001286 i16 nArg; /* Number of arguments. -1 means unlimited */
drhd36e1042013-09-06 13:10:12 +00001287 u16 funcFlags; /* Some combination of SQLITE_FUNC_* */
drhf9b596e2004-05-26 16:54:42 +00001288 void *pUserData; /* User data parameter */
1289 FuncDef *pNext; /* Next function with same name */
1290 void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
1291 void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
shane467bcf32008-11-24 20:01:32 +00001292 void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
danielk19778c0a7912008-08-20 14:49:23 +00001293 char *zName; /* SQL name of the function. */
drh70a8ca32008-08-21 18:49:27 +00001294 FuncDef *pHash; /* Next with a different name but the same hash */
dand2199f02010-08-27 17:48:52 +00001295 FuncDestructor *pDestructor; /* Reference counted destructor function */
1296};
1297
1298/*
1299** This structure encapsulates a user-function destructor callback (as
1300** configured using create_function_v2()) and a reference counter. When
1301** create_function_v2() is called to create a function with a destructor,
1302** a single object of this type is allocated. FuncDestructor.nRef is set to
1303** the number of FuncDef objects created (either 1 or 3, depending on whether
1304** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
1305** member of each of the new FuncDef objects is set to point to the allocated
1306** FuncDestructor.
1307**
1308** Thereafter, when one of the FuncDef objects is deleted, the reference
1309** count on this object is decremented. When it reaches 0, the destructor
1310** is invoked and the FuncDestructor structure freed.
1311*/
1312struct FuncDestructor {
1313 int nRef;
1314 void (*xDestroy)(void *);
1315 void *pUserData;
drh8e0a2f92002-02-23 23:45:45 +00001316};
drh28037572000-08-02 13:47:41 +00001317
1318/*
drha748fdc2012-03-28 01:34:47 +00001319** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF
1320** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. There
1321** are assert() statements in the code to verify this.
drh7d10d5a2008-08-20 16:35:10 +00001322*/
drhd36e1042013-09-06 13:10:12 +00001323#define SQLITE_FUNC_ENCMASK 0x003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
1324#define SQLITE_FUNC_LIKE 0x004 /* Candidate for the LIKE optimization */
1325#define SQLITE_FUNC_CASE 0x008 /* Case-sensitive LIKE-type function */
1326#define SQLITE_FUNC_EPHEM 0x010 /* Ephemeral. Delete with VDBE */
1327#define SQLITE_FUNC_NEEDCOLL 0x020 /* sqlite3GetFuncCollSeq() might be called */
1328#define SQLITE_FUNC_LENGTH 0x040 /* Built-in length() function */
1329#define SQLITE_FUNC_TYPEOF 0x080 /* Built-in typeof() function */
1330#define SQLITE_FUNC_COUNT 0x100 /* Built-in count(*) aggregate */
1331#define SQLITE_FUNC_COALESCE 0x200 /* Built-in coalesce() or ifnull() */
1332#define SQLITE_FUNC_UNLIKELY 0x400 /* Built-in unlikely() function */
drhb1fba282013-11-21 14:33:48 +00001333#define SQLITE_FUNC_CONSTANT 0x800 /* Constant inputs give a constant output */
drh9588ad92014-09-15 14:46:02 +00001334#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */
drh7d10d5a2008-08-20 16:35:10 +00001335
1336/*
drh777c5382008-08-21 20:21:34 +00001337** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
1338** used to create the initializers for the FuncDef structures.
1339**
1340** FUNCTION(zName, nArg, iArg, bNC, xFunc)
1341** Used to create a scalar function definition of a function zName
1342** implemented by C function xFunc that accepts nArg arguments. The
1343** value passed as iArg is cast to a (void*) and made available
1344** as the user-data (sqlite3_user_data()) for the function. If
drhf7bca572009-05-30 14:16:31 +00001345** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
drh777c5382008-08-21 20:21:34 +00001346**
drhb1fba282013-11-21 14:33:48 +00001347** VFUNCTION(zName, nArg, iArg, bNC, xFunc)
1348** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
1349**
drh777c5382008-08-21 20:21:34 +00001350** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
1351** Used to create an aggregate function definition implemented by
1352** the C functions xStep and xFinal. The first four parameters
1353** are interpreted in the same way as the first 4 parameters to
1354** FUNCTION().
1355**
1356** LIKEFUNC(zName, nArg, pArg, flags)
1357** Used to create a scalar function definition of a function zName
1358** that accepts nArg arguments and is implemented by a call to C
1359** function likeFunc. Argument pArg is cast to a (void *) and made
1360** available as the function user-data (sqlite3_user_data()). The
1361** FuncDef.flags variable is set to the value passed as the flags
1362** parameter.
1363*/
1364#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
drhb1fba282013-11-21 14:33:48 +00001365 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
1366 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
1367#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
drhd36e1042013-09-06 13:10:12 +00001368 {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
drha748fdc2012-03-28 01:34:47 +00001369 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
1370#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
drhb1fba282013-11-21 14:33:48 +00001371 {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
drh6ac78a02010-09-28 14:26:36 +00001372 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
drh21717ed2008-10-13 15:35:08 +00001373#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
drhb1fba282013-11-21 14:33:48 +00001374 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
drh6ac78a02010-09-28 14:26:36 +00001375 pArg, 0, xFunc, 0, 0, #zName, 0, 0}
drh777c5382008-08-21 20:21:34 +00001376#define LIKEFUNC(zName, nArg, arg, flags) \
drhb1fba282013-11-21 14:33:48 +00001377 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
1378 (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
drh777c5382008-08-21 20:21:34 +00001379#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
drhd36e1042013-09-06 13:10:12 +00001380 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
drh6ac78a02010-09-28 14:26:36 +00001381 SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
drh9588ad92014-09-15 14:46:02 +00001382#define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
1383 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
1384 SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
drh777c5382008-08-21 20:21:34 +00001385
danielk1977fd7f0452008-12-17 17:30:26 +00001386/*
1387** All current savepoints are stored in a linked list starting at
1388** sqlite3.pSavepoint. The first element in the list is the most recently
1389** opened savepoint. Savepoints are added to the list by the vdbe
1390** OP_Savepoint instruction.
1391*/
1392struct Savepoint {
1393 char *zName; /* Savepoint name (nul-terminated) */
drhfcb9f7a2009-10-13 19:19:23 +00001394 i64 nDeferredCons; /* Number of deferred fk violations */
drh648e2642013-07-11 15:03:32 +00001395 i64 nDeferredImmCons; /* Number of deferred imm fk. */
danielk1977fd7f0452008-12-17 17:30:26 +00001396 Savepoint *pNext; /* Parent savepoint (if any) */
1397};
1398
1399/*
1400** The following are used as the second parameter to sqlite3Savepoint(),
1401** and as the P1 argument to the OP_Savepoint instruction.
1402*/
1403#define SAVEPOINT_BEGIN 0
1404#define SAVEPOINT_RELEASE 1
1405#define SAVEPOINT_ROLLBACK 2
1406
drh777c5382008-08-21 20:21:34 +00001407
1408/*
danielk1977d1ab1ba2006-06-15 04:28:13 +00001409** Each SQLite module (virtual table definition) is defined by an
1410** instance of the following structure, stored in the sqlite3.aModule
1411** hash table.
1412*/
1413struct Module {
1414 const sqlite3_module *pModule; /* Callback pointers */
1415 const char *zName; /* Name passed to create_module() */
1416 void *pAux; /* pAux passed to create_module() */
danielk1977832a58a2007-06-22 15:21:15 +00001417 void (*xDestroy)(void *); /* Module destructor function */
danielk1977d1ab1ba2006-06-15 04:28:13 +00001418};
1419
1420/*
drh967e8b72000-06-21 13:59:10 +00001421** information about each column of an SQL table is held in an instance
drh7020f652000-06-03 18:06:52 +00001422** of this structure.
1423*/
1424struct Column {
drh967e8b72000-06-21 13:59:10 +00001425 char *zName; /* Name of this column */
danielk19777977a172004-11-09 12:44:37 +00001426 Expr *pDflt; /* Default value of this column */
drhb7916a72009-05-27 10:31:29 +00001427 char *zDflt; /* Original text of the default value */
drh382c0242001-10-06 16:33:02 +00001428 char *zType; /* Data type for this column */
danielk1977b3bf5562006-01-10 17:58:23 +00001429 char *zColl; /* Collating sequence. If NULL, use the default */
drha371ace2012-09-13 14:22:47 +00001430 u8 notNull; /* An OE_ code for handling a NOT NULL constraint */
danielk1977a37cdde2004-05-16 11:15:36 +00001431 char affinity; /* One of the SQLITE_AFF_... values */
drhfdaac672013-10-04 15:30:21 +00001432 u8 szEst; /* Estimated size of this column. INT==1 */
1433 u8 colFlags; /* Boolean properties. See COLFLAG_ defines below */
drh7020f652000-06-03 18:06:52 +00001434};
1435
drha371ace2012-09-13 14:22:47 +00001436/* Allowed values for Column.colFlags:
1437*/
1438#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */
1439#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */
1440
drh7020f652000-06-03 18:06:52 +00001441/*
drha9fd84b2004-05-18 23:21:35 +00001442** A "Collating Sequence" is defined by an instance of the following
danielk19770202b292004-06-09 09:55:16 +00001443** structure. Conceptually, a collating sequence consists of a name and
1444** a comparison routine that defines the order of that sequence.
drha9fd84b2004-05-18 23:21:35 +00001445**
drhe6f1e762012-12-06 01:03:15 +00001446** If CollSeq.xCmp is NULL, it means that the
danielk19770202b292004-06-09 09:55:16 +00001447** collating sequence is undefined. Indices built on an undefined
1448** collating sequence may not be read or written.
drha9fd84b2004-05-18 23:21:35 +00001449*/
1450struct CollSeq {
danielk1977a9808b32007-05-07 09:32:45 +00001451 char *zName; /* Name of the collating sequence, UTF-8 encoded */
1452 u8 enc; /* Text encoding handled by xCmp() */
danielk1977a9808b32007-05-07 09:32:45 +00001453 void *pUser; /* First argument to xCmp() */
danielk19770202b292004-06-09 09:55:16 +00001454 int (*xCmp)(void*,int, const void*, int, const void*);
danielk1977a9808b32007-05-07 09:32:45 +00001455 void (*xDel)(void*); /* Destructor for pUser */
drha9fd84b2004-05-18 23:21:35 +00001456};
1457
1458/*
drhd3d39e92004-05-20 22:16:29 +00001459** A sort order can be either ASC or DESC.
drh8e2ca022002-06-17 17:07:19 +00001460*/
drh8e2ca022002-06-17 17:07:19 +00001461#define SQLITE_SO_ASC 0 /* Sort in ascending order */
drhd3d39e92004-05-20 22:16:29 +00001462#define SQLITE_SO_DESC 1 /* Sort in ascending order */
drh8e2ca022002-06-17 17:07:19 +00001463
1464/*
danielk1977a37cdde2004-05-16 11:15:36 +00001465** Column affinity types.
drh8a512562005-11-14 22:29:05 +00001466**
1467** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
1468** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
drh7d10d5a2008-08-20 16:35:10 +00001469** the speed a little by numbering the values consecutively.
drh8a512562005-11-14 22:29:05 +00001470**
drh4583c372014-09-19 20:13:25 +00001471** But rather than start with 0 or 1, we begin with 'A'. That way,
drh8a512562005-11-14 22:29:05 +00001472** when multiple affinity types are concatenated into a string and
drh66a51672008-01-03 00:01:23 +00001473** used as the P4 operand, they will be more readable.
drh8a512562005-11-14 22:29:05 +00001474**
1475** Note also that the numeric types are grouped together so that testing
drh7ea31cc2014-09-18 14:36:00 +00001476** for a numeric type is a single comparison. And the NONE type is first.
danielk1977a37cdde2004-05-16 11:15:36 +00001477*/
drh4583c372014-09-19 20:13:25 +00001478#define SQLITE_AFF_NONE 'A'
1479#define SQLITE_AFF_TEXT 'B'
1480#define SQLITE_AFF_NUMERIC 'C'
1481#define SQLITE_AFF_INTEGER 'D'
1482#define SQLITE_AFF_REAL 'E'
danielk1977a37cdde2004-05-16 11:15:36 +00001483
drh8a512562005-11-14 22:29:05 +00001484#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
danielk1977a37cdde2004-05-16 11:15:36 +00001485
1486/*
drh35573352008-01-08 23:54:25 +00001487** The SQLITE_AFF_MASK values masks off the significant bits of an
1488** affinity value.
1489*/
drh4583c372014-09-19 20:13:25 +00001490#define SQLITE_AFF_MASK 0x47
drh35573352008-01-08 23:54:25 +00001491
1492/*
1493** Additional bit values that can be ORed with an affinity without
1494** changing the affinity.
drh3d77dee2014-02-19 14:20:49 +00001495**
1496** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
1497** It causes an assert() to fire if either operand to a comparison
1498** operator is NULL. It is added to certain comparison operators to
1499** prove that the operands are always NOT NULL.
drh35573352008-01-08 23:54:25 +00001500*/
drh4583c372014-09-19 20:13:25 +00001501#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */
1502#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */
drh6a2fe092009-09-23 02:29:36 +00001503#define SQLITE_NULLEQ 0x80 /* NULL=NULL */
drh4583c372014-09-19 20:13:25 +00001504#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */
drh35573352008-01-08 23:54:25 +00001505
1506/*
danielk1977595a5232009-07-24 17:58:53 +00001507** An object of this type is created for each virtual table present in
1508** the database schema.
1509**
1510** If the database schema is shared, then there is one instance of this
1511** structure for each database connection (sqlite3*) that uses the shared
1512** schema. This is because each database connection requires its own unique
1513** instance of the sqlite3_vtab* handle used to access the virtual table
1514** implementation. sqlite3_vtab* handles can not be shared between
1515** database connections, even when the rest of the in-memory database
1516** schema is shared, as the implementation often stores the database
1517** connection handle passed to it via the xConnect() or xCreate() method
1518** during initialization internally. This database connection handle may
drh9bbc2e22011-04-04 20:40:22 +00001519** then be used by the virtual table implementation to access real tables
danielk1977595a5232009-07-24 17:58:53 +00001520** within the database. So that they appear as part of the callers
1521** transaction, these accesses need to be made via the same database
1522** connection as that used to execute SQL operations on the virtual table.
1523**
1524** All VTable objects that correspond to a single table in a shared
1525** database schema are initially stored in a linked-list pointed to by
1526** the Table.pVTable member variable of the corresponding Table object.
1527** When an sqlite3_prepare() operation is required to access the virtual
1528** table, it searches the list for the VTable that corresponds to the
1529** database connection doing the preparing so as to use the correct
1530** sqlite3_vtab* handle in the compiled query.
1531**
1532** When an in-memory Table object is deleted (for example when the
1533** schema is being reloaded for some reason), the VTable objects are not
1534** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
1535** immediately. Instead, they are moved from the Table.pVTable list to
1536** another linked list headed by the sqlite3.pDisconnect member of the
1537** corresponding sqlite3 structure. They are then deleted/xDisconnected
1538** next time a statement is prepared using said sqlite3*. This is done
1539** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
1540** Refer to comments above function sqlite3VtabUnlockList() for an
1541** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
1542** list without holding the corresponding sqlite3.mutex mutex.
1543**
1544** The memory for objects of this type is always allocated by
1545** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
1546** the first argument.
1547*/
1548struct VTable {
1549 sqlite3 *db; /* Database connection associated with this table */
1550 Module *pMod; /* Pointer to module implementation */
1551 sqlite3_vtab *pVtab; /* Pointer to vtab instance */
1552 int nRef; /* Number of pointers to this structure */
danb061d052011-04-25 18:49:57 +00001553 u8 bConstraint; /* True if constraints are supported */
drhaddd8f82011-05-25 15:54:09 +00001554 int iSavepoint; /* Depth of the SAVEPOINT stack */
danielk1977595a5232009-07-24 17:58:53 +00001555 VTable *pNext; /* Next in linked list (see above) */
1556};
1557
1558/*
drh22f70c32002-02-18 01:17:00 +00001559** Each SQL table is represented in memory by an instance of the
1560** following structure.
1561**
drhd24cc422003-03-27 12:51:24 +00001562** Table.zName is the name of the table. The case of the original
drh22f70c32002-02-18 01:17:00 +00001563** CREATE TABLE statement is stored, but case is not significant for
1564** comparisons.
1565**
drhd24cc422003-03-27 12:51:24 +00001566** Table.nCol is the number of columns in this table. Table.aCol is a
drh22f70c32002-02-18 01:17:00 +00001567** pointer to an array of Column structures, one for each column.
1568**
drhd24cc422003-03-27 12:51:24 +00001569** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
1570** the column that is that key. Otherwise Table.iPKey is negative. Note
drh22f70c32002-02-18 01:17:00 +00001571** that the datatype of the PRIMARY KEY must be INTEGER for this field to
1572** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of
1573** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid
drh7d10d5a2008-08-20 16:35:10 +00001574** is generated for each row of the table. TF_HasPrimaryKey is set if
drh22f70c32002-02-18 01:17:00 +00001575** the table has any PRIMARY KEY, INTEGER or otherwise.
1576**
drhd24cc422003-03-27 12:51:24 +00001577** Table.tnum is the page number for the root BTree page of the table in the
1578** database file. If Table.iDb is the index of the database table backend
1579** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that
drh7d10d5a2008-08-20 16:35:10 +00001580** holds temporary tables and indices. If TF_Ephemeral is set
1581** then the table is stored in a file that is automatically deleted
drhd24cc422003-03-27 12:51:24 +00001582** when the VDBE cursor to the table is closed. In this case Table.tnum
drh22f70c32002-02-18 01:17:00 +00001583** refers VDBE cursor number that holds the table open, not to the root
1584** page number. Transient tables are used to hold the results of a
1585** sub-query that appears instead of a real table name in the FROM clause
1586** of a SELECT statement.
drh75897232000-05-29 14:26:00 +00001587*/
1588struct Table {
drh7d10d5a2008-08-20 16:35:10 +00001589 char *zName; /* Name of the table or view */
drh7d10d5a2008-08-20 16:35:10 +00001590 Column *aCol; /* Information about each column */
1591 Index *pIndex; /* List of SQL indexes on this table. */
drh7d10d5a2008-08-20 16:35:10 +00001592 Select *pSelect; /* NULL for tables. Points to definition if a view. */
drh7d10d5a2008-08-20 16:35:10 +00001593 FKey *pFKey; /* Linked list of all foreign keys in this table */
1594 char *zColAff; /* String defining the affinity of each column */
drhffe07b22005-11-03 00:41:17 +00001595#ifndef SQLITE_OMIT_CHECK
drh2938f922012-03-07 19:13:29 +00001596 ExprList *pCheck; /* All CHECK constraints */
drhffe07b22005-11-03 00:41:17 +00001597#endif
dancfc9df72014-04-25 15:01:01 +00001598 LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */
drhd815f172012-09-13 14:42:43 +00001599 int tnum; /* Root BTree node for this table (see note above) */
1600 i16 iPKey; /* If not negative, use aCol[iPKey] as the primary key */
1601 i16 nCol; /* Number of columns in this table */
1602 u16 nRef; /* Number of pointers to this Table */
drhbf539c42013-10-05 18:16:02 +00001603 LogEst szTabRow; /* Estimated size of each table row in bytes */
drhdbd94862014-07-23 23:57:42 +00001604#ifdef SQLITE_ENABLE_COSTMULT
1605 LogEst costMult; /* Cost multiplier for using this table */
1606#endif
drhd815f172012-09-13 14:42:43 +00001607 u8 tabFlags; /* Mask of TF_* values */
1608 u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
danielk197719a8e7e2005-03-17 05:03:38 +00001609#ifndef SQLITE_OMIT_ALTERTABLE
drh7d10d5a2008-08-20 16:35:10 +00001610 int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
danielk197719a8e7e2005-03-17 05:03:38 +00001611#endif
drhe09daa92006-06-10 13:29:31 +00001612#ifndef SQLITE_OMIT_VIRTUALTABLE
drh7d10d5a2008-08-20 16:35:10 +00001613 int nModuleArg; /* Number of arguments to the module */
1614 char **azModuleArg; /* Text of all module args. [0] is module name */
drhd815f172012-09-13 14:42:43 +00001615 VTable *pVTable; /* List of VTable objects. */
drhe09daa92006-06-10 13:29:31 +00001616#endif
danielk19772f886d12009-02-28 10:47:41 +00001617 Trigger *pTrigger; /* List of triggers stored in pSchema */
drh7d10d5a2008-08-20 16:35:10 +00001618 Schema *pSchema; /* Schema that contains this table */
drh588a9a12008-09-01 15:52:10 +00001619 Table *pNextZombie; /* Next on the Parse.pZombieTab list */
drh75897232000-05-29 14:26:00 +00001620};
1621
1622/*
dan8ce71842014-01-14 20:14:09 +00001623** Allowed values for Table.tabFlags.
drh7d10d5a2008-08-20 16:35:10 +00001624*/
1625#define TF_Readonly 0x01 /* Read-only system table */
shane467bcf32008-11-24 20:01:32 +00001626#define TF_Ephemeral 0x02 /* An ephemeral table */
drh7d10d5a2008-08-20 16:35:10 +00001627#define TF_HasPrimaryKey 0x04 /* Table has a primary key */
1628#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
1629#define TF_Virtual 0x10 /* Is a virtual table */
drh81eba732013-10-19 23:31:56 +00001630#define TF_WithoutRowid 0x20 /* No rowid used. PRIMARY KEY is the key */
drh7d10d5a2008-08-20 16:35:10 +00001631
1632
1633/*
drh4cbdda92006-06-14 19:00:20 +00001634** Test to see whether or not a table is a virtual table. This is
1635** done as a macro so that it will be optimized out when virtual
1636** table support is omitted from the build.
1637*/
1638#ifndef SQLITE_OMIT_VIRTUALTABLE
drh7d10d5a2008-08-20 16:35:10 +00001639# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
drha371ace2012-09-13 14:22:47 +00001640# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0)
drh4cbdda92006-06-14 19:00:20 +00001641#else
danielk1977034ca142007-06-26 10:38:54 +00001642# define IsVirtual(X) 0
1643# define IsHiddenColumn(X) 0
drh4cbdda92006-06-14 19:00:20 +00001644#endif
1645
drhec95c442013-10-23 01:57:32 +00001646/* Does the table have a rowid */
1647#define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0)
1648
drh4cbdda92006-06-14 19:00:20 +00001649/*
drhc2eef3b2002-08-31 18:53:06 +00001650** Each foreign key constraint is an instance of the following structure.
1651**
1652** A foreign key is associated with two tables. The "from" table is
1653** the table that contains the REFERENCES clause that creates the foreign
1654** key. The "to" table is the table that is named in the REFERENCES clause.
1655** Consider this example:
1656**
1657** CREATE TABLE ex1(
1658** a INTEGER PRIMARY KEY,
1659** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
1660** );
1661**
1662** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
drhbd50a922013-11-03 02:27:58 +00001663** Equivalent names:
1664**
1665** from-table == child-table
1666** to-table == parent-table
drhc2eef3b2002-08-31 18:53:06 +00001667**
1668** Each REFERENCES clause generates an instance of the following structure
1669** which is attached to the from-table. The to-table need not exist when
drhe61922a2009-05-02 13:29:37 +00001670** the from-table is created. The existence of the to-table is not checked.
drhbd50a922013-11-03 02:27:58 +00001671**
1672** The list of all parents for child Table X is held at X.pFKey.
1673**
1674** A list of all children for a table named Z (which might not even exist)
1675** is held in Schema.fkeyHash with a hash key of Z.
drhc2eef3b2002-08-31 18:53:06 +00001676*/
1677struct FKey {
drh1f638ce2009-09-24 13:48:10 +00001678 Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
drhbd50a922013-11-03 02:27:58 +00001679 FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */
drh1f638ce2009-09-24 13:48:10 +00001680 char *zTo; /* Name of table that the key points to (aka: Parent) */
drhbd50a922013-11-03 02:27:58 +00001681 FKey *pNextTo; /* Next with the same zTo. Next child of zTo. */
1682 FKey *pPrevTo; /* Previous with the same zTo */
drhc2eef3b2002-08-31 18:53:06 +00001683 int nCol; /* Number of columns in this key */
drh4c429832009-10-12 22:30:49 +00001684 /* EV: R-30323-21917 */
drhbd50a922013-11-03 02:27:58 +00001685 u8 isDeferred; /* True if constraint checking is deferred till COMMIT */
1686 u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */
1687 Trigger *apTrigger[2];/* Triggers for aAction[] actions */
1688 struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
1689 int iFrom; /* Index of column in pFrom */
1690 char *zCol; /* Name of column in zTo. If NULL use PRIMARY KEY */
1691 } aCol[1]; /* One entry for each of nCol columns */
drhc2eef3b2002-08-31 18:53:06 +00001692};
1693
1694/*
danielk1977aaa40c12007-09-21 04:28:16 +00001695** SQLite supports many different ways to resolve a constraint
drh22f70c32002-02-18 01:17:00 +00001696** error. ROLLBACK processing means that a constraint violation
drh0bd1f4e2002-06-06 18:54:39 +00001697** causes the operation in process to fail and for the current transaction
drh1c928532002-01-31 15:54:21 +00001698** to be rolled back. ABORT processing means the operation in process
1699** fails and any prior changes from that one operation are backed out,
1700** but the transaction is not rolled back. FAIL processing means that
1701** the operation in progress stops and returns an error code. But prior
1702** changes due to the same operation are not backed out and no rollback
1703** occurs. IGNORE means that the particular row that caused the constraint
1704** error is not inserted or updated. Processing continues and no error
1705** is returned. REPLACE means that preexisting database rows that caused
1706** a UNIQUE constraint violation are removed so that the new insert or
1707** update can proceed. Processing continues and no error is reported.
drhc2eef3b2002-08-31 18:53:06 +00001708**
1709** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
1710** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
1711** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
1712** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
1713** referenced table row is propagated into the row that holds the
1714** foreign key.
drh1c928532002-01-31 15:54:21 +00001715**
drh968af522003-02-11 14:55:40 +00001716** The following symbolic values are used to record which type
drh1c928532002-01-31 15:54:21 +00001717** of action to take.
drh9cfcf5d2002-01-29 18:41:24 +00001718*/
drh1c928532002-01-31 15:54:21 +00001719#define OE_None 0 /* There is no constraint to check */
1720#define OE_Rollback 1 /* Fail the operation and rollback the transaction */
1721#define OE_Abort 2 /* Back out changes but do no rollback transaction */
1722#define OE_Fail 3 /* Stop the operation but leave all prior changes */
1723#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
1724#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
drhc2eef3b2002-08-31 18:53:06 +00001725
1726#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
1727#define OE_SetNull 7 /* Set the foreign key value to NULL */
1728#define OE_SetDflt 8 /* Set the foreign key value to its default */
1729#define OE_Cascade 9 /* Cascade the changes */
1730
drhc28c4e52013-10-03 19:21:41 +00001731#define OE_Default 10 /* Do whatever the default action is */
drh9cfcf5d2002-01-29 18:41:24 +00001732
drhd3d39e92004-05-20 22:16:29 +00001733
1734/*
1735** An instance of the following structure is passed as the first
1736** argument to sqlite3VdbeKeyCompare and is used to control the
1737** comparison of the two index keys.
drh323df792013-08-05 19:11:29 +00001738**
1739** Note that aSortOrder[] and aColl[] have nField+1 slots. There
1740** are nField slots for the columns of an index then one extra slot
1741** for the rowid at the end.
drhd3d39e92004-05-20 22:16:29 +00001742*/
1743struct KeyInfo {
drh2ec2fb22013-11-06 19:59:23 +00001744 u32 nRef; /* Number of references to this KeyInfo object */
drh9b8d0272010-08-09 15:44:21 +00001745 u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
drhad124322013-10-23 13:30:58 +00001746 u16 nField; /* Number of key columns in the index */
drh6fbe41a2013-10-30 20:22:55 +00001747 u16 nXField; /* Number of columns beyond the key columns */
drh2ec2fb22013-11-06 19:59:23 +00001748 sqlite3 *db; /* The database connection */
drh323df792013-08-05 19:11:29 +00001749 u8 *aSortOrder; /* Sort order for each column. */
drhd3d39e92004-05-20 22:16:29 +00001750 CollSeq *aColl[1]; /* Collating sequence for each term of the key */
1751};
1752
drh9cfcf5d2002-01-29 18:41:24 +00001753/*
drhe63d9992008-08-13 19:11:48 +00001754** An instance of the following structure holds information about a
1755** single index record that has already been parsed out into individual
1756** values.
1757**
1758** A record is an object that contains one or more fields of data.
1759** Records are used to store the content of a table row and to store
1760** the key of an index. A blob encoding of a record is created by
shane467bcf32008-11-24 20:01:32 +00001761** the OP_MakeRecord opcode of the VDBE and is disassembled by the
drhe63d9992008-08-13 19:11:48 +00001762** OP_Column opcode.
1763**
1764** This structure holds a record that has already been disassembled
shane467bcf32008-11-24 20:01:32 +00001765** into its constituent fields.
dan3833e932014-03-01 19:44:56 +00001766**
1767** The r1 and r2 member variables are only used by the optimized comparison
1768** functions vdbeRecordCompareInt() and vdbeRecordCompareString().
drhe63d9992008-08-13 19:11:48 +00001769*/
1770struct UnpackedRecord {
1771 KeyInfo *pKeyInfo; /* Collation and sort-order information */
1772 u16 nField; /* Number of entries in apMem[] */
drha9e0aeb2014-03-04 00:15:16 +00001773 i8 default_rc; /* Comparison result if keys are equal */
dan38fdead2014-04-01 10:19:02 +00001774 u8 errCode; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
drhe63d9992008-08-13 19:11:48 +00001775 Mem *aMem; /* Values */
dan3833e932014-03-01 19:44:56 +00001776 int r1; /* Value to return if (lhs > rhs) */
1777 int r2; /* Value to return if (rhs < lhs) */
drhe63d9992008-08-13 19:11:48 +00001778};
1779
drhe63d9992008-08-13 19:11:48 +00001780
1781/*
drh66b89c82000-11-28 20:47:17 +00001782** Each SQL index is represented in memory by an
drh75897232000-05-29 14:26:00 +00001783** instance of the following structure.
drh967e8b72000-06-21 13:59:10 +00001784**
1785** The columns of the table that are to be indexed are described
1786** by the aiColumn[] field of this structure. For example, suppose
1787** we have the following table and index:
1788**
1789** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
1790** CREATE INDEX Ex2 ON Ex1(c3,c1);
1791**
1792** In the Table structure describing Ex1, nCol==3 because there are
1793** three columns in the table. In the Index structure describing
1794** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
1795** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
1796** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
1797** The second column to be indexed (c1) has an index of 0 in
1798** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
drhea1ba172003-04-20 00:00:23 +00001799**
1800** The Index.onError field determines whether or not the indexed columns
1801** must be unique and what to do if they are not. When Index.onError=OE_None,
1802** it means this is not a unique index. Otherwise it is a unique index
1803** and the value of Index.onError indicate the which conflict resolution
1804** algorithm to employ whenever an attempt is made to insert a non-unique
1805** element.
drh75897232000-05-29 14:26:00 +00001806*/
1807struct Index {
drhb376dae2013-01-01 14:01:28 +00001808 char *zName; /* Name of this index */
drhbbbdc832013-10-22 18:01:40 +00001809 i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */
dancfc9df72014-04-25 15:01:01 +00001810 LogEst *aiRowLogEst; /* From ANALYZE: Est. rows selected by each column */
drhb376dae2013-01-01 14:01:28 +00001811 Table *pTable; /* The SQL table being indexed */
1812 char *zColAff; /* String defining the affinity of each column */
1813 Index *pNext; /* The next index associated with the same table */
1814 Schema *pSchema; /* Schema containing this index */
1815 u8 *aSortOrder; /* for each column: True==DESC, False==ASC */
1816 char **azColl; /* Array of collation sequence names for index */
drh1fe05372013-07-31 18:12:26 +00001817 Expr *pPartIdxWhere; /* WHERE clause for partial indices */
drhb376dae2013-01-01 14:01:28 +00001818 int tnum; /* DB Page containing root of this index */
drhbf539c42013-10-05 18:16:02 +00001819 LogEst szIdxRow; /* Estimated average row size in bytes */
drhbbbdc832013-10-22 18:01:40 +00001820 u16 nKeyCol; /* Number of columns forming the key */
1821 u16 nColumn; /* Number of columns stored in the index */
drhbf539c42013-10-05 18:16:02 +00001822 u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
drh48dd1d82014-05-27 18:18:58 +00001823 unsigned idxType:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
drhb376dae2013-01-01 14:01:28 +00001824 unsigned bUnordered:1; /* Use this index for == or IN queries only */
drh7699d1c2013-06-04 12:42:29 +00001825 unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */
drh7f9c5db2013-10-23 00:32:58 +00001826 unsigned isResized:1; /* True if resizeIndexObject() has been called */
drhec95c442013-10-23 01:57:32 +00001827 unsigned isCovering:1; /* True if this is a covering index */
drhf9df2fb2014-11-15 19:08:13 +00001828 unsigned noSkipScan:1; /* Do not try to use skip-scan if true */
drh1435a9a2013-08-27 23:15:44 +00001829#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
drh2b9cf662011-09-22 20:52:56 +00001830 int nSample; /* Number of elements in aSample[] */
dan8ad169a2013-08-12 20:14:04 +00001831 int nSampleCol; /* Size of IndexSample.anEq[] and so on */
daneea568d2013-08-07 19:46:15 +00001832 tRowcnt *aAvgEq; /* Average nEq values for keys not in aSample */
drhfaacf172011-08-12 01:51:45 +00001833 IndexSample *aSample; /* Samples of the left-most key */
drh9f07cf72014-10-22 15:27:05 +00001834 tRowcnt *aiRowEst; /* Non-logarithmic stat1 data for this index */
1835 tRowcnt nRowEst0; /* Non-logarithmic number of rows in the index */
drhfaacf172011-08-12 01:51:45 +00001836#endif
dan02fa4692009-08-17 17:06:58 +00001837};
1838
1839/*
drh48dd1d82014-05-27 18:18:58 +00001840** Allowed values for Index.idxType
1841*/
1842#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
1843#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */
1844#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */
1845
1846/* Return true if index X is a PRIMARY KEY index */
1847#define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
1848
drh5f1d1d92014-07-31 22:59:04 +00001849/* Return true if index X is a UNIQUE index */
1850#define IsUniqueIndex(X) ((X)->onError!=OE_None)
1851
drh48dd1d82014-05-27 18:18:58 +00001852/*
drh74e7c8f2011-10-21 19:06:32 +00001853** Each sample stored in the sqlite_stat3 table is represented in memory
1854** using a structure of this type. See documentation at the top of the
1855** analyze.c source file for additional information.
dan02fa4692009-08-17 17:06:58 +00001856*/
1857struct IndexSample {
danf52bb8d2013-08-03 20:24:58 +00001858 void *p; /* Pointer to sampled record */
1859 int n; /* Size of record in bytes */
1860 tRowcnt *anEq; /* Est. number of rows where the key equals this sample */
1861 tRowcnt *anLt; /* Est. number of rows where key is less than this sample */
1862 tRowcnt *anDLt; /* Est. number of distinct keys less than this sample */
drh75897232000-05-29 14:26:00 +00001863};
1864
1865/*
1866** Each token coming out of the lexer is an instance of
drh4b59ab52002-08-24 18:24:51 +00001867** this structure. Tokens are also used as part of an expression.
drh4efc4752004-01-16 15:55:37 +00001868**
1869** Note if Token.z==0 then Token.dyn and Token.n are undefined and
shane467bcf32008-11-24 20:01:32 +00001870** may contain random values. Do not make any assumptions about Token.dyn
drh4efc4752004-01-16 15:55:37 +00001871** and Token.n when Token.z==0.
drh75897232000-05-29 14:26:00 +00001872*/
1873struct Token {
drhb7916a72009-05-27 10:31:29 +00001874 const char *z; /* Text of the token. Not NULL-terminated! */
1875 unsigned int n; /* Number of characters in this token */
drh75897232000-05-29 14:26:00 +00001876};
1877
1878/*
drh13449892005-09-07 21:22:45 +00001879** An instance of this structure contains information needed to generate
1880** code for a SELECT that contains aggregate functions.
1881**
1882** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
1883** pointer to this structure. The Expr.iColumn field is the index in
1884** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
1885** code for that node.
1886**
1887** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
1888** original Select structure that describes the SELECT statement. These
1889** fields do not need to be freed when deallocating the AggInfo structure.
1890*/
1891struct AggInfo {
1892 u8 directMode; /* Direct rendering mode means take data directly
1893 ** from source tables rather than from accumulators */
1894 u8 useSortingIdx; /* In direct mode, reference the sorting index rather
1895 ** than the source table */
1896 int sortingIdx; /* Cursor number of the sorting index */
dan5134d132011-09-02 10:31:11 +00001897 int sortingIdxPTab; /* Cursor number of pseudo-table */
drh13449892005-09-07 21:22:45 +00001898 int nSortingColumn; /* Number of columns in the sorting index */
drh7e61d182013-12-20 13:11:45 +00001899 int mnReg, mxReg; /* Range of registers allocated for aCol and aFunc */
drha4510172012-02-02 15:50:17 +00001900 ExprList *pGroupBy; /* The group by clause */
drh13449892005-09-07 21:22:45 +00001901 struct AggInfo_col { /* For each column used in source tables */
danielk19770817d0d2007-02-14 09:19:36 +00001902 Table *pTab; /* Source table */
drh13449892005-09-07 21:22:45 +00001903 int iTable; /* Cursor number of the source table */
1904 int iColumn; /* Column number within the source table */
1905 int iSorterColumn; /* Column number in the sorting index */
1906 int iMem; /* Memory location that acts as accumulator */
drh5774b802005-09-07 22:48:16 +00001907 Expr *pExpr; /* The original expression */
drh13449892005-09-07 21:22:45 +00001908 } *aCol;
1909 int nColumn; /* Number of used entries in aCol[] */
drh13449892005-09-07 21:22:45 +00001910 int nAccumulator; /* Number of columns that show through to the output.
1911 ** Additional columns are used only as parameters to
1912 ** aggregate functions */
1913 struct AggInfo_func { /* For each aggregate function */
1914 Expr *pExpr; /* Expression encoding the function */
1915 FuncDef *pFunc; /* The aggregate function implementation */
1916 int iMem; /* Memory location that acts as accumulator */
shane467bcf32008-11-24 20:01:32 +00001917 int iDistinct; /* Ephemeral table used to enforce DISTINCT */
drh13449892005-09-07 21:22:45 +00001918 } *aFunc;
1919 int nFunc; /* Number of entries in aFunc[] */
drh13449892005-09-07 21:22:45 +00001920};
1921
1922/*
drh8677d302009-11-04 13:17:14 +00001923** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
1924** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
1925** than 32767 we have to make it 32-bit. 16-bit is preferred because
1926** it uses less memory in the Expr object, which is a big memory user
1927** in systems with lots of prepared statements. And few applications
1928** need more than about 10 or 20 variables. But some extreme users want
1929** to have prepared statements with over 32767 variables, and for them
1930** the option is available (at compile-time).
1931*/
1932#if SQLITE_MAX_VARIABLE_NUMBER<=32767
drh481aa742009-11-05 18:46:02 +00001933typedef i16 ynVar;
drh8677d302009-11-04 13:17:14 +00001934#else
1935typedef int ynVar;
1936#endif
1937
1938/*
drh75897232000-05-29 14:26:00 +00001939** Each node of an expression in the parse tree is an instance
drh22f70c32002-02-18 01:17:00 +00001940** of this structure.
1941**
danielk19776ab3a2e2009-02-19 14:39:25 +00001942** Expr.op is the opcode. The integer parser token codes are reused
1943** as opcodes here. For example, the parser defines TK_GE to be an integer
1944** code representing the ">=" operator. This same integer code is reused
drh22f70c32002-02-18 01:17:00 +00001945** to represent the greater-than-or-equal-to operator in the expression
1946** tree.
1947**
danielk19776ab3a2e2009-02-19 14:39:25 +00001948** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
1949** or TK_STRING), then Expr.token contains the text of the SQL literal. If
1950** the expression is a variable (TK_VARIABLE), then Expr.token contains the
1951** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
1952** then Expr.token contains the name of the function.
drh22f70c32002-02-18 01:17:00 +00001953**
danielk19776ab3a2e2009-02-19 14:39:25 +00001954** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
1955** binary operator. Either or both may be NULL.
1956**
1957** Expr.x.pList is a list of arguments if the expression is an SQL function,
1958** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
1959** Expr.x.pSelect is used if the expression is a sub-select or an expression of
1960** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
1961** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
1962** valid.
drh22f70c32002-02-18 01:17:00 +00001963**
1964** An expression of the form ID or ID.ID refers to a column in a table.
1965** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
1966** the integer cursor number of a VDBE cursor pointing to that table and
1967** Expr.iColumn is the column number for the specific column. If the
1968** expression is used as a result in an aggregate SELECT, then the
1969** value is also stored in the Expr.iAgg column in the aggregate so that
1970** it can be accessed after all aggregates are computed.
1971**
danielk19776ab3a2e2009-02-19 14:39:25 +00001972** If the expression is an unbound variable marker (a question mark
1973** character '?' in the original SQL) then the Expr.iTable holds the index
1974** number for that variable.
drh22f70c32002-02-18 01:17:00 +00001975**
drh1398ad32005-01-19 23:24:50 +00001976** If the expression is a subquery then Expr.iColumn holds an integer
1977** register number containing the result of the subquery. If the
1978** subquery gives a constant result, then iTable is -1. If the subquery
1979** gives a different answer at different times during statement processing
1980** then iTable is the address of a subroutine that computes the subquery.
1981**
danielk1977aee18ef2005-03-09 12:26:50 +00001982** If the Expr is of type OP_Column, and the table it is selecting from
1983** is a disk table or the "old.*" pseudo-table, then pTab points to the
1984** corresponding table definition.
danielk19776ab3a2e2009-02-19 14:39:25 +00001985**
1986** ALLOCATION NOTES:
1987**
drh12ffee82009-04-08 13:51:51 +00001988** Expr objects can use a lot of memory space in database schema. To
1989** help reduce memory requirements, sometimes an Expr object will be
1990** truncated. And to reduce the number of memory allocations, sometimes
1991** two or more Expr objects will be stored in a single memory allocation,
drh33e619f2009-05-28 01:00:55 +00001992** together with Expr.zToken strings.
danielk19776ab3a2e2009-02-19 14:39:25 +00001993**
drhb7916a72009-05-27 10:31:29 +00001994** If the EP_Reduced and EP_TokenOnly flags are set when
drh12ffee82009-04-08 13:51:51 +00001995** an Expr object is truncated. When EP_Reduced is set, then all
1996** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
1997** are contained within the same memory allocation. Note, however, that
1998** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
1999** allocated, regardless of whether or not EP_Reduced is set.
drh75897232000-05-29 14:26:00 +00002000*/
2001struct Expr {
drh1cc093c2002-06-24 22:01:57 +00002002 u8 op; /* Operation performed by this node */
drha9fd84b2004-05-18 23:21:35 +00002003 char affinity; /* The affinity of the column or 0 if not a column */
drhc5cd1242013-09-12 16:50:49 +00002004 u32 flags; /* Various flags. EP_* See below */
drh33e619f2009-05-28 01:00:55 +00002005 union {
2006 char *zToken; /* Token value. Zero terminated and dequoted */
drhd50ffc42011-03-08 02:38:28 +00002007 int iValue; /* Non-negative integer value if EP_IntValue */
drh33e619f2009-05-28 01:00:55 +00002008 } u;
danielk19776ab3a2e2009-02-19 14:39:25 +00002009
2010 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
2011 ** space is allocated for the fields below this point. An attempt to
2012 ** access them will result in a segfault or malfunction.
2013 *********************************************************************/
2014
danielk19776ab3a2e2009-02-19 14:39:25 +00002015 Expr *pLeft; /* Left subnode */
2016 Expr *pRight; /* Right subnode */
2017 union {
drhc5cd1242013-09-12 16:50:49 +00002018 ExprList *pList; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */
2019 Select *pSelect; /* EP_xIsSelect and op = IN, EXISTS, SELECT */
danielk19776ab3a2e2009-02-19 14:39:25 +00002020 } x;
danielk19776ab3a2e2009-02-19 14:39:25 +00002021
2022 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
2023 ** space is allocated for the fields below this point. An attempt to
2024 ** access them will result in a segfault or malfunction.
2025 *********************************************************************/
2026
drh6ec65492012-09-13 19:59:09 +00002027#if SQLITE_MAX_EXPR_DEPTH>0
2028 int nHeight; /* Height of the tree headed by this node */
2029#endif
drhb7916a72009-05-27 10:31:29 +00002030 int iTable; /* TK_COLUMN: cursor number of table holding column
dan2832ad42009-08-31 15:27:27 +00002031 ** TK_REGISTER: register number
drhcca9f3d2013-09-06 15:23:29 +00002032 ** TK_TRIGGER: 1 -> new, 0 -> old
drhd05ab6a2014-10-25 13:42:16 +00002033 ** EP_Unlikely: 134217728 times likelihood */
drh8677d302009-11-04 13:17:14 +00002034 ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
dan937d0de2009-10-15 18:35:38 +00002035 ** TK_VARIABLE: variable number (always >= 1). */
drhb7916a72009-05-27 10:31:29 +00002036 i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
2037 i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */
drh030796d2012-08-23 16:18:10 +00002038 u8 op2; /* TK_REGISTER: original value of Expr.op
2039 ** TK_COLUMN: the value of p5 for OP_Column
2040 ** TK_AGG_FUNCTION: nesting depth */
drh13449892005-09-07 21:22:45 +00002041 AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
drh7d10d5a2008-08-20 16:35:10 +00002042 Table *pTab; /* Table for TK_COLUMN expressions. */
drh75897232000-05-29 14:26:00 +00002043};
2044
2045/*
drh1f162302002-10-27 19:35:33 +00002046** The following are the meanings of bits in the Expr.flags field.
2047*/
drh72673a22014-12-04 16:27:17 +00002048#define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */
drhc5cd1242013-09-12 16:50:49 +00002049#define EP_Agg 0x000002 /* Contains one or more aggregate functions */
2050#define EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */
2051#define EP_Error 0x000008 /* Expression contains one or more errors */
2052#define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */
2053#define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */
2054#define EP_DblQuoted 0x000040 /* token.z was originally in "..." */
2055#define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */
drhfbb24d12014-03-20 17:03:30 +00002056#define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */
2057#define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */
drhc5cd1242013-09-12 16:50:49 +00002058#define EP_IntValue 0x000400 /* Integer value contained in u.iValue */
2059#define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */
drha4c3c872013-09-12 17:29:25 +00002060#define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */
drhc5cd1242013-09-12 16:50:49 +00002061#define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */
2062#define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
2063#define EP_Static 0x008000 /* Held in memory not obtained from malloc() */
2064#define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */
drhebb6a652013-09-12 23:42:22 +00002065#define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
drha4c3c872013-09-12 17:29:25 +00002066#define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */
drh63f84572015-02-09 14:07:07 +00002067#define EP_ConstFunc 0x080000 /* Node is a SQLITE_FUNC_CONSTANT function */
drh72673a22014-12-04 16:27:17 +00002068#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
drh885a5b02015-02-09 15:21:36 +00002069#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
2070
2071/*
2072** Combinations of two or more EP_* flags
2073*/
2074#define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */
drh1af466e2009-03-24 15:31:28 +00002075
2076/*
drh1f162302002-10-27 19:35:33 +00002077** These macros can be used to test, set, or clear bits in the
2078** Expr.flags field.
2079*/
drhc5cd1242013-09-12 16:50:49 +00002080#define ExprHasProperty(E,P) (((E)->flags&(P))!=0)
2081#define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P))
drh1f162302002-10-27 19:35:33 +00002082#define ExprSetProperty(E,P) (E)->flags|=(P)
2083#define ExprClearProperty(E,P) (E)->flags&=~(P)
2084
drhebb6a652013-09-12 23:42:22 +00002085/* The ExprSetVVAProperty() macro is used for Verification, Validation,
2086** and Accreditation only. It works like ExprSetProperty() during VVA
2087** processes but is a no-op for delivery.
2088*/
2089#ifdef SQLITE_DEBUG
2090# define ExprSetVVAProperty(E,P) (E)->flags|=(P)
2091#else
2092# define ExprSetVVAProperty(E,P)
2093#endif
2094
drh1f162302002-10-27 19:35:33 +00002095/*
danielk19776ab3a2e2009-02-19 14:39:25 +00002096** Macros to determine the number of bytes required by a normal Expr
2097** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
2098** and an Expr struct with the EP_TokenOnly flag set.
2099*/
drh12ffee82009-04-08 13:51:51 +00002100#define EXPR_FULLSIZE sizeof(Expr) /* Full size */
2101#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
drhb7916a72009-05-27 10:31:29 +00002102#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
danielk19776ab3a2e2009-02-19 14:39:25 +00002103
2104/*
2105** Flags passed to the sqlite3ExprDup() function. See the header comment
2106** above sqlite3ExprDup() for details.
2107*/
drh12ffee82009-04-08 13:51:51 +00002108#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
danielk19776ab3a2e2009-02-19 14:39:25 +00002109
2110/*
drh75897232000-05-29 14:26:00 +00002111** A list of expressions. Each expression may optionally have a
2112** name. An expr/name combination can be used in several ways, such
2113** as the list of "expr AS ID" fields following a "SELECT" or in the
2114** list of "ID = expr" items in an UPDATE. A list of expressions can
drhad3cab52002-05-24 02:04:32 +00002115** also be used as the argument to a function, in which case the a.zName
drh75897232000-05-29 14:26:00 +00002116** field is not used.
drh0dde4732012-12-19 13:41:03 +00002117**
2118** By default the Expr.zSpan field holds a human-readable description of
2119** the expression that is used in the generation of error messages and
2120** column labels. In this case, Expr.zSpan is typically the text of a
2121** column expression as it exists in a SELECT statement. However, if
2122** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
drh3e3f1a52013-01-03 00:45:56 +00002123** of the result column in the form: DATABASE.TABLE.COLUMN. This later
2124** form is used for name resolution with nested FROM clauses.
drh75897232000-05-29 14:26:00 +00002125*/
2126struct ExprList {
2127 int nExpr; /* Number of expressions on the list */
drhd872bb12012-02-02 01:58:08 +00002128 struct ExprList_item { /* For each expression in the list */
drh0dde4732012-12-19 13:41:03 +00002129 Expr *pExpr; /* The list of expressions */
2130 char *zName; /* Token associated with this expression */
2131 char *zSpan; /* Original text of the expression */
2132 u8 sortOrder; /* 1 for DESC or 0 for ASC */
2133 unsigned done :1; /* A flag to indicate when processing is finished */
drh3e3f1a52013-01-03 00:45:56 +00002134 unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
drhd673cdd2013-11-21 21:23:31 +00002135 unsigned reusable :1; /* Constant expression is reusable */
drhc2acc4e2013-11-15 18:15:19 +00002136 union {
2137 struct {
2138 u16 iOrderByCol; /* For ORDER BY, column number in result set */
2139 u16 iAlias; /* Index into Parse.aAlias[] for zName */
2140 } x;
2141 int iConstExprReg; /* Register in which Expr value is cached */
2142 } u;
drhd872bb12012-02-02 01:58:08 +00002143 } *a; /* Alloc a power of two greater or equal to nExpr */
drh75897232000-05-29 14:26:00 +00002144};
2145
2146/*
drhb7916a72009-05-27 10:31:29 +00002147** An instance of this structure is used by the parser to record both
2148** the parse tree for an expression and the span of input text for an
2149** expression.
2150*/
2151struct ExprSpan {
2152 Expr *pExpr; /* The expression parse tree */
2153 const char *zStart; /* First character of input text */
2154 const char *zEnd; /* One character past the end of input text */
2155};
2156
2157/*
drhad3cab52002-05-24 02:04:32 +00002158** An instance of this structure can hold a simple list of identifiers,
2159** such as the list "a,b,c" in the following statements:
2160**
2161** INSERT INTO t(a,b,c) VALUES ...;
2162** CREATE INDEX idx ON t(a,b,c);
2163** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
2164**
2165** The IdList.a.idx field is used when the IdList represents the list of
2166** column names after a table name in an INSERT statement. In the statement
2167**
2168** INSERT INTO t(a,b,c) ...
2169**
2170** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
drh75897232000-05-29 14:26:00 +00002171*/
2172struct IdList {
drh6d4abfb2001-10-22 02:58:08 +00002173 struct IdList_item {
drhad3cab52002-05-24 02:04:32 +00002174 char *zName; /* Name of the identifier */
drh967e8b72000-06-21 13:59:10 +00002175 int idx; /* Index in some Table.aCol[] of a column named zName */
drhad3cab52002-05-24 02:04:32 +00002176 } *a;
drh13449892005-09-07 21:22:45 +00002177 int nId; /* Number of identifiers on the list */
drhad3cab52002-05-24 02:04:32 +00002178};
2179
2180/*
drh51669862004-12-18 18:40:26 +00002181** The bitmask datatype defined below is used for various optimizations.
drhca83ac52007-02-01 01:40:44 +00002182**
2183** Changing this from a 64-bit to a 32-bit type limits the number of
2184** tables in a join to 32 instead of 64. But it also reduces the size
2185** of the library by 738 bytes on ix86.
drh51669862004-12-18 18:40:26 +00002186*/
drhca83ac52007-02-01 01:40:44 +00002187typedef u64 Bitmask;
drh51669862004-12-18 18:40:26 +00002188
2189/*
danielk197700e13612008-11-17 19:18:54 +00002190** The number of bits in a Bitmask. "BMS" means "BitMask Size".
2191*/
2192#define BMS ((int)(sizeof(Bitmask)*8))
2193
2194/*
drh7699d1c2013-06-04 12:42:29 +00002195** A bit in a Bitmask
2196*/
2197#define MASKBIT(n) (((Bitmask)1)<<(n))
drh693e6712014-01-24 22:58:00 +00002198#define MASKBIT32(n) (((unsigned int)1)<<(n))
drh7699d1c2013-06-04 12:42:29 +00002199
2200/*
drhad3cab52002-05-24 02:04:32 +00002201** The following structure describes the FROM clause of a SELECT statement.
2202** Each table or subquery in the FROM clause is a separate element of
2203** the SrcList.a[] array.
drhd24cc422003-03-27 12:51:24 +00002204**
2205** With the addition of multiple database support, the following structure
2206** can also be used to describe a particular table such as the table that
2207** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
2208** such a table must be a simple name: ID. But in SQLite, the table can
2209** now be identified by a database name, a dot, then the table name: ID.ID.
drhc49de5d2007-01-19 01:06:01 +00002210**
2211** The jointype starts out showing the join type between the current table
2212** and the next table on the list. The parser builds the list this way.
2213** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
2214** jointype expresses the join between the table and the previous table.
drh2a6a7ee2010-04-07 14:33:07 +00002215**
2216** In the colUsed field, the high-order bit (bit 63) is set if the table
2217** contains more than 63 columns and the 64-th or later column is used.
drhad3cab52002-05-24 02:04:32 +00002218*/
2219struct SrcList {
drh6d1626e2014-03-05 15:52:43 +00002220 int nSrc; /* Number of tables or subqueries in the FROM clause */
2221 u32 nAlloc; /* Number of entries allocated in a[] below */
drhad3cab52002-05-24 02:04:32 +00002222 struct SrcList_item {
dan41fb5cd2012-10-04 19:33:00 +00002223 Schema *pSchema; /* Schema to which this item is fixed */
drh113088e2003-03-20 01:16:58 +00002224 char *zDatabase; /* Name of database holding this table */
drhad3cab52002-05-24 02:04:32 +00002225 char *zName; /* Name of the table */
2226 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
drhdaffd0e2001-04-11 14:28:42 +00002227 Table *pTab; /* An SQL table corresponding to zName */
2228 Select *pSelect; /* A SELECT statement used in place of a table name */
drh5b6a9ed2011-09-15 23:58:14 +00002229 int addrFillSub; /* Address of subroutine to manifest a subquery */
2230 int regReturn; /* Register holding return address of addrFillSub */
drh5f612292014-02-08 23:20:32 +00002231 int regResult; /* Registers holding results of a co-routine */
drhc49de5d2007-01-19 01:06:01 +00002232 u8 jointype; /* Type of join between this able and the previous */
drh21172c42012-10-30 00:29:07 +00002233 unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */
2234 unsigned isCorrelated :1; /* True if sub-query is correlated */
2235 unsigned viaCoroutine :1; /* Implemented as a co-routine */
danf43fe6e2014-01-15 18:12:00 +00002236 unsigned isRecursive :1; /* True for recursive reference in WITH */
dance7e1892010-12-01 19:00:48 +00002237#ifndef SQLITE_OMIT_EXPLAIN
2238 u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */
2239#endif
drhe68fbe72007-02-13 12:49:24 +00002240 int iCursor; /* The VDBE cursor number used to access this table */
drhad3cab52002-05-24 02:04:32 +00002241 Expr *pOn; /* The ON clause of a join */
2242 IdList *pUsing; /* The USING clause of a join */
danielk1977cd38d522009-01-02 17:33:46 +00002243 Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
danielk197785574e32008-10-06 05:32:18 +00002244 char *zIndex; /* Identifier from "INDEXED BY <zIndex>" clause */
2245 Index *pIndex; /* Index structure corresponding to zIndex, if any */
drh113088e2003-03-20 01:16:58 +00002246 } a[1]; /* One entry for each identifier on the list */
drh75897232000-05-29 14:26:00 +00002247};
2248
2249/*
drh01f3f252002-05-24 16:14:15 +00002250** Permitted values of the SrcList.a.jointype field
2251*/
2252#define JT_INNER 0x0001 /* Any kind of inner or cross join */
drh3dec2232005-09-10 15:28:09 +00002253#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
2254#define JT_NATURAL 0x0004 /* True for a "natural" join */
2255#define JT_LEFT 0x0008 /* Left outer join */
2256#define JT_RIGHT 0x0010 /* Right outer join */
2257#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
2258#define JT_ERROR 0x0040 /* unknown or unsupported join type */
drh01f3f252002-05-24 16:14:15 +00002259
drh111a6a72008-12-21 03:51:16 +00002260
2261/*
drh336a5302009-04-24 15:46:21 +00002262** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
2263** and the WhereInfo.wctrlFlags member.
drh08c88eb2008-04-10 13:33:18 +00002264*/
drh6df2acd2008-12-28 16:55:25 +00002265#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
2266#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
2267#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
2268#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
drh336a5302009-04-24 15:46:21 +00002269#define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */
drh9ef61f42011-10-07 14:40:59 +00002270#define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */
2271#define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */
2272#define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */
drh8e8e7ef2015-03-02 17:25:00 +00002273#define WHERE_NO_AUTOINDEX 0x0080 /* Disallow automatic indexes */
drh319f6772013-05-14 15:31:07 +00002274#define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */
drh4f402f22013-06-11 18:59:38 +00002275#define WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */
drh6457a352013-06-21 00:35:37 +00002276#define WHERE_WANT_DISTINCT 0x0400 /* All output needs to be distinct */
dan374cd782014-04-21 13:21:56 +00002277#define WHERE_SORTBYGROUP 0x0800 /* Support sqlite3WhereIsSorted() */
drh35263192014-07-22 20:02:19 +00002278#define WHERE_REOPEN_IDX 0x1000 /* Try to use OP_ReopenIdx */
danielk1977a9d1ccb2008-01-05 17:39:29 +00002279
drh4f402f22013-06-11 18:59:38 +00002280/* Allowed return values from sqlite3WhereIsDistinct()
drh75897232000-05-29 14:26:00 +00002281*/
drhe8e4af72012-09-21 00:04:28 +00002282#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
2283#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */
2284#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */
2285#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */
dan38cc40c2011-06-30 20:17:15 +00002286
drh75897232000-05-29 14:26:00 +00002287/*
danielk1977b3bce662005-01-29 08:32:43 +00002288** A NameContext defines a context in which to resolve table and column
2289** names. The context consists of a list of tables (the pSrcList) field and
2290** a list of named expression (pEList). The named expression list may
2291** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
2292** to the table being operated on by INSERT, UPDATE, or DELETE. The
2293** pEList corresponds to the result set of a SELECT and is NULL for
2294** other statements.
2295**
2296** NameContexts can be nested. When resolving names, the inner-most
2297** context is searched first. If no match is found, the next outer
2298** context is checked. If there is still no match, the next context
2299** is checked. This process continues until either a match is found
2300** or all contexts are check. When a match is found, the nRef member of
2301** the context containing the match is incremented.
2302**
2303** Each subquery gets a new NameContext. The pNext field points to the
2304** NameContext in the parent query. Thus the process of scanning the
2305** NameContext list corresponds to searching through successively outer
2306** subqueries looking for a match.
2307*/
2308struct NameContext {
2309 Parse *pParse; /* The parser */
2310 SrcList *pSrcList; /* One or more tables used to resolve names */
drh26080d92013-08-15 14:27:42 +00002311 ExprList *pEList; /* Optional list of result-set columns */
drh13449892005-09-07 21:22:45 +00002312 AggInfo *pAggInfo; /* Information about aggregates at this level */
danielk1977b3bce662005-01-29 08:32:43 +00002313 NameContext *pNext; /* Next outer name context. NULL for outermost */
drha51009b2012-05-21 19:11:25 +00002314 int nRef; /* Number of names resolved by this context */
2315 int nErr; /* Number of errors encountered while resolving names */
drh9588ad92014-09-15 14:46:02 +00002316 u16 ncFlags; /* Zero or more NC_* flags defined below */
danielk1977b3bce662005-01-29 08:32:43 +00002317};
2318
2319/*
drha51009b2012-05-21 19:11:25 +00002320** Allowed values for the NameContext, ncFlags field.
drh9588ad92014-09-15 14:46:02 +00002321**
2322** Note: NC_MinMaxAgg must have the same value as SF_MinMaxAgg and
2323** SQLITE_FUNC_MINMAX.
2324**
drha51009b2012-05-21 19:11:25 +00002325*/
drh9588ad92014-09-15 14:46:02 +00002326#define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */
2327#define NC_HasAgg 0x0002 /* One or more aggregate functions seen */
2328#define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */
2329#define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */
2330#define NC_PartIdx 0x0010 /* True if resolving a partial index WHERE */
2331#define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */
drha51009b2012-05-21 19:11:25 +00002332
2333/*
drh9bb61fe2000-06-05 16:01:39 +00002334** An instance of the following structure contains all information
2335** needed to generate code for a single SELECT statement.
drha76b5df2002-02-23 02:32:10 +00002336**
drhd11d3822002-06-21 23:01:49 +00002337** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
2338** If there is a LIMIT clause, the parser sets nLimit to the value of the
2339** limit and nOffset to the value of the offset (or 0 if there is not
2340** offset). But later on, nLimit and nOffset become the memory locations
2341** in the VDBE that record the limit and offset counters.
drh0342b1f2005-09-01 03:07:44 +00002342**
drhb9bb7c12006-06-11 23:41:55 +00002343** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
drh0342b1f2005-09-01 03:07:44 +00002344** These addresses must be stored so that we can go back and fill in
drh66a51672008-01-03 00:01:23 +00002345** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
drh0342b1f2005-09-01 03:07:44 +00002346** the number of columns in P2 can be computed at the same time
drhb9bb7c12006-06-11 23:41:55 +00002347** as the OP_OpenEphm instruction is coded because not
drh0342b1f2005-09-01 03:07:44 +00002348** enough information about the compound query is known at that point.
drhb9bb7c12006-06-11 23:41:55 +00002349** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
drh2c797332012-09-20 14:26:22 +00002350** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
drh0342b1f2005-09-01 03:07:44 +00002351** sequences for the ORDER BY clause.
drh9bb61fe2000-06-05 16:01:39 +00002352*/
2353struct Select {
drh9bb61fe2000-06-05 16:01:39 +00002354 ExprList *pEList; /* The fields of the result */
drh7b58dae2003-07-20 01:16:46 +00002355 u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
drh7d10d5a2008-08-20 16:35:10 +00002356 u16 selFlags; /* Various SF_* values */
drha4510172012-02-02 15:50:17 +00002357 int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
drhabd4c722014-09-20 18:18:33 +00002358#if SELECTTRACE_ENABLED
drheb9b8842014-09-21 00:27:26 +00002359 char zSelName[12]; /* Symbolic name of this SELECT use for debugging */
drhabd4c722014-09-20 18:18:33 +00002360#endif
drh079a3072014-03-19 14:10:55 +00002361 int addrOpenEphm[2]; /* OP_OpenEphem opcodes related to this select */
drhc63367e2013-06-10 20:46:50 +00002362 u64 nSelectRow; /* Estimated number of result rows */
drhad3cab52002-05-24 02:04:32 +00002363 SrcList *pSrc; /* The FROM clause */
drh9bb61fe2000-06-05 16:01:39 +00002364 Expr *pWhere; /* The WHERE clause */
2365 ExprList *pGroupBy; /* The GROUP BY clause */
2366 Expr *pHaving; /* The HAVING clause */
2367 ExprList *pOrderBy; /* The ORDER BY clause */
drh967e8b72000-06-21 13:59:10 +00002368 Select *pPrior; /* Prior select in a compound select statement */
drh1e281292007-12-13 03:45:07 +00002369 Select *pNext; /* Next select to the left in a compound */
danielk1977a2dc3b12005-02-05 12:48:48 +00002370 Expr *pLimit; /* LIMIT expression. NULL means not used. */
2371 Expr *pOffset; /* OFFSET expression. NULL means not used. */
dan4e9119d2014-01-13 15:12:23 +00002372 With *pWith; /* WITH clause attached to this select. Or NULL. */
drh9bb61fe2000-06-05 16:01:39 +00002373};
2374
2375/*
drh7d10d5a2008-08-20 16:35:10 +00002376** Allowed values for Select.selFlags. The "SF" prefix stands for
2377** "Select Flag".
2378*/
drh21172c42012-10-30 00:29:07 +00002379#define SF_Distinct 0x0001 /* Output should be DISTINCT */
2380#define SF_Resolved 0x0002 /* Identifiers have been resolved */
2381#define SF_Aggregate 0x0004 /* Contains aggregate functions */
2382#define SF_UsesEphemeral 0x0008 /* Uses the OpenEphemeral opcode */
2383#define SF_Expanded 0x0010 /* sqlite3SelectExpand() called on this */
2384#define SF_HasTypeInfo 0x0020 /* FROM subqueries have Table metadata */
drh9588ad92014-09-15 14:46:02 +00002385#define SF_Compound 0x0040 /* Part of a compound query */
drh21172c42012-10-30 00:29:07 +00002386#define SF_Values 0x0080 /* Synthesized from VALUES clause */
drh45f54a52015-01-05 19:16:42 +00002387#define SF_AllValues 0x0100 /* All terms of compound are VALUES */
drh832ee3d2012-12-18 19:36:11 +00002388#define SF_NestedFrom 0x0200 /* Part of a parenthesized FROM clause */
drhd58d3272013-08-05 22:05:02 +00002389#define SF_MaybeConvert 0x0400 /* Need convertCompoundSelectToSubquery() */
daneae73fb2014-01-16 18:34:33 +00002390#define SF_Recursive 0x0800 /* The recursive part of a recursive CTE */
drh9588ad92014-09-15 14:46:02 +00002391#define SF_MinMaxAgg 0x1000 /* Aggregate containing min() or max() */
drh7d10d5a2008-08-20 16:35:10 +00002392
2393
2394/*
drh340309f2014-01-22 00:23:49 +00002395** The results of a SELECT can be distributed in several ways, as defined
2396** by one of the following macros. The "SRT" prefix means "SELECT Result
2397** Type".
2398**
2399** SRT_Union Store results as a key in a temporary index
2400** identified by pDest->iSDParm.
2401**
2402** SRT_Except Remove results from the temporary index pDest->iSDParm.
2403**
2404** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
2405** set is not empty.
2406**
2407** SRT_Discard Throw the results away. This is used by SELECT
2408** statements within triggers whose only purpose is
2409** the side-effects of functions.
2410**
2411** All of the above are free to ignore their ORDER BY clause. Those that
2412** follow must honor the ORDER BY clause.
2413**
2414** SRT_Output Generate a row of output (using the OP_ResultRow
2415** opcode) for each row in the result set.
2416**
2417** SRT_Mem Only valid if the result is a single column.
2418** Store the first column of the first result row
2419** in register pDest->iSDParm then abandon the rest
2420** of the query. This destination implies "LIMIT 1".
2421**
2422** SRT_Set The result must be a single column. Store each
2423** row of result as the key in table pDest->iSDParm.
2424** Apply the affinity pDest->affSdst before storing
2425** results. Used to implement "IN (SELECT ...)".
2426**
drh340309f2014-01-22 00:23:49 +00002427** SRT_EphemTab Create an temporary table pDest->iSDParm and store
2428** the result there. The cursor is left open after
2429** returning. This is like SRT_Table except that
2430** this destination uses OP_OpenEphemeral to create
2431** the table first.
2432**
2433** SRT_Coroutine Generate a co-routine that returns a new row of
2434** results each time it is invoked. The entry point
2435** of the co-routine is stored in register pDest->iSDParm
2436** and the result row is stored in pDest->nDest registers
2437** starting with pDest->iSdst.
2438**
drh781def22014-01-22 13:35:53 +00002439** SRT_Table Store results in temporary table pDest->iSDParm.
drh8e1ee882014-03-21 19:56:09 +00002440** SRT_Fifo This is like SRT_EphemTab except that the table
2441** is assumed to already be open. SRT_Fifo has
2442** the additional property of being able to ignore
2443** the ORDER BY clause.
drh781def22014-01-22 13:35:53 +00002444**
drh8e1ee882014-03-21 19:56:09 +00002445** SRT_DistFifo Store results in a temporary table pDest->iSDParm.
drh340309f2014-01-22 00:23:49 +00002446** But also use temporary table pDest->iSDParm+1 as
2447** a record of all prior results and ignore any duplicate
drh8e1ee882014-03-21 19:56:09 +00002448** rows. Name means: "Distinct Fifo".
drh781def22014-01-22 13:35:53 +00002449**
2450** SRT_Queue Store results in priority queue pDest->iSDParm (really
2451** an index). Append a sequence number so that all entries
2452** are distinct.
2453**
2454** SRT_DistQueue Store results in priority queue pDest->iSDParm only if
2455** the same record has never been stored before. The
2456** index at pDest->iSDParm+1 hold all prior stores.
drhfef52082000-06-06 01:50:43 +00002457*/
drh13449892005-09-07 21:22:45 +00002458#define SRT_Union 1 /* Store result as keys in an index */
2459#define SRT_Except 2 /* Remove result from a UNION index */
danielk19779ed1dfa2008-01-02 17:11:14 +00002460#define SRT_Exists 3 /* Store 1 if the result is not empty */
2461#define SRT_Discard 4 /* Do not save the results anywhere */
drh8e1ee882014-03-21 19:56:09 +00002462#define SRT_Fifo 5 /* Store result as data with an automatic rowid */
2463#define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */
2464#define SRT_Queue 7 /* Store result in an queue */
2465#define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */
drhfef52082000-06-06 01:50:43 +00002466
drh13449892005-09-07 21:22:45 +00002467/* The ORDER BY clause is ignored for all of the above */
drh8e1ee882014-03-21 19:56:09 +00002468#define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue)
drh13449892005-09-07 21:22:45 +00002469
drh8e1ee882014-03-21 19:56:09 +00002470#define SRT_Output 9 /* Output each row of result */
2471#define SRT_Mem 10 /* Store result in a memory cell */
2472#define SRT_Set 11 /* Store results as keys in an index */
2473#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */
2474#define SRT_Coroutine 13 /* Generate a single row of result */
2475#define SRT_Table 14 /* Store result as data with an automatic rowid */
drh22827922000-06-06 17:27:05 +00002476
2477/*
drh634d81d2012-09-20 15:41:31 +00002478** An instance of this object describes where to put of the results of
2479** a SELECT statement.
danielk19776c8c8ce2008-01-02 16:27:09 +00002480*/
danielk19776c8c8ce2008-01-02 16:27:09 +00002481struct SelectDest {
drhfe1c6bb2014-01-22 17:28:35 +00002482 u8 eDest; /* How to dispose of the results. On of SRT_* above. */
2483 char affSdst; /* Affinity used when eDest==SRT_Set */
2484 int iSDParm; /* A parameter used by the eDest disposal method */
2485 int iSdst; /* Base register where results are written */
2486 int nSdst; /* Number of registers allocated */
2487 ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */
danielk19776c8c8ce2008-01-02 16:27:09 +00002488};
2489
2490/*
drh0b9f50d2009-06-23 20:28:53 +00002491** During code generation of statements that do inserts into AUTOINCREMENT
2492** tables, the following information is attached to the Table.u.autoInc.p
2493** pointer of each autoincrement table to record some side information that
2494** the code generator needs. We have to keep per-table autoincrement
2495** information in case inserts are down within triggers. Triggers do not
2496** normally coordinate their activities, but we do need to coordinate the
2497** loading and saving of autoincrement information.
2498*/
2499struct AutoincInfo {
2500 AutoincInfo *pNext; /* Next info block in a list of them all */
2501 Table *pTab; /* Table this info block refers to */
2502 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
2503 int regCtr; /* Memory register holding the rowid counter */
2504};
2505
2506/*
drhceea3322009-04-23 13:22:42 +00002507** Size of the column cache
2508*/
2509#ifndef SQLITE_N_COLCACHE
2510# define SQLITE_N_COLCACHE 10
2511#endif
2512
dan2832ad42009-08-31 15:27:27 +00002513/*
2514** At least one instance of the following structure is created for each
2515** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
2516** statement. All such objects are stored in the linked list headed at
2517** Parse.pTriggerPrg and deleted once statement compilation has been
2518** completed.
2519**
2520** A Vdbe sub-program that implements the body and WHEN clause of trigger
2521** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
2522** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
2523** The Parse.pTriggerPrg list never contains two entries with the same
2524** values for both pTrigger and orconf.
dan65a7cd12009-09-01 12:16:01 +00002525**
danbb5f1682009-11-27 12:12:34 +00002526** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
dan65a7cd12009-09-01 12:16:01 +00002527** accessed (or set to 0 for triggers fired as a result of INSERT
danbb5f1682009-11-27 12:12:34 +00002528** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
2529** a mask of new.* columns used by the program.
dan2832ad42009-08-31 15:27:27 +00002530*/
2531struct TriggerPrg {
2532 Trigger *pTrigger; /* Trigger this program was coded from */
dan2832ad42009-08-31 15:27:27 +00002533 TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
drha4510172012-02-02 15:50:17 +00002534 SubProgram *pProgram; /* Program implementing pTrigger/orconf */
2535 int orconf; /* Default ON CONFLICT policy */
2536 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
dan165921a2009-08-28 18:53:45 +00002537};
2538
drh64123582011-04-02 20:01:02 +00002539/*
2540** The yDbMask datatype for the bitmask of all attached databases.
2541*/
drh01c7dc82011-03-23 18:22:34 +00002542#if SQLITE_MAX_ATTACHED>30
drha7ab6d82014-07-21 15:44:39 +00002543 typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8];
2544# define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0)
2545# define DbMaskZero(M) memset((M),0,sizeof(M))
2546# define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7))
2547# define DbMaskAllZero(M) sqlite3DbMaskAllZero(M)
2548# define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0)
drh01c7dc82011-03-23 18:22:34 +00002549#else
drh64123582011-04-02 20:01:02 +00002550 typedef unsigned int yDbMask;
drha7ab6d82014-07-21 15:44:39 +00002551# define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0)
2552# define DbMaskZero(M) (M)=0
2553# define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I))
2554# define DbMaskAllZero(M) (M)==0
2555# define DbMaskNonZero(M) (M)!=0
drh01c7dc82011-03-23 18:22:34 +00002556#endif
2557
drhceea3322009-04-23 13:22:42 +00002558/*
drhf57b3392001-10-08 13:22:32 +00002559** An SQL parser context. A copy of this structure is passed through
2560** the parser and down into all the parser action routine in order to
2561** carry around information that is global to the entire parse.
drhf1974842004-11-05 03:56:00 +00002562**
2563** The structure is divided into two parts. When the parser and code
2564** generate call themselves recursively, the first part of the structure
2565** is constant but the second part is reset at the beginning and end of
2566** each recursion.
danielk1977c00da102006-01-07 13:21:04 +00002567**
2568** The nTableLock and aTableLock variables are only used if the shared-cache
2569** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
2570** used to store the set of table-locks required by the statement being
2571** compiled. Function sqlite3TableLock() is used to add entries to the
2572** list.
drh75897232000-05-29 14:26:00 +00002573*/
2574struct Parse {
drh9bb575f2004-09-06 17:24:11 +00002575 sqlite3 *db; /* The main database structure */
drh75897232000-05-29 14:26:00 +00002576 char *zErrMsg; /* An error message */
drh75897232000-05-29 14:26:00 +00002577 Vdbe *pVdbe; /* An engine for executing database bytecode */
drha4510172012-02-02 15:50:17 +00002578 int rc; /* Return code from execution */
drh836faa42003-01-11 13:30:57 +00002579 u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */
drha6ecd332004-06-10 00:29:09 +00002580 u8 checkSchema; /* Causes schema cookie check after an error */
drh205f48e2004-11-05 00:43:11 +00002581 u8 nested; /* Number of nested calls to the parser/code generator */
drh892d3172008-01-10 03:46:36 +00002582 u8 nTempReg; /* Number of temporary registers in aTempReg[] */
drha4510172012-02-02 15:50:17 +00002583 u8 isMultiWrite; /* True if statement may modify/insert multiple rows */
2584 u8 mayAbort; /* True if statement may throw an ABORT exception */
drhd58d3272013-08-05 22:05:02 +00002585 u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */
drhaceb31b2014-02-08 01:40:27 +00002586 u8 okConstFactor; /* OK to factor out constants */
drh892d3172008-01-10 03:46:36 +00002587 int aTempReg[8]; /* Holding area for temporary registers */
2588 int nRangeReg; /* Size of the temporary register block */
2589 int iRangeReg; /* First register in temporary register block */
drh75897232000-05-29 14:26:00 +00002590 int nErr; /* Number of errors seen */
drh832508b2002-03-02 17:04:07 +00002591 int nTab; /* Number of previously allocated VDBE cursors */
drh19a775c2000-06-05 18:54:46 +00002592 int nMem; /* Number of memory cells used so far */
drhfef52082000-06-06 01:50:43 +00002593 int nSet; /* Number of sets used so far */
dan1d8cb212011-12-09 13:24:16 +00002594 int nOnce; /* Number of OP_Once instructions so far */
drh73d5b8f2013-12-23 19:09:07 +00002595 int nOpAlloc; /* Number of slots allocated for Vdbe.aOp[] */
drh61019c72014-01-04 16:49:02 +00002596 int iFixedOp; /* Never back out opcodes iFixedOp-1 or earlier */
drhaa9b8962008-01-08 02:57:55 +00002597 int ckBase; /* Base register of data during check constraints */
drhb2b9d3d2013-08-01 01:14:43 +00002598 int iPartIdxTab; /* Table corresponding to a partial index */
drhceea3322009-04-23 13:22:42 +00002599 int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
2600 int iCacheCnt; /* Counter used to generate aColCache[].lru values */
drh7df89c82014-02-04 15:55:25 +00002601 int nLabel; /* Number of labels used */
2602 int *aLabel; /* Space to hold the labels */
drh2f7794c2008-04-01 03:27:39 +00002603 struct yColCache {
drhe55cbd72008-03-31 23:48:03 +00002604 int iTable; /* Table cursor number */
drh7df89c82014-02-04 15:55:25 +00002605 i16 iColumn; /* Table column number */
drhceea3322009-04-23 13:22:42 +00002606 u8 tempReg; /* iReg is a temp register that needs to be freed */
2607 int iLevel; /* Nesting level */
2608 int iReg; /* Reg with value of this column. 0 means none. */
2609 int lru; /* Least recently used entry has the smallest value */
2610 } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
drhf30a9692013-11-15 01:10:18 +00002611 ExprList *pConstExpr;/* Constant expressions */
drh7df89c82014-02-04 15:55:25 +00002612 Token constraintName;/* Name of the constraint currently being parsed */
drh64123582011-04-02 20:01:02 +00002613 yDbMask writeMask; /* Start a write transaction on these databases */
2614 yDbMask cookieMask; /* Bitmask of schema verified databases */
drhc797d4d2007-05-08 01:08:49 +00002615 int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */
drha4510172012-02-02 15:50:17 +00002616 int regRowid; /* Register holding rowid of CREATE TABLE entry */
2617 int regRoot; /* Register holding root page number for new objects */
2618 int nMaxArg; /* Max args passed to user function by sub-program */
drhabd4c722014-09-20 18:18:33 +00002619#if SELECTTRACE_ENABLED
2620 int nSelect; /* Number of SELECT statements seen */
drheb9b8842014-09-21 00:27:26 +00002621 int nSelectIndent; /* How far to indent SELECTTRACE() output */
drhabd4c722014-09-20 18:18:33 +00002622#endif
danielk1977c00da102006-01-07 13:21:04 +00002623#ifndef SQLITE_OMIT_SHARED_CACHE
2624 int nTableLock; /* Number of locks in aTableLock */
2625 TableLock *aTableLock; /* Required table locks for shared-cache mode */
2626#endif
drh0b9f50d2009-06-23 20:28:53 +00002627 AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */
drhf1974842004-11-05 03:56:00 +00002628
dan165921a2009-08-28 18:53:45 +00002629 /* Information used while coding trigger programs. */
dan65a7cd12009-09-01 12:16:01 +00002630 Parse *pToplevel; /* Parse structure for main program (or NULL) */
dan165921a2009-08-28 18:53:45 +00002631 Table *pTriggerTab; /* Table triggers are being coded for */
drhc6bd4e42013-11-02 14:37:18 +00002632 int addrCrTab; /* Address of OP_CreateTable opcode on CREATE TABLE */
2633 int addrSkipPK; /* Address of instruction to skip PRIMARY KEY index */
drh4f402f22013-06-11 18:59:38 +00002634 u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */
dan65a7cd12009-09-01 12:16:01 +00002635 u32 oldmask; /* Mask of old.* columns referenced */
danbb5f1682009-11-27 12:12:34 +00002636 u32 newmask; /* Mask of new.* columns referenced */
dan65a7cd12009-09-01 12:16:01 +00002637 u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */
2638 u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */
dand66c8302009-09-28 14:49:01 +00002639 u8 disableTriggers; /* True to disable triggers */
dan165921a2009-08-28 18:53:45 +00002640
drh7df89c82014-02-04 15:55:25 +00002641 /************************************************************************
2642 ** Above is constant between recursions. Below is reset before and after
2643 ** each recursion. The boundary between these two regions is determined
2644 ** using offsetof(Parse,nVar) so the nVar field must be the first field
2645 ** in the recursive region.
2646 ************************************************************************/
drhf1974842004-11-05 03:56:00 +00002647
drha4510172012-02-02 15:50:17 +00002648 int nVar; /* Number of '?' variables seen in the SQL so far */
2649 int nzVar; /* Number of available slots in azVar[] */
drh7f9c5db2013-10-23 00:32:58 +00002650 u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */
drh7df89c82014-02-04 15:55:25 +00002651 u8 bFreeWith; /* True if pWith should be freed with parser */
drha4510172012-02-02 15:50:17 +00002652 u8 explain; /* True if the EXPLAIN flag is found on the query */
2653#ifndef SQLITE_OMIT_VIRTUALTABLE
2654 u8 declareVtab; /* True if inside sqlite3_declare_vtab() */
2655 int nVtabLock; /* Number of virtual tables to lock */
2656#endif
2657 int nAlias; /* Number of aliased result set columns */
2658 int nHeight; /* Expression tree height of current sub-select */
2659#ifndef SQLITE_OMIT_EXPLAIN
2660 int iSelectId; /* ID of current select for EXPLAIN output */
2661 int iNextSelectId; /* Next available select ID for EXPLAIN output */
2662#endif
2663 char **azVar; /* Pointers to names of parameters */
2664 Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */
drha4510172012-02-02 15:50:17 +00002665 const char *zTail; /* All SQL text past the last semicolon parsed */
2666 Table *pNewTable; /* A table being constructed by CREATE TABLE */
drhf1974842004-11-05 03:56:00 +00002667 Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */
drhf1974842004-11-05 03:56:00 +00002668 const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
drha4510172012-02-02 15:50:17 +00002669 Token sNameToken; /* Token with unqualified schema object name */
2670 Token sLastToken; /* The last token parsed */
drhb9bb7c12006-06-11 23:41:55 +00002671#ifndef SQLITE_OMIT_VIRTUALTABLE
drha4510172012-02-02 15:50:17 +00002672 Token sArg; /* Complete text of a module argument */
2673 Table **apVtabLock; /* Pointer to virtual tables needing locking */
drhb9bb7c12006-06-11 23:41:55 +00002674#endif
drha4510172012-02-02 15:50:17 +00002675 Table *pZombieTab; /* List of Table objects to delete after code gen */
2676 TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */
dan4e9119d2014-01-13 15:12:23 +00002677 With *pWith; /* Current WITH clause, or NULL */
drh75897232000-05-29 14:26:00 +00002678};
2679
drha4510172012-02-02 15:50:17 +00002680/*
2681** Return true if currently inside an sqlite3_declare_vtab() call.
2682*/
danielk19777e6ebfb2006-06-12 11:24:37 +00002683#ifdef SQLITE_OMIT_VIRTUALTABLE
2684 #define IN_DECLARE_VTAB 0
2685#else
2686 #define IN_DECLARE_VTAB (pParse->declareVtab)
2687#endif
2688
danielk1977d99bc932002-05-16 00:13:12 +00002689/*
drh85e20962003-04-25 17:52:11 +00002690** An instance of the following structure can be declared on a stack and used
2691** to save the Parse.zAuthContext value so that it can be restored later.
2692*/
2693struct AuthContext {
2694 const char *zAuthContext; /* Put saved Parse.zAuthContext here */
2695 Parse *pParse; /* The Parse structure */
2696};
2697
2698/*
drha748fdc2012-03-28 01:34:47 +00002699** Bitfield flags for P5 value in various opcodes.
rdcb0c374f2004-02-20 22:53:38 +00002700*/
drh3e9ca092009-09-08 01:14:48 +00002701#define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */
drh97348b32014-09-25 02:44:29 +00002702#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */
drh3e9ca092009-09-08 01:14:48 +00002703#define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */
2704#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
2705#define OPFLAG_APPEND 0x08 /* This is likely to be an append */
2706#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
drha748fdc2012-03-28 01:34:47 +00002707#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
2708#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
dan428c2182012-08-06 18:50:11 +00002709#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
drhe0997b32015-03-20 14:57:50 +00002710#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */
2711#define OPFLAG_P2ISREG 0x04 /* P2 to OP_Open** is a register number */
drh953f7612012-12-07 22:18:54 +00002712#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */
rdcb0c374f2004-02-20 22:53:38 +00002713
2714/*
danielk1977d99bc932002-05-16 00:13:12 +00002715 * Each trigger present in the database schema is stored as an instance of
2716 * struct Trigger.
2717 *
2718 * Pointers to instances of struct Trigger are stored in two ways.
drh9bb575f2004-09-06 17:24:11 +00002719 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
danielk1977d99bc932002-05-16 00:13:12 +00002720 * database). This allows Trigger structures to be retrieved by name.
2721 * 2. All triggers associated with a single table form a linked list, using the
drhad3cab52002-05-24 02:04:32 +00002722 * pNext member of struct Trigger. A pointer to the first element of the
2723 * linked list is stored as the "pTrigger" member of the associated
2724 * struct Table.
danielk1977d99bc932002-05-16 00:13:12 +00002725 *
drhad3cab52002-05-24 02:04:32 +00002726 * The "step_list" member points to the first element of a linked list
2727 * containing the SQL statements specified as the trigger program.
danielk1977d99bc932002-05-16 00:13:12 +00002728 */
danielk1977c3f9bad2002-05-15 08:30:12 +00002729struct Trigger {
dan165921a2009-08-28 18:53:45 +00002730 char *zName; /* The name of the trigger */
drhdc379452002-05-15 12:45:43 +00002731 char *table; /* The table or view to which the trigger applies */
drhf0f258b2003-04-21 18:48:45 +00002732 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
drhdca76842004-12-07 14:06:13 +00002733 u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
shane467bcf32008-11-24 20:01:32 +00002734 Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */
drhdc379452002-05-15 12:45:43 +00002735 IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
danielk1977d99bc932002-05-16 00:13:12 +00002736 the <column-list> is stored here */
danielk1977e501b892006-01-09 06:29:47 +00002737 Schema *pSchema; /* Schema containing the trigger */
2738 Schema *pTabSchema; /* Schema containing the table */
drhdc379452002-05-15 12:45:43 +00002739 TriggerStep *step_list; /* Link list of trigger program steps */
drhdc379452002-05-15 12:45:43 +00002740 Trigger *pNext; /* Next trigger associated with the table */
danielk1977c3f9bad2002-05-15 08:30:12 +00002741};
2742
danielk1977d99bc932002-05-16 00:13:12 +00002743/*
drhdca76842004-12-07 14:06:13 +00002744** A trigger is either a BEFORE or an AFTER trigger. The following constants
2745** determine which.
2746**
2747** If there are multiple triggers, you might of some BEFORE and some AFTER.
2748** In that cases, the constants below can be ORed together.
2749*/
2750#define TRIGGER_BEFORE 1
2751#define TRIGGER_AFTER 2
2752
2753/*
danielk1977d99bc932002-05-16 00:13:12 +00002754 * An instance of struct TriggerStep is used to store a single SQL statement
2755 * that is a part of a trigger-program.
2756 *
2757 * Instances of struct TriggerStep are stored in a singly linked list (linked
2758 * using the "pNext" member) referenced by the "step_list" member of the
2759 * associated struct Trigger instance. The first element of the linked list is
2760 * the first step of the trigger-program.
2761 *
2762 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
2763 * "SELECT" statement. The meanings of the other members is determined by the
2764 * value of "op" as follows:
2765 *
2766 * (op == TK_INSERT)
2767 * orconf -> stores the ON CONFLICT algorithm
2768 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
2769 * this stores a pointer to the SELECT statement. Otherwise NULL.
drhb7916a72009-05-27 10:31:29 +00002770 * target -> A token holding the quoted name of the table to insert into.
danielk1977d99bc932002-05-16 00:13:12 +00002771 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
2772 * this stores values to be inserted. Otherwise NULL.
2773 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
drhad3cab52002-05-24 02:04:32 +00002774 * statement, then this stores the column-names to be
2775 * inserted into.
danielk1977d99bc932002-05-16 00:13:12 +00002776 *
2777 * (op == TK_DELETE)
drhb7916a72009-05-27 10:31:29 +00002778 * target -> A token holding the quoted name of the table to delete from.
danielk1977d99bc932002-05-16 00:13:12 +00002779 * pWhere -> The WHERE clause of the DELETE statement if one is specified.
2780 * Otherwise NULL.
2781 *
2782 * (op == TK_UPDATE)
drhb7916a72009-05-27 10:31:29 +00002783 * target -> A token holding the quoted name of the table to update rows of.
danielk1977d99bc932002-05-16 00:13:12 +00002784 * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
2785 * Otherwise NULL.
2786 * pExprList -> A list of the columns to update and the expressions to update
danielk19774adee202004-05-08 08:23:19 +00002787 * them to. See sqlite3Update() documentation of "pChanges"
drhad3cab52002-05-24 02:04:32 +00002788 * argument.
danielk1977d99bc932002-05-16 00:13:12 +00002789 *
2790 */
2791struct TriggerStep {
drhb1819a02009-07-03 15:37:27 +00002792 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
2793 u8 orconf; /* OE_Rollback etc. */
drha69d9162003-04-17 22:57:53 +00002794 Trigger *pTrig; /* The trigger that this step is a part of */
drhb1819a02009-07-03 15:37:27 +00002795 Select *pSelect; /* SELECT statment or RHS of INSERT INTO .. SELECT ... */
2796 Token target; /* Target table for DELETE, UPDATE, INSERT */
2797 Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */
drh75593d92014-01-10 20:46:55 +00002798 ExprList *pExprList; /* SET clause for UPDATE. */
drhb1819a02009-07-03 15:37:27 +00002799 IdList *pIdList; /* Column names for INSERT */
drh187e4c62006-02-27 22:22:27 +00002800 TriggerStep *pNext; /* Next in the link-list */
2801 TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */
danielk1977d99bc932002-05-16 00:13:12 +00002802};
2803
2804/*
drhf26e09c2003-05-31 16:21:12 +00002805** The following structure contains information used by the sqliteFix...
2806** routines as they walk the parse tree to make database references
2807** explicit.
2808*/
2809typedef struct DbFixer DbFixer;
2810struct DbFixer {
2811 Parse *pParse; /* The parsing context. Error messages written here */
dan41fb5cd2012-10-04 19:33:00 +00002812 Schema *pSchema; /* Fix items to this schema */
dan46539d72013-10-03 12:29:38 +00002813 int bVarOnly; /* Check for variable references only */
drhf26e09c2003-05-31 16:21:12 +00002814 const char *zDb; /* Make sure all objects are contained in this database */
2815 const char *zType; /* Type of the container - used for error messages */
2816 const Token *pName; /* Name of the container - used for error messages */
2817};
2818
2819/*
drhade86482007-11-28 22:36:40 +00002820** An objected used to accumulate the text of a string where we
2821** do not necessarily know how big the string will be in the end.
2822*/
2823struct StrAccum {
drh633e6d52008-07-28 19:34:53 +00002824 sqlite3 *db; /* Optional database for lookaside. Can be NULL */
2825 char *zBase; /* A base allocation. Not from malloc. */
2826 char *zText; /* The string collected so far */
2827 int nChar; /* Length of the string so far */
2828 int nAlloc; /* Amount of space allocated in zText */
drhbb4957f2008-03-20 14:03:29 +00002829 int mxAlloc; /* Maximum allowed string length */
drhb9755982010-07-24 16:34:37 +00002830 u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */
drhb49bc862013-08-21 21:12:10 +00002831 u8 accError; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
drhade86482007-11-28 22:36:40 +00002832};
drhb49bc862013-08-21 21:12:10 +00002833#define STRACCUM_NOMEM 1
2834#define STRACCUM_TOOBIG 2
drhade86482007-11-28 22:36:40 +00002835
2836/*
drh234c39d2004-07-24 03:30:47 +00002837** A pointer to this structure is used to communicate information
2838** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
2839*/
2840typedef struct {
drh9bb575f2004-09-06 17:24:11 +00002841 sqlite3 *db; /* The database being initialized */
drh234c39d2004-07-24 03:30:47 +00002842 char **pzErrMsg; /* Error message stored here */
drha4510172012-02-02 15:50:17 +00002843 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
drh15ca1df2006-07-26 13:43:30 +00002844 int rc; /* Result code stored here */
drh234c39d2004-07-24 03:30:47 +00002845} InitData;
2846
drhb6c29892004-11-22 19:12:19 +00002847/*
drh40257ff2008-06-13 18:24:27 +00002848** Structure containing global configuration data for the SQLite library.
drh33589792008-06-18 13:27:46 +00002849**
2850** This structure also contains some state information.
drh40257ff2008-06-13 18:24:27 +00002851*/
2852struct Sqlite3Config {
drhfec00ea2008-06-14 16:56:21 +00002853 int bMemstat; /* True to enable memory status */
2854 int bCoreMutex; /* True to enable core mutexing */
2855 int bFullMutex; /* True to enable full mutexing */
dancd74b612011-04-22 19:37:32 +00002856 int bOpenUri; /* True to interpret filenames as URIs */
drhde9a7b82012-09-17 20:44:46 +00002857 int bUseCis; /* Use covering indices for full-scans */
drh0a687d12008-07-08 14:52:07 +00002858 int mxStrlen; /* Maximum string length */
drh09fe6142013-11-29 15:06:27 +00002859 int neverCorrupt; /* Database is always well-formed */
drh633e6d52008-07-28 19:34:53 +00002860 int szLookaside; /* Default lookaside buffer size */
2861 int nLookaside; /* Default lookaside buffer count */
drhfec00ea2008-06-14 16:56:21 +00002862 sqlite3_mem_methods m; /* Low-level memory allocation interface */
danielk19776d2ab0e2008-06-17 17:21:18 +00002863 sqlite3_mutex_methods mutex; /* Low-level mutex interface */
dan22e21ff2011-11-08 20:08:44 +00002864 sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */
drh40257ff2008-06-13 18:24:27 +00002865 void *pHeap; /* Heap storage space */
drh33589792008-06-18 13:27:46 +00002866 int nHeap; /* Size of pHeap[] */
2867 int mnReq, mxReq; /* Min and max heap requests sizes */
drh9b4c59f2013-04-15 17:03:42 +00002868 sqlite3_int64 szMmap; /* mmap() space per open file */
2869 sqlite3_int64 mxMmap; /* Maximum value for szMmap */
drh33589792008-06-18 13:27:46 +00002870 void *pScratch; /* Scratch memory */
2871 int szScratch; /* Size of each scratch buffer */
2872 int nScratch; /* Number of scratch buffers */
2873 void *pPage; /* Page cache memory */
2874 int szPage; /* Size of each page in pPage[] */
2875 int nPage; /* Number of pages in pPage[] */
drh1875f7a2008-12-08 18:19:17 +00002876 int mxParserStack; /* maximum depth of the parser stack */
2877 int sharedCacheEnabled; /* true if shared-cache mode enabled */
drh3bd17912015-01-02 15:55:29 +00002878 u32 szPma; /* Maximum Sorter PMA size */
drh1875f7a2008-12-08 18:19:17 +00002879 /* The above might be initialized to non-zero. The following need to always
2880 ** initially be zero, however. */
danielk197771bc31c2008-06-26 08:29:34 +00002881 int isInit; /* True after initialization has finished */
danielk1977502b4e02008-09-02 14:07:24 +00002882 int inProgress; /* True while initialization in progress */
dane1ab2192009-08-17 15:16:19 +00002883 int isMutexInit; /* True after mutexes are initialized */
danielk197771bc31c2008-06-26 08:29:34 +00002884 int isMallocInit; /* True after malloc is initialized */
dane1ab2192009-08-17 15:16:19 +00002885 int isPCacheInit; /* True after malloc is initialized */
drh93ed56d2008-08-12 15:21:11 +00002886 int nRefInitMutex; /* Number of users of pInitMutex */
drhc007f612014-05-16 14:17:01 +00002887 sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */
drh3f280702010-02-18 18:45:09 +00002888 void (*xLog)(void*,int,const char*); /* Function for logging */
2889 void *pLogArg; /* First argument to xLog() */
danac455932012-11-26 19:50:41 +00002890#ifdef SQLITE_ENABLE_SQLLOG
2891 void(*xSqllog)(void*,sqlite3*,const char*, int);
2892 void *pSqllogArg;
2893#endif
drh688852a2014-02-17 22:40:43 +00002894#ifdef SQLITE_VDBE_COVERAGE
2895 /* The following callback (if not NULL) is invoked on every VDBE branch
2896 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
2897 */
2898 void (*xVdbeBranch)(void*,int iSrcLine,u8 eThis,u8 eMx); /* Callback */
2899 void *pVdbeBranchArg; /* 1st argument */
2900#endif
drhc007f612014-05-16 14:17:01 +00002901#ifndef SQLITE_OMIT_BUILTIN_TEST
2902 int (*xTestCallback)(int); /* Invoked by sqlite3FaultSim() */
2903#endif
2904 int bLocaltimeFault; /* True to fail localtime() calls */
drh40257ff2008-06-13 18:24:27 +00002905};
2906
2907/*
drh09fe6142013-11-29 15:06:27 +00002908** This macro is used inside of assert() statements to indicate that
2909** the assert is only valid on a well-formed database. Instead of:
2910**
2911** assert( X );
2912**
2913** One writes:
2914**
drhb2023662013-11-29 15:39:36 +00002915** assert( X || CORRUPT_DB );
drh09fe6142013-11-29 15:06:27 +00002916**
drhb2023662013-11-29 15:39:36 +00002917** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate
2918** that the database is definitely corrupt, only that it might be corrupt.
2919** For most test cases, CORRUPT_DB is set to false using a special
2920** sqlite3_test_control(). This enables assert() statements to prove
2921** things that are always true for well-formed databases.
drh09fe6142013-11-29 15:06:27 +00002922*/
drhb2023662013-11-29 15:39:36 +00002923#define CORRUPT_DB (sqlite3Config.neverCorrupt==0)
drh09fe6142013-11-29 15:06:27 +00002924
2925/*
drh7d10d5a2008-08-20 16:35:10 +00002926** Context pointer passed down through the tree-walk.
2927*/
2928struct Walker {
2929 int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */
2930 int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */
danb290f112014-01-17 14:59:27 +00002931 void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */
drh7d10d5a2008-08-20 16:35:10 +00002932 Parse *pParse; /* Parser context. */
drh030796d2012-08-23 16:18:10 +00002933 int walkerDepth; /* Number of subqueries */
drh059b2d52014-10-24 19:28:09 +00002934 u8 eCode; /* A small processing code */
drh7d10d5a2008-08-20 16:35:10 +00002935 union { /* Extra data for callback */
2936 NameContext *pNC; /* Naming context */
drh059b2d52014-10-24 19:28:09 +00002937 int n; /* A counter */
2938 int iCur; /* A cursor number */
drh374fdce2012-04-17 16:38:53 +00002939 SrcList *pSrcList; /* FROM clause */
drh030796d2012-08-23 16:18:10 +00002940 struct SrcCount *pSrcCount; /* Counting column references */
drh7d10d5a2008-08-20 16:35:10 +00002941 } u;
2942};
2943
2944/* Forward declarations */
2945int sqlite3WalkExpr(Walker*, Expr*);
2946int sqlite3WalkExprList(Walker*, ExprList*);
2947int sqlite3WalkSelect(Walker*, Select*);
2948int sqlite3WalkSelectExpr(Walker*, Select*);
2949int sqlite3WalkSelectFrom(Walker*, Select*);
2950
2951/*
2952** Return code from the parse-tree walking primitives and their
2953** callbacks.
2954*/
drh2bf90f12008-12-09 13:04:29 +00002955#define WRC_Continue 0 /* Continue down into children */
2956#define WRC_Prune 1 /* Omit children but continue walking siblings */
2957#define WRC_Abort 2 /* Abandon the tree walk */
drh7d10d5a2008-08-20 16:35:10 +00002958
2959/*
daneae73fb2014-01-16 18:34:33 +00002960** An instance of this structure represents a set of one or more CTEs
drhc49832c2014-01-15 18:35:52 +00002961** (common table expressions) created by a single WITH clause.
dan7d562db2014-01-11 19:19:36 +00002962*/
2963struct With {
drhc49832c2014-01-15 18:35:52 +00002964 int nCte; /* Number of CTEs in the WITH clause */
dan4e9119d2014-01-13 15:12:23 +00002965 With *pOuter; /* Containing WITH clause, or NULL */
drhc49832c2014-01-15 18:35:52 +00002966 struct Cte { /* For each CTE in the WITH clause.... */
2967 char *zName; /* Name of this CTE */
2968 ExprList *pCols; /* List of explicit column names, or NULL */
2969 Select *pSelect; /* The definition of this CTE */
danf2655fe2014-01-16 21:02:02 +00002970 const char *zErr; /* Error message for circular references */
dan7d562db2014-01-11 19:19:36 +00002971 } a[1];
2972};
2973
drh4fa4a542014-09-30 12:33:33 +00002974#ifdef SQLITE_DEBUG
2975/*
2976** An instance of the TreeView object is used for printing the content of
2977** data structures on sqlite3DebugPrintf() using a tree-like view.
2978*/
2979struct TreeView {
2980 int iLevel; /* Which level of the tree we are on */
drhb08cd3f2014-09-30 19:04:41 +00002981 u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */
drh4fa4a542014-09-30 12:33:33 +00002982};
2983#endif /* SQLITE_DEBUG */
2984
dan7d562db2014-01-11 19:19:36 +00002985/*
drh66150952007-07-23 19:12:41 +00002986** Assuming zIn points to the first byte of a UTF-8 character,
2987** advance zIn to point to the first byte of the next UTF-8 character.
drh4a919112007-05-15 11:55:09 +00002988*/
drh4a919112007-05-15 11:55:09 +00002989#define SQLITE_SKIP_UTF8(zIn) { \
2990 if( (*(zIn++))>=0xc0 ){ \
2991 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
2992 } \
2993}
2994
drh4a919112007-05-15 11:55:09 +00002995/*
drh9978c972010-02-23 17:36:32 +00002996** The SQLITE_*_BKPT macros are substitutes for the error codes with
2997** the same name but without the _BKPT suffix. These macros invoke
2998** routines that report the line-number on which the error originated
2999** using sqlite3_log(). The routines also provide a convenient place
3000** to set a debugger breakpoint.
drh49285702005-09-17 15:20:26 +00003001*/
drh9978c972010-02-23 17:36:32 +00003002int sqlite3CorruptError(int);
3003int sqlite3MisuseError(int);
3004int sqlite3CantopenError(int);
3005#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
3006#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
3007#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
3008
drh49285702005-09-17 15:20:26 +00003009
3010/*
drhb4a1fed2010-02-03 19:55:13 +00003011** FTS4 is really an extension for FTS3. It is enabled using the
peter.d.reid60ec9142014-09-06 16:39:46 +00003012** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call
3013** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3.
drhb4a1fed2010-02-03 19:55:13 +00003014*/
3015#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
drh0ede9eb2015-01-10 16:49:23 +00003016# define SQLITE_ENABLE_FTS3 1
drhb4a1fed2010-02-03 19:55:13 +00003017#endif
3018
3019/*
drh79f02ce2009-05-07 14:11:52 +00003020** The ctype.h header is needed for non-ASCII systems. It is also
3021** needed by FTS3 when FTS3 is included in the amalgamation.
3022*/
3023#if !defined(SQLITE_ASCII) || \
3024 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
3025# include <ctype.h>
3026#endif
3027
3028/*
danielk197778ca0e72009-01-20 16:53:39 +00003029** The following macros mimic the standard library functions toupper(),
3030** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
3031** sqlite versions only work for ASCII characters, regardless of locale.
3032*/
3033#ifdef SQLITE_ASCII
3034# define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
3035# define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
drhdc86e2b2009-01-24 11:30:42 +00003036# define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
3037# define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
danielk197778ca0e72009-01-20 16:53:39 +00003038# define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
3039# define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
3040# define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
3041#else
danielk197778ca0e72009-01-20 16:53:39 +00003042# define sqlite3Toupper(x) toupper((unsigned char)(x))
3043# define sqlite3Isspace(x) isspace((unsigned char)(x))
3044# define sqlite3Isalnum(x) isalnum((unsigned char)(x))
drhdc86e2b2009-01-24 11:30:42 +00003045# define sqlite3Isalpha(x) isalpha((unsigned char)(x))
danielk197778ca0e72009-01-20 16:53:39 +00003046# define sqlite3Isdigit(x) isdigit((unsigned char)(x))
3047# define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
3048# define sqlite3Tolower(x) tolower((unsigned char)(x))
3049#endif
drh97348b32014-09-25 02:44:29 +00003050int sqlite3IsIdChar(u8);
danielk197778ca0e72009-01-20 16:53:39 +00003051
3052/*
drh75897232000-05-29 14:26:00 +00003053** Internal function prototypes
3054*/
drh3fa97302012-02-22 16:58:36 +00003055#define sqlite3StrICmp sqlite3_stricmp
drhea678832008-12-10 19:26:22 +00003056int sqlite3Strlen30(const char*);
danielk1977ee0484c2009-07-28 16:44:26 +00003057#define sqlite3StrNICmp sqlite3_strnicmp
danielk19772e588c72005-12-09 14:25:08 +00003058
drh40257ff2008-06-13 18:24:27 +00003059int sqlite3MallocInit(void);
drhfec00ea2008-06-14 16:56:21 +00003060void sqlite3MallocEnd(void);
drhda4ca9d2014-09-09 17:27:35 +00003061void *sqlite3Malloc(u64);
3062void *sqlite3MallocZero(u64);
3063void *sqlite3DbMallocZero(sqlite3*, u64);
3064void *sqlite3DbMallocRaw(sqlite3*, u64);
drh17435752007-08-16 04:30:38 +00003065char *sqlite3DbStrDup(sqlite3*,const char*);
drhda4ca9d2014-09-09 17:27:35 +00003066char *sqlite3DbStrNDup(sqlite3*,const char*, u64);
3067void *sqlite3Realloc(void*, u64);
3068void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64);
3069void *sqlite3DbRealloc(sqlite3 *, void *, u64);
drh633e6d52008-07-28 19:34:53 +00003070void sqlite3DbFree(sqlite3*, void*);
3071int sqlite3MallocSize(void*);
3072int sqlite3DbMallocSize(sqlite3*, void*);
drhfacf0302008-06-17 15:12:00 +00003073void *sqlite3ScratchMalloc(int);
3074void sqlite3ScratchFree(void*);
3075void *sqlite3PageMalloc(int);
3076void sqlite3PageFree(void*);
drhfec00ea2008-06-14 16:56:21 +00003077void sqlite3MemSetDefault(void);
danielk1977171bfed2008-06-23 09:50:50 +00003078void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
drh50d1b5f2010-08-27 12:21:06 +00003079int sqlite3HeapNearlyFull(void);
danielk19772e588c72005-12-09 14:25:08 +00003080
drhe7b347072009-06-01 18:18:20 +00003081/*
3082** On systems with ample stack space and that support alloca(), make
3083** use of alloca() to obtain space for large automatic objects. By default,
3084** obtain space from malloc().
3085**
3086** The alloca() routine never returns NULL. This will cause code paths
3087** that deal with sqlite3StackAlloc() failures to be unreachable.
3088*/
3089#ifdef SQLITE_USE_ALLOCA
3090# define sqlite3StackAllocRaw(D,N) alloca(N)
3091# define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
3092# define sqlite3StackFree(D,P)
3093#else
3094# define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
3095# define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
3096# define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
3097#endif
3098
danielk1977f3d3c272008-11-19 16:52:44 +00003099#ifdef SQLITE_ENABLE_MEMSYS3
3100const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
3101#endif
3102#ifdef SQLITE_ENABLE_MEMSYS5
3103const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
3104#endif
3105
3106
drh18472fa2008-10-07 15:25:48 +00003107#ifndef SQLITE_MUTEX_OMIT
dan558814f2010-06-02 05:53:53 +00003108 sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
3109 sqlite3_mutex_methods const *sqlite3NoopMutex(void);
drh65bbf292008-06-19 01:03:17 +00003110 sqlite3_mutex *sqlite3MutexAlloc(int);
3111 int sqlite3MutexInit(void);
3112 int sqlite3MutexEnd(void);
3113#endif
danielk19776d2ab0e2008-06-17 17:21:18 +00003114
drhaf89fe62015-03-23 17:25:18 +00003115sqlite3_int64 sqlite3StatusValue(int);
3116void sqlite3StatusUp(int, int);
3117void sqlite3StatusDown(int, int);
drhf7141992008-06-19 00:16:08 +00003118void sqlite3StatusSet(int, int);
3119
drhaf89fe62015-03-23 17:25:18 +00003120/* Access to mutexes used by sqlite3_status() */
3121sqlite3_mutex *sqlite3Pcache1Mutex(void);
3122sqlite3_mutex *sqlite3MallocMutex(void);
3123
drh85c8f292010-01-13 17:39:53 +00003124#ifndef SQLITE_OMIT_FLOATING_POINT
3125 int sqlite3IsNaN(double);
3126#else
3127# define sqlite3IsNaN(X) 0
3128#endif
drh0de3ae92008-04-28 16:55:26 +00003129
drha5c14162013-12-17 15:03:06 +00003130/*
3131** An instance of the following structure holds information about SQL
3132** functions arguments that are the parameters to the printf() function.
3133*/
3134struct PrintfArguments {
3135 int nArg; /* Total number of arguments */
3136 int nUsed; /* Number of arguments used so far */
3137 sqlite3_value **apArg; /* The argument values */
3138};
3139
3140#define SQLITE_PRINTF_INTERNAL 0x01
3141#define SQLITE_PRINTF_SQLFUNC 0x02
3142void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
3143void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
drh17435752007-08-16 04:30:38 +00003144char *sqlite3MPrintf(sqlite3*,const char*, ...);
3145char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
drh633e6d52008-07-28 19:34:53 +00003146char *sqlite3MAppendf(sqlite3*,char*,const char*,...);
drh87cc3b32007-05-08 21:45:27 +00003147#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
3148 void sqlite3DebugPrintf(const char*, ...);
drhd919fe12007-12-11 19:34:44 +00003149#endif
3150#if defined(SQLITE_TEST)
drhe8f52c52008-07-12 14:52:20 +00003151 void *sqlite3TestTextToPtr(const char*);
drh87cc3b32007-05-08 21:45:27 +00003152#endif
drh7e02e5e2011-12-06 19:44:51 +00003153
drh4fa4a542014-09-30 12:33:33 +00003154#if defined(SQLITE_DEBUG)
3155 TreeView *sqlite3TreeViewPush(TreeView*,u8);
3156 void sqlite3TreeViewPop(TreeView*);
3157 void sqlite3TreeViewLine(TreeView*, const char*, ...);
3158 void sqlite3TreeViewItem(TreeView*, const char*, u8);
3159 void sqlite3TreeViewExpr(TreeView*, const Expr*, u8);
3160 void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*);
3161 void sqlite3TreeViewSelect(TreeView*, const Select*, u8);
drh7e02e5e2011-12-06 19:44:51 +00003162#endif
3163
3164
drhf089aa42008-07-08 19:34:06 +00003165void sqlite3SetString(char **, sqlite3*, const char*, ...);
danielk19774adee202004-05-08 08:23:19 +00003166void sqlite3ErrorMsg(Parse*, const char*, ...);
drh24fb6272009-05-01 21:13:36 +00003167int sqlite3Dequote(char*);
drh2646da72005-12-09 20:02:05 +00003168int sqlite3KeywordCode(const unsigned char*, int);
danielk19774adee202004-05-08 08:23:19 +00003169int sqlite3RunParser(Parse*, const char*, char **);
drh80242052004-06-09 00:48:12 +00003170void sqlite3FinishCoding(Parse*);
drh892d3172008-01-10 03:46:36 +00003171int sqlite3GetTempReg(Parse*);
3172void sqlite3ReleaseTempReg(Parse*,int);
3173int sqlite3GetTempRange(Parse*,int);
3174void sqlite3ReleaseTempRange(Parse*,int,int);
drhcdc69552011-12-06 13:24:59 +00003175void sqlite3ClearTempRegCache(Parse*);
drhb7916a72009-05-27 10:31:29 +00003176Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int);
3177Expr *sqlite3Expr(sqlite3*,int,const char*);
3178void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
drh17435752007-08-16 04:30:38 +00003179Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
danielk19771e536952007-08-16 10:09:01 +00003180Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
drh17435752007-08-16 04:30:38 +00003181Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
drhfa6bc002004-09-07 16:19:52 +00003182void sqlite3ExprAssignVarNumber(Parse*, Expr*);
drh633e6d52008-07-28 19:34:53 +00003183void sqlite3ExprDelete(sqlite3*, Expr*);
drhb7916a72009-05-27 10:31:29 +00003184ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
3185void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
3186void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
drh633e6d52008-07-28 19:34:53 +00003187void sqlite3ExprListDelete(sqlite3*, ExprList*);
drh2308ed32015-02-09 16:09:34 +00003188u32 sqlite3ExprListFlags(const ExprList*);
drh9bb575f2004-09-06 17:24:11 +00003189int sqlite3Init(sqlite3*, char**);
drh234c39d2004-07-24 03:30:47 +00003190int sqlite3InitCallback(void*, int, char**, char**);
danielk197791cf71b2004-06-26 06:37:06 +00003191void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
drh81028a42012-05-15 18:28:27 +00003192void sqlite3ResetAllSchemasOfConnection(sqlite3*);
3193void sqlite3ResetOneSchema(sqlite3*,int);
3194void sqlite3CollapseDatabaseArray(sqlite3*);
danielk19774adee202004-05-08 08:23:19 +00003195void sqlite3BeginParse(Parse*,int);
drh9bb575f2004-09-06 17:24:11 +00003196void sqlite3CommitInternalChanges(sqlite3*);
drh7d10d5a2008-08-20 16:35:10 +00003197Table *sqlite3ResultSetOfSelect(Parse*,Select*);
danielk1977c00da102006-01-07 13:21:04 +00003198void sqlite3OpenMasterTable(Parse *, int);
drh44156282013-10-23 22:23:03 +00003199Index *sqlite3PrimaryKeyIndex(Table*);
3200i16 sqlite3ColumnOfIndex(Index*, i16);
danielk1977f1a381e2006-06-16 08:01:02 +00003201void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
danielk19774adee202004-05-08 08:23:19 +00003202void sqlite3AddColumn(Parse*,Token*);
3203void sqlite3AddNotNull(Parse*, int);
drhfdd6e852005-12-16 01:06:16 +00003204void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
drhffe07b22005-11-03 00:41:17 +00003205void sqlite3AddCheckConstraint(Parse*, Expr*);
drh487e2622005-06-25 18:42:14 +00003206void sqlite3AddColumnType(Parse*,Token*);
drhb7916a72009-05-27 10:31:29 +00003207void sqlite3AddDefaultValue(Parse*,ExprSpan*);
danielk197739002502007-11-12 09:50:26 +00003208void sqlite3AddCollateType(Parse*, Token*);
drh5969da42013-10-21 02:14:45 +00003209void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);
drh522c26f2011-05-07 14:40:29 +00003210int sqlite3ParseUri(const char*,const char*,unsigned int*,
3211 sqlite3_vfs**,char**,char **);
drh421377e2012-03-15 21:28:54 +00003212Btree *sqlite3DbNameToBtree(sqlite3*,const char*);
dan1d8cb212011-12-09 13:24:16 +00003213int sqlite3CodeOnce(Parse *);
drhb7f91642004-10-31 02:22:47 +00003214
drhc007f612014-05-16 14:17:01 +00003215#ifdef SQLITE_OMIT_BUILTIN_TEST
3216# define sqlite3FaultSim(X) SQLITE_OK
3217#else
3218 int sqlite3FaultSim(int);
3219#endif
3220
drhf5e7bb52008-02-18 14:47:33 +00003221Bitvec *sqlite3BitvecCreate(u32);
3222int sqlite3BitvecTest(Bitvec*, u32);
3223int sqlite3BitvecSet(Bitvec*, u32);
drhe98c9042009-06-02 21:31:38 +00003224void sqlite3BitvecClear(Bitvec*, u32, void*);
drhf5e7bb52008-02-18 14:47:33 +00003225void sqlite3BitvecDestroy(Bitvec*);
danielk1977bea2a942009-01-20 17:06:27 +00003226u32 sqlite3BitvecSize(Bitvec*);
drh3088d592008-03-21 16:45:47 +00003227int sqlite3BitvecBuiltinTest(int,int*);
drhf5e7bb52008-02-18 14:47:33 +00003228
drh3d4501e2008-12-04 20:40:10 +00003229RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
3230void sqlite3RowSetClear(RowSet*);
3231void sqlite3RowSetInsert(RowSet*, i64);
drhd83cad22014-04-10 02:24:48 +00003232int sqlite3RowSetTest(RowSet*, int iBatch, i64);
drh3d4501e2008-12-04 20:40:10 +00003233int sqlite3RowSetNext(RowSet*, i64*);
3234
drhfdd48a72006-09-11 23:45:48 +00003235void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
danielk1977fe3fcbe22006-06-12 12:08:45 +00003236
3237#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
drhb7f91642004-10-31 02:22:47 +00003238 int sqlite3ViewGetColumnNames(Parse*,Table*);
3239#else
3240# define sqlite3ViewGetColumnNames(A,B) 0
3241#endif
3242
drha7ab6d82014-07-21 15:44:39 +00003243#if SQLITE_MAX_ATTACHED>30
3244 int sqlite3DbMaskAllZero(yDbMask);
3245#endif
drha0733842005-12-29 01:11:36 +00003246void sqlite3DropTable(Parse*, SrcList*, int, int);
drhfaacf172011-08-12 01:51:45 +00003247void sqlite3CodeDropTable(Parse*, Table*, int, int);
dan1feeaed2010-07-23 15:41:47 +00003248void sqlite3DeleteTable(sqlite3*, Table*);
drh0b9f50d2009-06-23 20:28:53 +00003249#ifndef SQLITE_OMIT_AUTOINCREMENT
3250 void sqlite3AutoincrementBegin(Parse *pParse);
3251 void sqlite3AutoincrementEnd(Parse *pParse);
3252#else
3253# define sqlite3AutoincrementBegin(X)
3254# define sqlite3AutoincrementEnd(X)
3255#endif
drh75593d92014-01-10 20:46:55 +00003256void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int);
drh6c535152012-02-02 03:38:30 +00003257void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*);
drh17435752007-08-16 04:30:38 +00003258IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);
danielk19774adee202004-05-08 08:23:19 +00003259int sqlite3IdListIndex(IdList*,const char*);
drha78c22c2008-11-11 18:28:58 +00003260SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int);
drh17435752007-08-16 04:30:38 +00003261SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*);
danielk1977b1c685b2008-10-06 16:18:39 +00003262SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
danielk197785574e32008-10-06 05:32:18 +00003263 Token*, Select*, Expr*, IdList*);
danielk1977b1c685b2008-10-06 16:18:39 +00003264void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
3265int sqlite3IndexedByLookup(Parse *, struct SrcList_item *);
drh61dfc312006-12-16 16:25:15 +00003266void sqlite3SrcListShiftJoinType(SrcList*);
danielk19774adee202004-05-08 08:23:19 +00003267void sqlite3SrcListAssignCursors(Parse*, SrcList*);
drh633e6d52008-07-28 19:34:53 +00003268void sqlite3IdListDelete(sqlite3*, IdList*);
3269void sqlite3SrcListDelete(sqlite3*, SrcList*);
drhbbbdc832013-10-22 18:01:40 +00003270Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**);
dan1da40a32009-09-19 17:00:31 +00003271Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
drh8a9789b2013-08-01 03:36:59 +00003272 Expr*, int, int);
drh4d91a702006-01-04 15:54:36 +00003273void sqlite3DropIndex(Parse*, SrcList*, int);
drh7d10d5a2008-08-20 16:35:10 +00003274int sqlite3Select(Parse*, Select*, SelectDest*);
drh17435752007-08-16 04:30:38 +00003275Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
drh832ee3d2012-12-18 19:36:11 +00003276 Expr*,ExprList*,u16,Expr*,Expr*);
drh633e6d52008-07-28 19:34:53 +00003277void sqlite3SelectDelete(sqlite3*, Select*);
danielk19774adee202004-05-08 08:23:19 +00003278Table *sqlite3SrcListLookup(Parse*, SrcList*);
3279int sqlite3IsReadOnly(Parse*, Table*, int);
danielk1977c00da102006-01-07 13:21:04 +00003280void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
shane273f6192008-10-10 04:34:16 +00003281#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
drh4bde3702013-02-19 18:34:12 +00003282Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,Expr*,char*);
shane4281bd42008-10-07 05:27:11 +00003283#endif
danielk19774adee202004-05-08 08:23:19 +00003284void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
3285void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
drh46ec5b62012-09-24 15:30:54 +00003286WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int);
danielk19774adee202004-05-08 08:23:19 +00003287void sqlite3WhereEnd(WhereInfo*);
drhc63367e2013-06-10 20:46:50 +00003288u64 sqlite3WhereOutputRowCount(WhereInfo*);
drh6f328482013-06-05 23:39:34 +00003289int sqlite3WhereIsDistinct(WhereInfo*);
3290int sqlite3WhereIsOrdered(WhereInfo*);
dan374cd782014-04-21 13:21:56 +00003291int sqlite3WhereIsSorted(WhereInfo*);
drh6f328482013-06-05 23:39:34 +00003292int sqlite3WhereContinueLabel(WhereInfo*);
3293int sqlite3WhereBreakLabel(WhereInfo*);
drhfc8d4f92013-11-08 15:19:46 +00003294int sqlite3WhereOkOnePass(WhereInfo*, int*);
drha748fdc2012-03-28 01:34:47 +00003295int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8);
drh5c092e82010-05-14 19:24:02 +00003296void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
drhb21e7c72008-06-22 12:37:57 +00003297void sqlite3ExprCodeMove(Parse*, int, int, int);
drhceea3322009-04-23 13:22:42 +00003298void sqlite3ExprCacheStore(Parse*, int, int, int);
3299void sqlite3ExprCachePush(Parse*);
drhd2490902014-04-13 19:28:15 +00003300void sqlite3ExprCachePop(Parse*);
drhf49f3522009-12-30 14:12:38 +00003301void sqlite3ExprCacheRemove(Parse*, int, int);
drhceea3322009-04-23 13:22:42 +00003302void sqlite3ExprCacheClear(Parse*);
drhda250ea2008-04-01 05:07:14 +00003303void sqlite3ExprCacheAffinityChange(Parse*, int, int);
drh05a86c52014-02-16 01:55:49 +00003304void sqlite3ExprCode(Parse*, Expr*, int);
3305void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
drhd673cdd2013-11-21 21:23:31 +00003306void sqlite3ExprCodeAtInit(Parse*, Expr*, int, u8);
drh2dcef112008-01-12 19:03:48 +00003307int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
drh678ccce2008-03-31 18:19:54 +00003308int sqlite3ExprCodeTarget(Parse*, Expr*, int);
drh05a86c52014-02-16 01:55:49 +00003309void sqlite3ExprCodeAndCache(Parse*, Expr*, int);
drhd1a01ed2013-11-21 16:08:52 +00003310int sqlite3ExprCodeExprList(Parse*, ExprList*, int, u8);
3311#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */
3312#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
danielk19774adee202004-05-08 08:23:19 +00003313void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
3314void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
drh9bb575f2004-09-06 17:24:11 +00003315Table *sqlite3FindTable(sqlite3*,const char*, const char*);
drhca424112008-01-25 15:04:48 +00003316Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*);
dan41fb5cd2012-10-04 19:33:00 +00003317Table *sqlite3LocateTableItem(Parse*,int isView,struct SrcList_item *);
drh9bb575f2004-09-06 17:24:11 +00003318Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
3319void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
3320void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
drh74161702006-02-24 02:53:49 +00003321void sqlite3Vacuum(Parse*);
drh9bb575f2004-09-06 17:24:11 +00003322int sqlite3RunVacuum(char**, sqlite3*);
drh17435752007-08-16 04:30:38 +00003323char *sqlite3NameFromToken(sqlite3*, Token*);
drh619a1302013-08-01 13:04:46 +00003324int sqlite3ExprCompare(Expr*, Expr*, int);
3325int sqlite3ExprListCompare(ExprList*, ExprList*, int);
drh4bd5f732013-07-31 23:22:39 +00003326int sqlite3ExprImpliesExpr(Expr*, Expr*, int);
drhd2b3e232008-01-23 14:51:49 +00003327void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
3328void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
drh030796d2012-08-23 16:18:10 +00003329int sqlite3FunctionUsesThisSrc(Expr*, SrcList*);
danielk19774adee202004-05-08 08:23:19 +00003330Vdbe *sqlite3GetVdbe(Parse*);
drh2fa18682008-03-19 14:15:34 +00003331void sqlite3PrngSaveState(void);
3332void sqlite3PrngRestoreState(void);
drh0f198a72012-02-13 16:43:16 +00003333void sqlite3RollbackAll(sqlite3*,int);
danielk19774adee202004-05-08 08:23:19 +00003334void sqlite3CodeVerifySchema(Parse*, int);
dan57966752011-04-09 17:32:58 +00003335void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);
drh684917c2004-10-05 02:41:42 +00003336void sqlite3BeginTransaction(Parse*, int);
danielk19774adee202004-05-08 08:23:19 +00003337void sqlite3CommitTransaction(Parse*);
3338void sqlite3RollbackTransaction(Parse*);
danielk1977fd7f0452008-12-17 17:30:26 +00003339void sqlite3Savepoint(Parse*, int, Token*);
3340void sqlite3CloseSavepoints(sqlite3 *);
drh4245c402012-06-02 14:32:21 +00003341void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
danielk19774adee202004-05-08 08:23:19 +00003342int sqlite3ExprIsConstant(Expr*);
drh0a168372007-06-08 00:20:47 +00003343int sqlite3ExprIsConstantNotJoin(Expr*);
drhfeada2d2014-09-24 13:20:22 +00003344int sqlite3ExprIsConstantOrFunction(Expr*, u8);
drh059b2d52014-10-24 19:28:09 +00003345int sqlite3ExprIsTableConstant(Expr*,int);
danielk19774adee202004-05-08 08:23:19 +00003346int sqlite3ExprIsInteger(Expr*, int*);
drh039fc322009-11-17 18:31:47 +00003347int sqlite3ExprCanBeNull(const Expr*);
3348int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
danielk19774adee202004-05-08 08:23:19 +00003349int sqlite3IsRowid(const char*);
drh392ee212013-11-08 16:54:56 +00003350void sqlite3GenerateRowDelete(Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8);
drh26198bb2013-10-31 11:15:09 +00003351void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*);
drh1c2c0b72014-01-04 19:27:05 +00003352int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
drh87744512014-04-13 19:15:49 +00003353void sqlite3ResolvePartIdxLabel(Parse*,int);
drhf8ffb272013-11-01 17:08:56 +00003354void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
3355 u8,u8,int,int*);
drh26198bb2013-10-31 11:15:09 +00003356void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);
drh6a534992013-11-16 20:13:39 +00003357int sqlite3OpenTableAndIndices(Parse*, Table*, int, int, u8*, int*, int*);
danielk19774adee202004-05-08 08:23:19 +00003358void sqlite3BeginWriteOperation(Parse*, int, int);
drhff738bc2009-09-24 00:09:58 +00003359void sqlite3MultiWrite(Parse*);
3360void sqlite3MayAbort(Parse*);
drhf9c8ce32013-11-05 13:33:55 +00003361void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8);
3362void sqlite3UniqueConstraint(Parse*, int, Index*);
3363void sqlite3RowidConstraint(Parse*, int, Table*);
danielk19776ab3a2e2009-02-19 14:39:25 +00003364Expr *sqlite3ExprDup(sqlite3*,Expr*,int);
danielk19776ab3a2e2009-02-19 14:39:25 +00003365ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int);
3366SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int);
drh17435752007-08-16 04:30:38 +00003367IdList *sqlite3IdListDup(sqlite3*,IdList*);
danielk19776ab3a2e2009-02-19 14:39:25 +00003368Select *sqlite3SelectDup(sqlite3*,Select*,int);
drheb9b8842014-09-21 00:27:26 +00003369#if SELECTTRACE_ENABLED
3370void sqlite3SelectSetName(Select*,const char*);
3371#else
3372# define sqlite3SelectSetName(A,B)
3373#endif
drh70a8ca32008-08-21 18:49:27 +00003374void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
drh89d5d6a2012-04-07 00:09:21 +00003375FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,u8);
drh9bb575f2004-09-06 17:24:11 +00003376void sqlite3RegisterBuiltinFunctions(sqlite3*);
drh777c5382008-08-21 20:21:34 +00003377void sqlite3RegisterDateTimeFunctions(void);
drh70a8ca32008-08-21 18:49:27 +00003378void sqlite3RegisterGlobalFunctions(void);
drh7e8b8482008-01-23 03:03:05 +00003379int sqlite3SafetyCheckOk(sqlite3*);
3380int sqlite3SafetyCheckSickOrOk(sqlite3*);
drh9cbf3422008-01-17 16:22:13 +00003381void sqlite3ChangeCookie(Parse*, int);
shanefa4e62f2008-09-01 21:59:42 +00003382
3383#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
drh2a5d8252008-08-22 12:30:52 +00003384void sqlite3MaterializeView(Parse*, Table*, Expr*, int);
shanefa4e62f2008-09-01 21:59:42 +00003385#endif
drhb7f91642004-10-31 02:22:47 +00003386
3387#ifndef SQLITE_OMIT_TRIGGER
3388 void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
drh60218d22007-04-06 11:26:00 +00003389 Expr*,int, int);
drhb7f91642004-10-31 02:22:47 +00003390 void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
drhfdd48a72006-09-11 23:45:48 +00003391 void sqlite3DropTrigger(Parse*, SrcList*, int);
drh74161702006-02-24 02:53:49 +00003392 void sqlite3DropTriggerPtr(Parse*, Trigger*);
danielk19772f886d12009-02-28 10:47:41 +00003393 Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask);
3394 Trigger *sqlite3TriggerList(Parse *, Table *);
dan165921a2009-08-28 18:53:45 +00003395 void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
dan94d7f502009-09-24 09:05:49 +00003396 int, int, int);
dan1da40a32009-09-19 17:00:31 +00003397 void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
drhb7f91642004-10-31 02:22:47 +00003398 void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
drh633e6d52008-07-28 19:34:53 +00003399 void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
drh17435752007-08-16 04:30:38 +00003400 TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*);
3401 TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*,
drh75593d92014-01-10 20:46:55 +00003402 Select*,u8);
shane5eff7cf2009-08-10 03:57:58 +00003403 TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8);
drh17435752007-08-16 04:30:38 +00003404 TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*);
drh633e6d52008-07-28 19:34:53 +00003405 void sqlite3DeleteTrigger(sqlite3*, Trigger*);
drhb7f91642004-10-31 02:22:47 +00003406 void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
danbb5f1682009-11-27 12:12:34 +00003407 u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
dan65a7cd12009-09-01 12:16:01 +00003408# define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
drhb7f91642004-10-31 02:22:47 +00003409#else
danielk197762c14b32008-11-19 09:05:26 +00003410# define sqlite3TriggersExist(B,C,D,E,F) 0
drh633e6d52008-07-28 19:34:53 +00003411# define sqlite3DeleteTrigger(A,B)
drhcdd536f2006-03-17 00:04:03 +00003412# define sqlite3DropTriggerPtr(A,B)
drhb7f91642004-10-31 02:22:47 +00003413# define sqlite3UnlinkAndDeleteTrigger(A,B,C)
dan94d7f502009-09-24 09:05:49 +00003414# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
dan75cbd982009-09-21 16:06:03 +00003415# define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
danielk19772943c372009-04-07 14:14:22 +00003416# define sqlite3TriggerList(X, Y) 0
dan65a7cd12009-09-01 12:16:01 +00003417# define sqlite3ParseToplevel(p) p
danbb5f1682009-11-27 12:12:34 +00003418# define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
drhb7f91642004-10-31 02:22:47 +00003419#endif
3420
danielk19774adee202004-05-08 08:23:19 +00003421int sqlite3JoinType(Parse*, Token*, Token*, Token*);
danielk19770202b292004-06-09 09:55:16 +00003422void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
danielk19774adee202004-05-08 08:23:19 +00003423void sqlite3DeferForeignKey(Parse*, int);
drhed6c8672003-01-12 18:02:16 +00003424#ifndef SQLITE_OMIT_AUTHORIZATION
drh728b5772007-09-18 15:55:07 +00003425 void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
danielk19774adee202004-05-08 08:23:19 +00003426 int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
3427 void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
3428 void sqlite3AuthContextPop(AuthContext*);
dan02470b22009-10-03 07:04:11 +00003429 int sqlite3AuthReadCol(Parse*, const char *, const char *, int);
drhed6c8672003-01-12 18:02:16 +00003430#else
danielk1977b5258c32007-10-04 18:11:15 +00003431# define sqlite3AuthRead(a,b,c,d)
danielk19774adee202004-05-08 08:23:19 +00003432# define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
3433# define sqlite3AuthContextPush(a,b,c)
3434# define sqlite3AuthContextPop(a) ((void)(a))
drhed6c8672003-01-12 18:02:16 +00003435#endif
danielk1977f744bb52005-12-06 17:19:11 +00003436void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
3437void sqlite3Detach(Parse*, Expr*);
drhd100f692013-10-03 15:39:44 +00003438void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
danielk19774adee202004-05-08 08:23:19 +00003439int sqlite3FixSrcList(DbFixer*, SrcList*);
3440int sqlite3FixSelect(DbFixer*, Select*);
3441int sqlite3FixExpr(DbFixer*, Expr*);
3442int sqlite3FixExprList(DbFixer*, ExprList*);
3443int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
drh9339da12010-09-30 00:50:49 +00003444int sqlite3AtoF(const char *z, double*, int, u8);
drhfec19aa2004-05-19 20:41:03 +00003445int sqlite3GetInt32(const char *, int*);
drh60ac3f42010-11-23 18:59:27 +00003446int sqlite3Atoi(const char*);
drhee858132007-05-08 20:37:38 +00003447int sqlite3Utf16ByteLen(const void *pData, int nChar);
3448int sqlite3Utf8CharLen(const char *pData, int nByte);
drh42610962012-09-17 18:56:32 +00003449u32 sqlite3Utf8Read(const u8**);
drhbf539c42013-10-05 18:16:02 +00003450LogEst sqlite3LogEst(u64);
3451LogEst sqlite3LogEstAdd(LogEst,LogEst);
3452#ifndef SQLITE_OMIT_VIRTUALTABLE
3453LogEst sqlite3LogEstFromDouble(double);
3454#endif
3455u64 sqlite3LogEstToInt(LogEst);
shane3f8d5cf2008-04-24 19:15:09 +00003456
3457/*
3458** Routines to read and write variable-length integers. These used to
3459** be defined locally, but now we use the varint routines in the util.c
drh2f2b2b82014-08-22 18:48:25 +00003460** file.
shane3f8d5cf2008-04-24 19:15:09 +00003461*/
drh35b5a332008-04-05 18:41:42 +00003462int sqlite3PutVarint(unsigned char*, u64);
drh1bd10f82008-12-10 21:19:56 +00003463u8 sqlite3GetVarint(const unsigned char *, u64 *);
3464u8 sqlite3GetVarint32(const unsigned char *, u32 *);
danielk1977192ac1d2004-05-10 07:17:30 +00003465int sqlite3VarintLen(u64 v);
shane3f8d5cf2008-04-24 19:15:09 +00003466
3467/*
drh2f2b2b82014-08-22 18:48:25 +00003468** The common case is for a varint to be a single byte. They following
3469** macros handle the common case without a procedure call, but then call
3470** the procedure for larger varints.
shane3f8d5cf2008-04-24 19:15:09 +00003471*/
drh4bde3702013-02-19 18:34:12 +00003472#define getVarint32(A,B) \
3473 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
3474#define putVarint32(A,B) \
3475 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
drh2f2b2b82014-08-22 18:48:25 +00003476 sqlite3PutVarint((A),(B)))
shane3f8d5cf2008-04-24 19:15:09 +00003477#define getVarint sqlite3GetVarint
3478#define putVarint sqlite3PutVarint
3479
3480
dan69f8bb92009-08-13 19:21:16 +00003481const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
drh57bf4a82014-02-17 14:59:22 +00003482void sqlite3TableAffinity(Vdbe*, Table*, int);
danielk1977e014a832004-05-17 10:48:57 +00003483char sqlite3CompareAffinity(Expr *pExpr, char aff2);
danielk1977e014a832004-05-17 10:48:57 +00003484int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
danielk1977bf3b7212004-05-18 10:06:24 +00003485char sqlite3ExprAffinity(Expr *pExpr);
drh9339da12010-09-30 00:50:49 +00003486int sqlite3Atoi64(const char*, i64*, int, u8);
drh9296c182014-07-23 13:40:49 +00003487int sqlite3DecOrHexToI64(const char*, i64*);
drh13f40da2014-08-22 18:00:11 +00003488void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);
3489void sqlite3Error(sqlite3*,int);
drhca48c902008-01-18 14:08:24 +00003490void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
dancd74b612011-04-22 19:37:32 +00003491u8 sqlite3HexToInt(int h);
danielk1977ef2cb632004-05-29 02:37:19 +00003492int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
mistachkindd08ca02013-04-30 07:58:15 +00003493
drh685e3c42013-12-21 17:07:13 +00003494#if defined(SQLITE_TEST)
mistachkinf2c1c992013-04-28 01:44:43 +00003495const char *sqlite3ErrName(int);
mistachkindd08ca02013-04-30 07:58:15 +00003496#endif
3497
danielk1977f20b21c2004-05-31 23:56:42 +00003498const char *sqlite3ErrStr(int);
danielk19778a414492004-06-29 08:59:35 +00003499int sqlite3ReadSchema(Parse *pParse);
drhc4a64fa2009-05-11 20:53:28 +00003500CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
3501CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
danielk19777cedc8d2004-06-10 10:50:08 +00003502CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
dan80103fc2015-03-20 08:43:59 +00003503Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int);
drh0a8a4062012-12-07 18:38:16 +00003504Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*);
3505Expr *sqlite3ExprSkipCollate(Expr*);
danielk19777cedc8d2004-06-10 10:50:08 +00003506int sqlite3CheckCollSeq(Parse *, CollSeq *);
danielk1977d8123362004-06-12 09:25:12 +00003507int sqlite3CheckObjectName(Parse *, const char *);
danielk1977b28af712004-06-21 06:50:26 +00003508void sqlite3VdbeSetChanges(sqlite3 *, int);
drh158b9cb2011-03-05 20:59:46 +00003509int sqlite3AddInt64(i64*,i64);
3510int sqlite3SubInt64(i64*,i64);
3511int sqlite3MulInt64(i64*,i64);
drhd50ffc42011-03-08 02:38:28 +00003512int sqlite3AbsInt32(int);
drh81cc5162011-05-17 20:36:21 +00003513#ifdef SQLITE_ENABLE_8_3_NAMES
3514void sqlite3FileSuffix3(const char*, char*);
3515#else
3516# define sqlite3FileSuffix3(X,Y)
3517#endif
drheac5bd72014-07-25 21:35:39 +00003518u8 sqlite3GetBoolean(const char *z,u8);
danielk19774e6af132004-06-10 14:01:08 +00003519
drhb21c8cd2007-08-21 19:33:56 +00003520const void *sqlite3ValueText(sqlite3_value*, u8);
3521int sqlite3ValueBytes(sqlite3_value*, u8);
3522void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
danielk19771e536952007-08-16 10:09:01 +00003523 void(*)(void*));
drha3cc0072013-12-13 16:23:55 +00003524void sqlite3ValueSetNull(sqlite3_value*);
danielk19774e6af132004-06-10 14:01:08 +00003525void sqlite3ValueFree(sqlite3_value*);
danielk19771e536952007-08-16 10:09:01 +00003526sqlite3_value *sqlite3ValueNew(sqlite3 *);
danb7dca7d2010-03-05 16:32:12 +00003527char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
danielk19771e536952007-08-16 10:09:01 +00003528int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
drhb21c8cd2007-08-21 19:33:56 +00003529void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
drh46c99e02007-08-27 23:26:59 +00003530#ifndef SQLITE_AMALGAMATION
drha6c2ed92009-11-14 23:22:23 +00003531extern const unsigned char sqlite3OpcodeProperty[];
drh4e5ffc52004-08-31 00:52:37 +00003532extern const unsigned char sqlite3UpperToLower[];
danielk197778ca0e72009-01-20 16:53:39 +00003533extern const unsigned char sqlite3CtypeMap[];
drh094430e2010-07-14 18:24:06 +00003534extern const Token sqlite3IntTokens[];
danielk1977075c23a2008-09-01 18:34:20 +00003535extern SQLITE_WSD struct Sqlite3Config sqlite3Config;
3536extern SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
drhf83dc1e2010-06-03 12:09:52 +00003537#ifndef SQLITE_OMIT_WSD
drhddb68e12009-02-05 16:53:43 +00003538extern int sqlite3PendingByte;
drh46c99e02007-08-27 23:26:59 +00003539#endif
drhf83dc1e2010-06-03 12:09:52 +00003540#endif
drhcdf011d2011-04-04 21:25:28 +00003541void sqlite3RootPageMoved(sqlite3*, int, int, int);
drh4343fea2004-11-05 23:46:15 +00003542void sqlite3Reindex(Parse*, Token*, Token*);
drh545f5872010-04-24 14:02:59 +00003543void sqlite3AlterFunctions(void);
danielk19779fd2a9a2004-11-12 13:42:30 +00003544void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
3545int sqlite3GetToken(const unsigned char *, int *);
drh2958a4e2004-11-12 03:56:15 +00003546void sqlite3NestedParse(Parse*, const char*, ...);
drhd89bd002005-01-22 03:03:54 +00003547void sqlite3ExpirePreparedStatements(sqlite3*);
drh1450bc62009-10-30 13:25:56 +00003548int sqlite3CodeSubselect(Parse *, Expr *, int, int);
drh7d10d5a2008-08-20 16:35:10 +00003549void sqlite3SelectPrep(Parse*, Select*, NameContext*);
drh3e3f1a52013-01-03 00:45:56 +00003550int sqlite3MatchSpanName(const char*, const char*, const char*, const char*);
drh7d10d5a2008-08-20 16:35:10 +00003551int sqlite3ResolveExprNames(NameContext*, Expr*);
drh7d10d5a2008-08-20 16:35:10 +00003552void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
drh3780be12013-07-31 19:05:22 +00003553void sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*);
drh7d10d5a2008-08-20 16:35:10 +00003554int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
danielk1977c7538b52009-07-27 10:05:04 +00003555void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
danielk197719a8e7e2005-03-17 05:03:38 +00003556void sqlite3AlterFinishAddColumn(Parse *, Token *);
3557void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
drh79e72a52012-10-05 14:43:40 +00003558CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
drhfdaac672013-10-04 15:30:21 +00003559char sqlite3AffinityType(const char*, u8*);
drh9f18e8a2005-07-08 12:13:04 +00003560void sqlite3Analyze(Parse*, Token*, Token*);
drha4afb652005-07-09 02:16:02 +00003561int sqlite3InvokeBusyHandler(BusyHandler*);
drhff2d5ea2005-07-23 00:41:48 +00003562int sqlite3FindDb(sqlite3*, Token*);
danielk197704103022009-02-03 16:51:24 +00003563int sqlite3FindDbName(sqlite3 *, const char *);
drhcf1be452007-05-12 12:08:51 +00003564int sqlite3AnalysisLoad(sqlite3*,int iDB);
dand46def72010-07-24 11:28:28 +00003565void sqlite3DeleteIndexSamples(sqlite3*,Index*);
drh51147ba2005-07-23 22:59:55 +00003566void sqlite3DefaultRowEst(Index*);
drh55ef4d92005-08-14 01:20:37 +00003567void sqlite3RegisterLikeFunctions(sqlite3*, int);
drhd64fe2f2005-08-28 17:00:23 +00003568int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
drhfdd6e852005-12-16 01:06:16 +00003569void sqlite3MinimumFileFormat(Parse*, int, int);
drhb6ee6602011-04-04 13:40:53 +00003570void sqlite3SchemaClear(void *);
danielk19771e536952007-08-16 10:09:01 +00003571Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
danielk1977e501b892006-01-09 06:29:47 +00003572int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
drhad124322013-10-23 13:30:58 +00003573KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int);
drh2ec2fb22013-11-06 19:59:23 +00003574void sqlite3KeyInfoUnref(KeyInfo*);
3575KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
3576KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
3577#ifdef SQLITE_DEBUG
3578int sqlite3KeyInfoIsWriteable(KeyInfo*);
3579#endif
danielk1977771151b2006-01-17 13:21:40 +00003580int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
3581 void (*)(sqlite3_context*,int,sqlite3_value **),
dand2199f02010-08-27 17:48:52 +00003582 void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
3583 FuncDestructor *pDestructor
3584);
danielk197754f01982006-01-18 15:25:17 +00003585int sqlite3ApiExit(sqlite3 *db, int);
danielk1977ddfb2f02006-02-17 12:25:14 +00003586int sqlite3OpenTempDatabase(Parse *);
drh69dab1d2006-06-27 14:37:20 +00003587
drhf089aa42008-07-08 19:34:06 +00003588void sqlite3StrAccumInit(StrAccum*, char*, int, int);
drhade86482007-11-28 22:36:40 +00003589void sqlite3StrAccumAppend(StrAccum*,const char*,int);
drha6353a32013-12-09 19:03:26 +00003590void sqlite3StrAccumAppendAll(StrAccum*,const char*);
drhaf8f5132014-10-29 18:20:18 +00003591void sqlite3AppendChar(StrAccum*,int,char);
drhade86482007-11-28 22:36:40 +00003592char *sqlite3StrAccumFinish(StrAccum*);
3593void sqlite3StrAccumReset(StrAccum*);
drh1013c932008-01-06 00:25:21 +00003594void sqlite3SelectDestInit(SelectDest*,int,int);
danf7b0b0a2009-10-19 15:52:32 +00003595Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
danielk19771e536952007-08-16 10:09:01 +00003596
danielk197704103022009-02-03 16:51:24 +00003597void sqlite3BackupRestart(sqlite3_backup *);
3598void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
3599
drh1435a9a2013-08-27 23:15:44 +00003600#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
drh9fecc542013-08-27 20:16:48 +00003601void sqlite3AnalyzeFunctions(void);
dan87cd9322013-08-07 15:52:41 +00003602int sqlite3Stat4ProbeSetValue(Parse*,Index*,UnpackedRecord**,Expr*,u8,int,int*);
danb0b82902014-06-26 20:21:46 +00003603int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**);
dan7a419232013-08-06 20:01:43 +00003604void sqlite3Stat4ProbeFree(UnpackedRecord*);
danb0b82902014-06-26 20:21:46 +00003605int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**);
drh9fecc542013-08-27 20:16:48 +00003606#endif
dan7a419232013-08-06 20:01:43 +00003607
drh95bdbbb2007-07-23 19:31:16 +00003608/*
3609** The interface to the LEMON-generated parser
3610*/
drhfb046e72014-09-12 04:28:33 +00003611void *sqlite3ParserAlloc(void*(*)(u64));
drh95bdbbb2007-07-23 19:31:16 +00003612void sqlite3ParserFree(void*, void(*)(void*));
3613void sqlite3Parser(void*, int, Token, Parse*);
drhec424a52008-07-25 15:39:03 +00003614#ifdef YYTRACKMAXSTACKDEPTH
3615 int sqlite3ParserStackPeak(void*);
3616#endif
drh95bdbbb2007-07-23 19:31:16 +00003617
drh7aaa8782009-05-20 02:40:45 +00003618void sqlite3AutoLoadExtensions(sqlite3*);
drh69dab1d2006-06-27 14:37:20 +00003619#ifndef SQLITE_OMIT_LOAD_EXTENSION
3620 void sqlite3CloseExtensions(sqlite3*);
3621#else
3622# define sqlite3CloseExtensions(X)
3623#endif
danielk1977e3026632004-06-22 11:29:02 +00003624
danielk1977c00da102006-01-07 13:21:04 +00003625#ifndef SQLITE_OMIT_SHARED_CACHE
3626 void sqlite3TableLock(Parse *, int, int, u8, const char *);
3627#else
3628 #define sqlite3TableLock(v,w,x,y,z)
3629#endif
3630
drh53c14022007-05-10 17:23:11 +00003631#ifdef SQLITE_TEST
3632 int sqlite3Utf8To8(unsigned char*);
3633#endif
3634
drhb9bb7c12006-06-11 23:41:55 +00003635#ifdef SQLITE_OMIT_VIRTUALTABLE
danielk1977595a5232009-07-24 17:58:53 +00003636# define sqlite3VtabClear(Y)
danielk19779dbee7d2008-08-02 15:32:39 +00003637# define sqlite3VtabSync(X,Y) SQLITE_OK
danielk1977f9e7dda2006-06-16 16:08:53 +00003638# define sqlite3VtabRollback(X)
3639# define sqlite3VtabCommit(X)
danielk1977093e0f62008-11-13 18:00:14 +00003640# define sqlite3VtabInSync(db) 0
danielk1977595a5232009-07-24 17:58:53 +00003641# define sqlite3VtabLock(X)
3642# define sqlite3VtabUnlock(X)
3643# define sqlite3VtabUnlockList(X)
dana311b802011-04-26 19:21:34 +00003644# define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
drhc3c8dac2011-10-12 19:04:07 +00003645# define sqlite3GetVTable(X,Y) ((VTable*)0)
drhb9bb7c12006-06-11 23:41:55 +00003646#else
dan1feeaed2010-07-23 15:41:47 +00003647 void sqlite3VtabClear(sqlite3 *db, Table*);
danbba02a92012-05-15 17:15:34 +00003648 void sqlite3VtabDisconnect(sqlite3 *db, Table *p);
dan016f7812013-08-21 17:35:48 +00003649 int sqlite3VtabSync(sqlite3 *db, Vdbe*);
danielk1977f9e7dda2006-06-16 16:08:53 +00003650 int sqlite3VtabRollback(sqlite3 *db);
3651 int sqlite3VtabCommit(sqlite3 *db);
danielk1977595a5232009-07-24 17:58:53 +00003652 void sqlite3VtabLock(VTable *);
3653 void sqlite3VtabUnlock(VTable *);
3654 void sqlite3VtabUnlockList(sqlite3*);
dana311b802011-04-26 19:21:34 +00003655 int sqlite3VtabSavepoint(sqlite3 *, int, int);
dan016f7812013-08-21 17:35:48 +00003656 void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*);
drhc3c8dac2011-10-12 19:04:07 +00003657 VTable *sqlite3GetVTable(sqlite3*, Table*);
danielk1977093e0f62008-11-13 18:00:14 +00003658# define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
drhb9bb7c12006-06-11 23:41:55 +00003659#endif
drh4f3dd152008-04-28 18:46:43 +00003660void sqlite3VtabMakeWritable(Parse*,Table*);
drhb421b892012-01-28 19:41:53 +00003661void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int);
drhb9bb7c12006-06-11 23:41:55 +00003662void sqlite3VtabFinishParse(Parse*, Token*);
3663void sqlite3VtabArgInit(Parse*);
3664void sqlite3VtabArgExtend(Parse*, Token*);
danielk197778efaba2006-06-12 06:09:17 +00003665int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
danielk19777e6ebfb2006-06-12 11:24:37 +00003666int sqlite3VtabCallConnect(Parse*, Table*);
danielk19779e39ce82006-06-12 16:01:21 +00003667int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
danielk1977595a5232009-07-24 17:58:53 +00003668int sqlite3VtabBegin(sqlite3 *, VTable *);
danielk19771e536952007-08-16 10:09:01 +00003669FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
drhb7481e72006-09-16 21:45:14 +00003670void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
drh95a7b3e2013-09-16 12:57:19 +00003671sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
drh5f18a222009-11-26 14:01:53 +00003672int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
shane4a27a282008-09-04 04:32:49 +00003673int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
drhf30a9692013-11-15 01:10:18 +00003674void sqlite3ParserReset(Parse*);
drhb900aaf2006-11-09 00:24:53 +00003675int sqlite3Reprepare(Vdbe*);
drhb1a6c3c2008-03-20 16:30:17 +00003676void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
drh0a0e1312007-08-07 17:04:59 +00003677CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
drh1c514142009-04-30 12:25:10 +00003678int sqlite3TempInMemory(const sqlite3*);
dan28e53862010-04-21 06:19:12 +00003679const char *sqlite3JournalModename(int);
dan06a2d822012-10-10 09:46:29 +00003680#ifndef SQLITE_OMIT_WAL
3681 int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
3682 int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
3683#endif
drh8b471862014-01-11 13:22:17 +00003684#ifndef SQLITE_OMIT_CTE
dan4e9119d2014-01-13 15:12:23 +00003685 With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*);
dan7d562db2014-01-11 19:19:36 +00003686 void sqlite3WithDelete(sqlite3*,With*);
danb290f112014-01-17 14:59:27 +00003687 void sqlite3WithPush(Parse*, With*, u8);
dan4e9119d2014-01-13 15:12:23 +00003688#else
danb290f112014-01-17 14:59:27 +00003689#define sqlite3WithPush(x,y,z)
daneede6a52014-01-15 19:42:23 +00003690#define sqlite3WithDelete(x,y)
drh8b471862014-01-11 13:22:17 +00003691#endif
danielk1977d8293352009-04-30 09:10:37 +00003692
dan75cbd982009-09-21 16:06:03 +00003693/* Declarations for functions in fkey.c. All of these are replaced by
3694** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
3695** key functionality is available. If OMIT_TRIGGER is defined but
3696** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
3697** this case foreign keys are parsed, but no other functionality is
3698** provided (enforcement of FK constraints requires the triggers sub-system).
3699*/
3700#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
dan8ff2d952013-09-05 18:40:29 +00003701 void sqlite3FkCheck(Parse*, Table*, int, int, int*, int);
dand66c8302009-09-28 14:49:01 +00003702 void sqlite3FkDropTable(Parse*, SrcList *, Table*);
dan8ff2d952013-09-05 18:40:29 +00003703 void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int);
dane7a94d82009-10-01 16:09:04 +00003704 int sqlite3FkRequired(Parse*, Table*, int*, int);
3705 u32 sqlite3FkOldmask(Parse*, Table*);
dan432cc5b2009-09-26 17:51:48 +00003706 FKey *sqlite3FkReferences(Table *);
dan1da40a32009-09-19 17:00:31 +00003707#else
dan8ff2d952013-09-05 18:40:29 +00003708 #define sqlite3FkActions(a,b,c,d,e,f)
dan67896ce2013-10-14 15:41:39 +00003709 #define sqlite3FkCheck(a,b,c,d,e,f)
dand66c8302009-09-28 14:49:01 +00003710 #define sqlite3FkDropTable(a,b,c)
dan67896ce2013-10-14 15:41:39 +00003711 #define sqlite3FkOldmask(a,b) 0
3712 #define sqlite3FkRequired(a,b,c,d) 0
dan1da40a32009-09-19 17:00:31 +00003713#endif
dan75cbd982009-09-21 16:06:03 +00003714#ifndef SQLITE_OMIT_FOREIGN_KEY
dan1feeaed2010-07-23 15:41:47 +00003715 void sqlite3FkDelete(sqlite3 *, Table*);
drh6c5b9152012-12-17 16:46:37 +00003716 int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**);
dan75cbd982009-09-21 16:06:03 +00003717#else
dan1feeaed2010-07-23 15:41:47 +00003718 #define sqlite3FkDelete(a,b)
drh6c5b9152012-12-17 16:46:37 +00003719 #define sqlite3FkLocateIndex(a,b,c,d,e)
dan75cbd982009-09-21 16:06:03 +00003720#endif
3721
drh643167f2008-01-22 21:30:53 +00003722
3723/*
3724** Available fault injectors. Should be numbered beginning with 0.
3725*/
3726#define SQLITE_FAULTINJECTOR_MALLOC 0
drh7e8b8482008-01-23 03:03:05 +00003727#define SQLITE_FAULTINJECTOR_COUNT 1
drh643167f2008-01-22 21:30:53 +00003728
3729/*
danielk1977ef05f2d2008-06-20 11:05:37 +00003730** The interface to the code in fault.c used for identifying "benign"
3731** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST
3732** is not defined.
drh643167f2008-01-22 21:30:53 +00003733*/
drh3088d592008-03-21 16:45:47 +00003734#ifndef SQLITE_OMIT_BUILTIN_TEST
danielk19772d1d86f2008-06-20 14:59:51 +00003735 void sqlite3BeginBenignMalloc(void);
3736 void sqlite3EndBenignMalloc(void);
drh643167f2008-01-22 21:30:53 +00003737#else
danielk19772d1d86f2008-06-20 14:59:51 +00003738 #define sqlite3BeginBenignMalloc()
danielk1977867d05a2008-06-23 14:03:45 +00003739 #define sqlite3EndBenignMalloc()
drh643167f2008-01-22 21:30:53 +00003740#endif
drh643167f2008-01-22 21:30:53 +00003741
drh3a856252014-08-01 14:46:57 +00003742/*
3743** Allowed return values from sqlite3FindInIndex()
3744*/
3745#define IN_INDEX_ROWID 1 /* Search the rowid of the table */
3746#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */
3747#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */
3748#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */
drhbb53ecb2014-08-02 21:03:33 +00003749#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */
drh3a856252014-08-01 14:46:57 +00003750/*
3751** Allowed flags for the 3rd parameter to sqlite3FindInIndex().
3752*/
drhbb53ecb2014-08-02 21:03:33 +00003753#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
3754#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
3755#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
drh3a856252014-08-01 14:46:57 +00003756int sqlite3FindInIndex(Parse *, Expr *, u32, int*);
danielk19779a96b662007-11-29 17:05:18 +00003757
danielk1977c7b60172007-08-22 11:22:03 +00003758#ifdef SQLITE_ENABLE_ATOMIC_WRITE
3759 int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
3760 int sqlite3JournalSize(sqlite3_vfs *);
danielk1977f55b8992007-08-24 08:15:53 +00003761 int sqlite3JournalCreate(sqlite3_file *);
dan3de0f182012-12-05 10:01:35 +00003762 int sqlite3JournalExists(sqlite3_file *p);
danielk1977c7b60172007-08-22 11:22:03 +00003763#else
3764 #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)
dan3de0f182012-12-05 10:01:35 +00003765 #define sqlite3JournalExists(p) 1
danielk1977c7b60172007-08-22 11:22:03 +00003766#endif
3767
danielk1977b3175382008-10-17 18:51:52 +00003768void sqlite3MemJournalOpen(sqlite3_file *);
drh3a5990a2008-12-20 02:14:39 +00003769int sqlite3MemJournalSize(void);
danielk1977b3175382008-10-17 18:51:52 +00003770int sqlite3IsMemJournal(sqlite3_file *);
3771
drh2308ed32015-02-09 16:09:34 +00003772void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
drh0224d262008-05-28 13:49:34 +00003773#if SQLITE_MAX_EXPR_DEPTH>0
danielk1977fc976062007-05-10 10:46:56 +00003774 int sqlite3SelectExprHeight(Select *);
drh7d10d5a2008-08-20 16:35:10 +00003775 int sqlite3ExprCheckHeight(Parse*, int);
danielk1977fc976062007-05-10 10:46:56 +00003776#else
drh0224d262008-05-28 13:49:34 +00003777 #define sqlite3SelectExprHeight(x) 0
drh7d10d5a2008-08-20 16:35:10 +00003778 #define sqlite3ExprCheckHeight(x,y)
danielk1977fc976062007-05-10 10:46:56 +00003779#endif
3780
drha3152892007-05-05 11:48:52 +00003781u32 sqlite3Get4byte(const u8*);
drha3152892007-05-05 11:48:52 +00003782void sqlite3Put4byte(u8*, u32);
3783
danielk1977404ca072009-03-16 13:19:36 +00003784#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
3785 void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
3786 void sqlite3ConnectionUnlocked(sqlite3 *db);
3787 void sqlite3ConnectionClosed(sqlite3 *db);
3788#else
3789 #define sqlite3ConnectionBlocked(x,y)
3790 #define sqlite3ConnectionUnlocked(x)
3791 #define sqlite3ConnectionClosed(x)
3792#endif
3793
drh6e736832007-05-11 12:30:03 +00003794#ifdef SQLITE_DEBUG
3795 void sqlite3ParserTrace(FILE*, char *);
3796#endif
3797
drhb0603412007-02-28 04:47:26 +00003798/*
3799** If the SQLITE_ENABLE IOTRACE exists then the global variable
mlcreech3a00f902008-03-04 17:45:01 +00003800** sqlite3IoTrace is a pointer to a printf-like routine used to
drhb0603412007-02-28 04:47:26 +00003801** print I/O tracing messages.
3802*/
3803#ifdef SQLITE_ENABLE_IOTRACE
mlcreech3a00f902008-03-04 17:45:01 +00003804# define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
danielk1977b4622b62007-03-02 06:24:19 +00003805 void sqlite3VdbeIOTraceSql(Vdbe*);
mistachkin9871a932015-03-27 00:21:52 +00003806SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
drhb0603412007-02-28 04:47:26 +00003807#else
3808# define IOTRACE(A)
danielk1977b4622b62007-03-02 06:24:19 +00003809# define sqlite3VdbeIOTraceSql(X)
drhb0603412007-02-28 04:47:26 +00003810#endif
drhb0603412007-02-28 04:47:26 +00003811
drh107b56e2010-03-12 16:32:53 +00003812/*
3813** These routines are available for the mem2.c debugging memory allocator
3814** only. They are used to verify that different "types" of memory
3815** allocations are properly tracked by the system.
3816**
3817** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
3818** the MEMTYPE_* macros defined below. The type must be a bitmask with
3819** a single bit set.
3820**
3821** sqlite3MemdebugHasType() returns true if any of the bits in its second
3822** argument match the type set by the previous sqlite3MemdebugSetType().
3823** sqlite3MemdebugHasType() is intended for use inside assert() statements.
drh107b56e2010-03-12 16:32:53 +00003824**
drh174b9a12010-07-26 11:07:20 +00003825** sqlite3MemdebugNoType() returns true if none of the bits in its second
3826** argument match the type set by the previous sqlite3MemdebugSetType().
drh107b56e2010-03-12 16:32:53 +00003827**
3828** Perhaps the most important point is the difference between MEMTYPE_HEAP
drh174b9a12010-07-26 11:07:20 +00003829** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
3830** it might have been allocated by lookaside, except the allocation was
3831** too large or lookaside was already full. It is important to verify
3832** that allocations that might have been satisfied by lookaside are not
3833** passed back to non-lookaside free() routines. Asserts such as the
3834** example above are placed on the non-lookaside free() routines to verify
3835** this constraint.
drh107b56e2010-03-12 16:32:53 +00003836**
3837** All of this is no-op for a production build. It only comes into
3838** play when the SQLITE_MEMDEBUG compile-time option is used.
3839*/
3840#ifdef SQLITE_MEMDEBUG
3841 void sqlite3MemdebugSetType(void*,u8);
3842 int sqlite3MemdebugHasType(void*,u8);
drh174b9a12010-07-26 11:07:20 +00003843 int sqlite3MemdebugNoType(void*,u8);
drh107b56e2010-03-12 16:32:53 +00003844#else
3845# define sqlite3MemdebugSetType(X,Y) /* no-op */
3846# define sqlite3MemdebugHasType(X,Y) 1
drh174b9a12010-07-26 11:07:20 +00003847# define sqlite3MemdebugNoType(X,Y) 1
danielk1977e3026632004-06-22 11:29:02 +00003848#endif
drh174b9a12010-07-26 11:07:20 +00003849#define MEMTYPE_HEAP 0x01 /* General heap allocations */
drhd231aa32014-10-07 15:46:54 +00003850#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */
drh174b9a12010-07-26 11:07:20 +00003851#define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
3852#define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
drh107b56e2010-03-12 16:32:53 +00003853
drhf51446a2012-07-21 19:40:42 +00003854/*
3855** Threading interface
3856*/
drhbf20a352014-04-04 22:44:59 +00003857#if SQLITE_MAX_WORKER_THREADS>0
drhf51446a2012-07-21 19:40:42 +00003858int sqlite3ThreadCreate(SQLiteThread**,void*(*)(void*),void*);
3859int sqlite3ThreadJoin(SQLiteThread*, void**);
drhbf20a352014-04-04 22:44:59 +00003860#endif
drhf51446a2012-07-21 19:40:42 +00003861
drh107b56e2010-03-12 16:32:53 +00003862#endif /* _SQLITEINT_H_ */