drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1 | /* |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 2 | ** 2001 September 15 |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 3 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 4 | ** The author disclaims copyright to this source code. In place of |
| 5 | ** a legal notice, here is a blessing: |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 6 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 7 | ** May you do good and not evil. |
| 8 | ** May you find forgiveness for yourself and forgive others. |
| 9 | ** May you share freely, never taking more than you give. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 10 | ** |
| 11 | ************************************************************************* |
| 12 | ** Internal interface definitions for SQLite. |
| 13 | ** |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 14 | */ |
danielk1977 | e302663 | 2004-06-22 11:29:02 +0000 | [diff] [blame] | 15 | #ifndef _SQLITEINT_H_ |
| 16 | #define _SQLITEINT_H_ |
drh | 71674ce | 2007-10-23 15:51:26 +0000 | [diff] [blame] | 17 | |
mlcreech | bd0ae11 | 2008-03-06 09:16:24 +0000 | [diff] [blame] | 18 | /* |
drh | 2210dcc | 2009-08-12 11:45:40 +0000 | [diff] [blame] | 19 | ** These #defines should enable >2GB file support on POSIX if the |
| 20 | ** underlying operating system supports it. If the OS lacks |
| 21 | ** large file support, or if the OS is windows, these should be no-ops. |
| 22 | ** |
| 23 | ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any |
| 24 | ** system #includes. Hence, this block of code must be the very first |
| 25 | ** code in all source files. |
| 26 | ** |
| 27 | ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch |
| 28 | ** on the compiler command line. This is necessary if you are compiling |
| 29 | ** on a recent machine (ex: Red Hat 7.2) but you want your code to work |
| 30 | ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 |
| 31 | ** without this option, LFS is enable. But LFS does not exist in the kernel |
| 32 | ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary |
| 33 | ** portability you should omit LFS. |
| 34 | ** |
| 35 | ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. |
| 36 | */ |
| 37 | #ifndef SQLITE_DISABLE_LFS |
| 38 | # define _LARGE_FILE 1 |
| 39 | # ifndef _FILE_OFFSET_BITS |
| 40 | # define _FILE_OFFSET_BITS 64 |
| 41 | # endif |
| 42 | # define _LARGEFILE_SOURCE 1 |
| 43 | #endif |
| 44 | |
| 45 | /* |
mlcreech | 1e12d43 | 2008-05-07 02:42:01 +0000 | [diff] [blame] | 46 | ** Include the configuration header output by 'configure' if we're using the |
| 47 | ** autoconf-based build |
mlcreech | bd0ae11 | 2008-03-06 09:16:24 +0000 | [diff] [blame] | 48 | */ |
mlcreech | 1e12d43 | 2008-05-07 02:42:01 +0000 | [diff] [blame] | 49 | #ifdef _HAVE_SQLITE_CONFIG_H |
mlcreech | 98dc4b1 | 2008-03-06 16:28:58 +0000 | [diff] [blame] | 50 | #include "config.h" |
mlcreech | 1e12d43 | 2008-05-07 02:42:01 +0000 | [diff] [blame] | 51 | #endif |
| 52 | |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 53 | #include "sqliteLimit.h" |
mlcreech | 98dc4b1 | 2008-03-06 16:28:58 +0000 | [diff] [blame] | 54 | |
drh | e296582 | 2008-04-10 16:47:41 +0000 | [diff] [blame] | 55 | /* Disable nuisance warnings on Borland compilers */ |
| 56 | #if defined(__BORLANDC__) |
| 57 | #pragma warn -rch /* unreachable code */ |
| 58 | #pragma warn -ccc /* Condition is always true or false */ |
| 59 | #pragma warn -aus /* Assigned value is never used */ |
| 60 | #pragma warn -csu /* Comparing signed and unsigned */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 61 | #pragma warn -spa /* Suspicious pointer arithmetic */ |
drh | e296582 | 2008-04-10 16:47:41 +0000 | [diff] [blame] | 62 | #endif |
| 63 | |
mlcreech | 98dc4b1 | 2008-03-06 16:28:58 +0000 | [diff] [blame] | 64 | /* Needed for various definitions... */ |
drh | 6032341 | 2008-07-31 17:35:45 +0000 | [diff] [blame] | 65 | #ifndef _GNU_SOURCE |
| 66 | # define _GNU_SOURCE |
| 67 | #endif |
mlcreech | 98dc4b1 | 2008-03-06 16:28:58 +0000 | [diff] [blame] | 68 | |
dan | 881bd79 | 2013-03-11 13:37:52 +0000 | [diff] [blame] | 69 | #if defined(__OpenBSD__) && !defined(_BSD_SOURCE) |
| 70 | # define _BSD_SOURCE |
| 71 | #endif |
| 72 | |
mlcreech | 98dc4b1 | 2008-03-06 16:28:58 +0000 | [diff] [blame] | 73 | /* |
drh | 06af763 | 2008-04-28 12:54:15 +0000 | [diff] [blame] | 74 | ** Include standard header files as necessary |
| 75 | */ |
| 76 | #ifdef HAVE_STDINT_H |
| 77 | #include <stdint.h> |
| 78 | #endif |
| 79 | #ifdef HAVE_INTTYPES_H |
| 80 | #include <inttypes.h> |
| 81 | #endif |
| 82 | |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 83 | /* |
drh | c05a9a8 | 2010-03-04 16:12:34 +0000 | [diff] [blame] | 84 | ** The following macros are used to cast pointers to integers and |
| 85 | ** integers to pointers. The way you do this varies from one compiler |
| 86 | ** to the next, so we have developed the following set of #if statements |
| 87 | ** to generate appropriate macros for a wide range of compilers. |
drh | 875e9e7 | 2009-05-16 17:38:21 +0000 | [diff] [blame] | 88 | ** |
drh | c05a9a8 | 2010-03-04 16:12:34 +0000 | [diff] [blame] | 89 | ** The correct "ANSI" way to do this is to use the intptr_t type. |
| 90 | ** Unfortunately, that typedef is not available on all compilers, or |
| 91 | ** if it is available, it requires an #include of specific headers |
drh | c92271c | 2010-03-10 14:06:35 +0000 | [diff] [blame] | 92 | ** that vary from one machine to the next. |
drh | 875e9e7 | 2009-05-16 17:38:21 +0000 | [diff] [blame] | 93 | ** |
| 94 | ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on |
| 95 | ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). |
drh | 5e49edc | 2009-05-18 13:34:37 +0000 | [diff] [blame] | 96 | ** So we have to define the macros in different ways depending on the |
drh | 875e9e7 | 2009-05-16 17:38:21 +0000 | [diff] [blame] | 97 | ** compiler. |
| 98 | */ |
drh | c05a9a8 | 2010-03-04 16:12:34 +0000 | [diff] [blame] | 99 | #if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ |
| 100 | # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) |
| 101 | # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) |
| 102 | #elif !defined(__GNUC__) /* Works for compilers other than LLVM */ |
| 103 | # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) |
| 104 | # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) |
| 105 | #elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ |
| 106 | # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) |
| 107 | # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) |
| 108 | #else /* Generates a warning - but it always works */ |
| 109 | # define SQLITE_INT_TO_PTR(X) ((void*)(X)) |
| 110 | # define SQLITE_PTR_TO_INT(X) ((int)(X)) |
drh | 875e9e7 | 2009-05-16 17:38:21 +0000 | [diff] [blame] | 111 | #endif |
drh | b6dbc00 | 2007-11-27 02:38:00 +0000 | [diff] [blame] | 112 | |
drh | e5e7a90 | 2007-10-01 17:47:00 +0000 | [diff] [blame] | 113 | /* |
drh | 38c67c3 | 2010-09-08 02:30:27 +0000 | [diff] [blame] | 114 | ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. |
| 115 | ** 0 means mutexes are permanently disable and the library is never |
| 116 | ** threadsafe. 1 means the library is serialized which is the highest |
drh | f7b5496 | 2013-05-28 12:11:54 +0000 | [diff] [blame] | 117 | ** level of threadsafety. 2 means the library is multithreaded - multiple |
drh | 38c67c3 | 2010-09-08 02:30:27 +0000 | [diff] [blame] | 118 | ** threads can use SQLite as long as no two threads try to use the same |
| 119 | ** database connection at the same time. |
| 120 | ** |
drh | e5e7a90 | 2007-10-01 17:47:00 +0000 | [diff] [blame] | 121 | ** Older versions of SQLite used an optional THREADSAFE macro. |
drh | 38c67c3 | 2010-09-08 02:30:27 +0000 | [diff] [blame] | 122 | ** We support that for legacy. |
drh | e5e7a90 | 2007-10-01 17:47:00 +0000 | [diff] [blame] | 123 | */ |
| 124 | #if !defined(SQLITE_THREADSAFE) |
drh | d16d0bc | 2013-04-16 18:24:34 +0000 | [diff] [blame] | 125 | # if defined(THREADSAFE) |
| 126 | # define SQLITE_THREADSAFE THREADSAFE |
| 127 | # else |
| 128 | # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ |
| 129 | # endif |
drh | e5e7a90 | 2007-10-01 17:47:00 +0000 | [diff] [blame] | 130 | #endif |
| 131 | |
drh | 6708061 | 2007-10-01 14:30:14 +0000 | [diff] [blame] | 132 | /* |
drh | cb15f35 | 2011-12-23 01:04:17 +0000 | [diff] [blame] | 133 | ** Powersafe overwrite is on by default. But can be turned off using |
| 134 | ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. |
| 135 | */ |
| 136 | #ifndef SQLITE_POWERSAFE_OVERWRITE |
| 137 | # define SQLITE_POWERSAFE_OVERWRITE 1 |
| 138 | #endif |
| 139 | |
| 140 | /* |
danielk1977 | 0a732f5 | 2008-09-04 17:17:38 +0000 | [diff] [blame] | 141 | ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1. |
| 142 | ** It determines whether or not the features related to |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 143 | ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can |
danielk1977 | 0a732f5 | 2008-09-04 17:17:38 +0000 | [diff] [blame] | 144 | ** be overridden at runtime using the sqlite3_config() API. |
| 145 | */ |
| 146 | #if !defined(SQLITE_DEFAULT_MEMSTATUS) |
| 147 | # define SQLITE_DEFAULT_MEMSTATUS 1 |
| 148 | #endif |
| 149 | |
| 150 | /* |
drh | 0d18020 | 2008-02-14 23:26:56 +0000 | [diff] [blame] | 151 | ** Exactly one of the following macros must be defined in order to |
| 152 | ** specify which memory allocation subsystem to use. |
| 153 | ** |
| 154 | ** SQLITE_SYSTEM_MALLOC // Use normal system malloc() |
mistachkin | 1b186a9 | 2011-08-24 16:13:57 +0000 | [diff] [blame] | 155 | ** SQLITE_WIN32_MALLOC // Use Win32 native heap API |
drh | d1b0afc | 2012-06-21 14:25:17 +0000 | [diff] [blame] | 156 | ** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails |
drh | 0d18020 | 2008-02-14 23:26:56 +0000 | [diff] [blame] | 157 | ** SQLITE_MEMDEBUG // Debugging version of system malloc() |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 158 | ** |
mistachkin | 753c544 | 2011-08-25 02:02:25 +0000 | [diff] [blame] | 159 | ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the |
| 160 | ** assert() macro is enabled, each call into the Win32 native heap subsystem |
| 161 | ** will cause HeapValidate to be called. If heap validation should fail, an |
| 162 | ** assertion will be triggered. |
| 163 | ** |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 164 | ** (Historical note: There used to be several other options, but we've |
drh | 9d56acd | 2011-09-19 20:56:59 +0000 | [diff] [blame] | 165 | ** pared it down to just these three.) |
drh | 0d18020 | 2008-02-14 23:26:56 +0000 | [diff] [blame] | 166 | ** |
| 167 | ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as |
| 168 | ** the default. |
| 169 | */ |
drh | d1b0afc | 2012-06-21 14:25:17 +0000 | [diff] [blame] | 170 | #if defined(SQLITE_SYSTEM_MALLOC) \ |
| 171 | + defined(SQLITE_WIN32_MALLOC) \ |
| 172 | + defined(SQLITE_ZERO_MALLOC) \ |
| 173 | + defined(SQLITE_MEMDEBUG)>1 |
| 174 | # error "Two or more of the following compile-time configuration options\ |
mistachkin | 20b1ff0 | 2012-06-21 15:12:30 +0000 | [diff] [blame] | 175 | are defined but at most one is allowed:\ |
drh | d1b0afc | 2012-06-21 14:25:17 +0000 | [diff] [blame] | 176 | SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ |
| 177 | SQLITE_ZERO_MALLOC" |
drh | 0d18020 | 2008-02-14 23:26:56 +0000 | [diff] [blame] | 178 | #endif |
drh | d1b0afc | 2012-06-21 14:25:17 +0000 | [diff] [blame] | 179 | #if defined(SQLITE_SYSTEM_MALLOC) \ |
| 180 | + defined(SQLITE_WIN32_MALLOC) \ |
| 181 | + defined(SQLITE_ZERO_MALLOC) \ |
| 182 | + defined(SQLITE_MEMDEBUG)==0 |
drh | 0d18020 | 2008-02-14 23:26:56 +0000 | [diff] [blame] | 183 | # define SQLITE_SYSTEM_MALLOC 1 |
| 184 | #endif |
| 185 | |
| 186 | /* |
drh | 8a1e594 | 2009-04-28 15:43:45 +0000 | [diff] [blame] | 187 | ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the |
drh | eee4c8c | 2008-02-18 22:24:57 +0000 | [diff] [blame] | 188 | ** sizes of memory allocations below this value where possible. |
| 189 | */ |
drh | 8a1e594 | 2009-04-28 15:43:45 +0000 | [diff] [blame] | 190 | #if !defined(SQLITE_MALLOC_SOFT_LIMIT) |
drh | eee4c8c | 2008-02-18 22:24:57 +0000 | [diff] [blame] | 191 | # define SQLITE_MALLOC_SOFT_LIMIT 1024 |
| 192 | #endif |
| 193 | |
| 194 | /* |
drh | 6708061 | 2007-10-01 14:30:14 +0000 | [diff] [blame] | 195 | ** We need to define _XOPEN_SOURCE as follows in order to enable |
drh | 40b521f | 2013-05-24 12:47:26 +0000 | [diff] [blame] | 196 | ** recursive mutexes on most Unix systems and fchmod() on OpenBSD. |
| 197 | ** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit |
| 198 | ** it. |
drh | 6708061 | 2007-10-01 14:30:14 +0000 | [diff] [blame] | 199 | */ |
drh | 40b521f | 2013-05-24 12:47:26 +0000 | [diff] [blame] | 200 | #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) |
| 201 | # define _XOPEN_SOURCE 600 |
drh | 6708061 | 2007-10-01 14:30:14 +0000 | [diff] [blame] | 202 | #endif |
danielk1977 | e302663 | 2004-06-22 11:29:02 +0000 | [diff] [blame] | 203 | |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 204 | /* |
| 205 | ** The TCL headers are only needed when compiling the TCL bindings. |
| 206 | */ |
drh | 4f0c587 | 2007-03-26 22:05:01 +0000 | [diff] [blame] | 207 | #if defined(SQLITE_TCL) || defined(TCLSH) |
| 208 | # include <tcl.h> |
drh | 824d7c1 | 2006-01-06 12:03:19 +0000 | [diff] [blame] | 209 | #endif |
| 210 | |
| 211 | /* |
drh | 1b28b89 | 2012-05-29 19:25:20 +0000 | [diff] [blame] | 212 | ** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that |
| 213 | ** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true, |
| 214 | ** make it true by defining or undefining NDEBUG. |
| 215 | ** |
| 216 | ** Setting NDEBUG makes the code smaller and run faster by disabling the |
| 217 | ** number assert() statements in the code. So we want the default action |
| 218 | ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG |
| 219 | ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out |
drh | 4b529d9 | 2005-09-13 00:00:00 +0000 | [diff] [blame] | 220 | ** feature. |
| 221 | */ |
danielk1977 | 771151b | 2006-01-17 13:21:40 +0000 | [diff] [blame] | 222 | #if !defined(NDEBUG) && !defined(SQLITE_DEBUG) |
drh | 4b529d9 | 2005-09-13 00:00:00 +0000 | [diff] [blame] | 223 | # define NDEBUG 1 |
| 224 | #endif |
drh | 1b28b89 | 2012-05-29 19:25:20 +0000 | [diff] [blame] | 225 | #if defined(NDEBUG) && defined(SQLITE_DEBUG) |
| 226 | # undef NDEBUG |
| 227 | #endif |
drh | 4b529d9 | 2005-09-13 00:00:00 +0000 | [diff] [blame] | 228 | |
drh | 6402250 | 2009-01-09 14:11:04 +0000 | [diff] [blame] | 229 | /* |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 230 | ** The testcase() macro is used to aid in coverage testing. When |
| 231 | ** doing coverage testing, the condition inside the argument to |
| 232 | ** testcase() must be evaluated both true and false in order to |
| 233 | ** get full branch coverage. The testcase() macro is inserted |
| 234 | ** to help ensure adequate test coverage in places where simple |
| 235 | ** condition/decision coverage is inadequate. For example, testcase() |
| 236 | ** can be used to make sure boundary values are tested. For |
| 237 | ** bitmask tests, testcase() can be used to make sure each bit |
| 238 | ** is significant and used at least once. On switch statements |
| 239 | ** where multiple cases go to the same block of code, testcase() |
| 240 | ** can insure that all cases are evaluated. |
| 241 | ** |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 242 | */ |
| 243 | #ifdef SQLITE_COVERAGE_TEST |
| 244 | void sqlite3Coverage(int); |
| 245 | # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 246 | #else |
| 247 | # define testcase(X) |
drh | 8f941bc | 2009-01-14 23:03:40 +0000 | [diff] [blame] | 248 | #endif |
| 249 | |
| 250 | /* |
| 251 | ** The TESTONLY macro is used to enclose variable declarations or |
| 252 | ** other bits of code that are needed to support the arguments |
| 253 | ** within testcase() and assert() macros. |
| 254 | */ |
| 255 | #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) |
| 256 | # define TESTONLY(X) X |
| 257 | #else |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 258 | # define TESTONLY(X) |
| 259 | #endif |
| 260 | |
| 261 | /* |
drh | 6149526 | 2009-04-22 15:32:59 +0000 | [diff] [blame] | 262 | ** Sometimes we need a small amount of code such as a variable initialization |
| 263 | ** to setup for a later assert() statement. We do not want this code to |
| 264 | ** appear when assert() is disabled. The following macro is therefore |
| 265 | ** used to contain that setup code. The "VVA" acronym stands for |
| 266 | ** "Verification, Validation, and Accreditation". In other words, the |
| 267 | ** code within VVA_ONLY() will only run during verification processes. |
| 268 | */ |
| 269 | #ifndef NDEBUG |
| 270 | # define VVA_ONLY(X) X |
| 271 | #else |
| 272 | # define VVA_ONLY(X) |
| 273 | #endif |
| 274 | |
| 275 | /* |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 276 | ** The ALWAYS and NEVER macros surround boolean expressions which |
| 277 | ** are intended to always be true or false, respectively. Such |
| 278 | ** expressions could be omitted from the code completely. But they |
| 279 | ** are included in a few cases in order to enhance the resilience |
| 280 | ** of SQLite to unexpected behavior - to make the code "self-healing" |
| 281 | ** or "ductile" rather than being "brittle" and crashing at the first |
| 282 | ** hint of unplanned behavior. |
| 283 | ** |
| 284 | ** In other words, ALWAYS and NEVER are added for defensive code. |
| 285 | ** |
| 286 | ** When doing coverage testing ALWAYS and NEVER are hard-coded to |
| 287 | ** be true and false so that the unreachable code then specify will |
| 288 | ** not be counted as untested code. |
| 289 | */ |
| 290 | #if defined(SQLITE_COVERAGE_TEST) |
| 291 | # define ALWAYS(X) (1) |
| 292 | # define NEVER(X) (0) |
| 293 | #elif !defined(NDEBUG) |
drh | 2de80f4 | 2009-06-24 10:26:32 +0000 | [diff] [blame] | 294 | # define ALWAYS(X) ((X)?1:(assert(0),0)) |
| 295 | # define NEVER(X) ((X)?(assert(0),1):0) |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 296 | #else |
| 297 | # define ALWAYS(X) (X) |
| 298 | # define NEVER(X) (X) |
| 299 | #endif |
| 300 | |
| 301 | /* |
drh | 3e8e7ec | 2010-07-07 13:43:19 +0000 | [diff] [blame] | 302 | ** Return true (non-zero) if the input is a integer that is too large |
| 303 | ** to fit in 32-bits. This macro is used inside of various testcase() |
| 304 | ** macros to verify that we have tested SQLite for large-file support. |
| 305 | */ |
dan | b31a6af | 2010-07-14 06:20:26 +0000 | [diff] [blame] | 306 | #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) |
drh | 3e8e7ec | 2010-07-07 13:43:19 +0000 | [diff] [blame] | 307 | |
| 308 | /* |
drh | 47c3b3e | 2009-01-10 16:15:20 +0000 | [diff] [blame] | 309 | ** The macro unlikely() is a hint that surrounds a boolean |
| 310 | ** expression that is usually false. Macro likely() surrounds |
| 311 | ** a boolean expression that is usually true. GCC is able to |
| 312 | ** use these hints to generate better code, sometimes. |
| 313 | */ |
| 314 | #if defined(__GNUC__) && 0 |
| 315 | # define likely(X) __builtin_expect((X),1) |
| 316 | # define unlikely(X) __builtin_expect((X),0) |
| 317 | #else |
| 318 | # define likely(X) !!(X) |
| 319 | # define unlikely(X) !!(X) |
| 320 | #endif |
| 321 | |
drh | 1d482dd | 2004-05-31 18:23:07 +0000 | [diff] [blame] | 322 | #include "sqlite3.h" |
drh | beae319 | 2001-09-22 18:12:08 +0000 | [diff] [blame] | 323 | #include "hash.h" |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 324 | #include "parse.h" |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 325 | #include <stdio.h> |
| 326 | #include <stdlib.h> |
| 327 | #include <string.h> |
| 328 | #include <assert.h> |
drh | 52370e2 | 2005-01-21 21:31:40 +0000 | [diff] [blame] | 329 | #include <stddef.h> |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 330 | |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 331 | /* |
drh | b37df7b | 2005-10-13 02:09:49 +0000 | [diff] [blame] | 332 | ** If compiling for a processor that lacks floating point support, |
| 333 | ** substitute integer for floating-point |
| 334 | */ |
| 335 | #ifdef SQLITE_OMIT_FLOATING_POINT |
| 336 | # define double sqlite_int64 |
drh | 8b307fb | 2010-04-06 15:57:05 +0000 | [diff] [blame] | 337 | # define float sqlite_int64 |
drh | b37df7b | 2005-10-13 02:09:49 +0000 | [diff] [blame] | 338 | # define LONGDOUBLE_TYPE sqlite_int64 |
drh | d116739 | 2006-01-23 13:00:35 +0000 | [diff] [blame] | 339 | # ifndef SQLITE_BIG_DBL |
drh | cdaca55 | 2009-08-20 13:45:07 +0000 | [diff] [blame] | 340 | # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) |
drh | d116739 | 2006-01-23 13:00:35 +0000 | [diff] [blame] | 341 | # endif |
drh | b37df7b | 2005-10-13 02:09:49 +0000 | [diff] [blame] | 342 | # define SQLITE_OMIT_DATETIME_FUNCS 1 |
| 343 | # define SQLITE_OMIT_TRACE 1 |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 344 | # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT |
drh | 0b3bf92 | 2009-06-15 20:45:34 +0000 | [diff] [blame] | 345 | # undef SQLITE_HAVE_ISNAN |
drh | b37df7b | 2005-10-13 02:09:49 +0000 | [diff] [blame] | 346 | #endif |
drh | d116739 | 2006-01-23 13:00:35 +0000 | [diff] [blame] | 347 | #ifndef SQLITE_BIG_DBL |
| 348 | # define SQLITE_BIG_DBL (1e99) |
| 349 | #endif |
drh | b37df7b | 2005-10-13 02:09:49 +0000 | [diff] [blame] | 350 | |
| 351 | /* |
danielk1977 | 53c0f74 | 2005-03-29 03:10:59 +0000 | [diff] [blame] | 352 | ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 |
| 353 | ** afterward. Having this macro allows us to cause the C compiler |
| 354 | ** to omit code used by TEMP tables without messy #ifndef statements. |
| 355 | */ |
| 356 | #ifdef SQLITE_OMIT_TEMPDB |
| 357 | #define OMIT_TEMPDB 1 |
| 358 | #else |
| 359 | #define OMIT_TEMPDB 0 |
| 360 | #endif |
| 361 | |
| 362 | /* |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 363 | ** The "file format" number is an integer that is incremented whenever |
| 364 | ** the VDBE-level file format changes. The following macros define the |
| 365 | ** the default file format for new databases and the maximum file format |
| 366 | ** that the library can read. |
| 367 | */ |
| 368 | #define SQLITE_MAX_FILE_FORMAT 4 |
| 369 | #ifndef SQLITE_DEFAULT_FILE_FORMAT |
drh | bf3f5f8 | 2011-11-07 13:05:23 +0000 | [diff] [blame] | 370 | # define SQLITE_DEFAULT_FILE_FORMAT 4 |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 371 | #endif |
| 372 | |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 373 | /* |
| 374 | ** Determine whether triggers are recursive by default. This can be |
| 375 | ** changed at run-time using a pragma. |
| 376 | */ |
dan | 5bde73c | 2009-09-01 17:11:07 +0000 | [diff] [blame] | 377 | #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS |
| 378 | # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 |
| 379 | #endif |
| 380 | |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 381 | /* |
danielk1977 | b06a0b6 | 2008-06-26 10:54:12 +0000 | [diff] [blame] | 382 | ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified |
drh | 49766d6 | 2005-01-08 18:42:28 +0000 | [diff] [blame] | 383 | ** on the command-line |
| 384 | */ |
danielk1977 | b06a0b6 | 2008-06-26 10:54:12 +0000 | [diff] [blame] | 385 | #ifndef SQLITE_TEMP_STORE |
| 386 | # define SQLITE_TEMP_STORE 1 |
drh | d16d0bc | 2013-04-16 18:24:34 +0000 | [diff] [blame] | 387 | # define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */ |
drh | 49766d6 | 2005-01-08 18:42:28 +0000 | [diff] [blame] | 388 | #endif |
| 389 | |
| 390 | /* |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 391 | ** GCC does not define the offsetof() macro so we'll have to do it |
| 392 | ** ourselves. |
| 393 | */ |
| 394 | #ifndef offsetof |
| 395 | #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) |
| 396 | #endif |
| 397 | |
| 398 | /* |
drh | 9b8f447 | 2006-04-04 01:54:55 +0000 | [diff] [blame] | 399 | ** Check to see if this machine uses EBCDIC. (Yes, believe it or |
| 400 | ** not, there are still machines out there that use EBCDIC.) |
| 401 | */ |
| 402 | #if 'A' == '\301' |
| 403 | # define SQLITE_EBCDIC 1 |
| 404 | #else |
| 405 | # define SQLITE_ASCII 1 |
| 406 | #endif |
| 407 | |
| 408 | /* |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 409 | ** Integers of known sizes. These typedefs might change for architectures |
| 410 | ** where the sizes very. Preprocessor macros are available so that the |
| 411 | ** types can be conveniently redefined at compile-type. Like this: |
| 412 | ** |
| 413 | ** cc '-DUINTPTR_TYPE=long long int' ... |
drh | 41a2b48 | 2001-01-20 19:52:49 +0000 | [diff] [blame] | 414 | */ |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 415 | #ifndef UINT32_TYPE |
mlcreech | dda5b68 | 2008-03-14 13:02:08 +0000 | [diff] [blame] | 416 | # ifdef HAVE_UINT32_T |
| 417 | # define UINT32_TYPE uint32_t |
| 418 | # else |
| 419 | # define UINT32_TYPE unsigned int |
| 420 | # endif |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 421 | #endif |
| 422 | #ifndef UINT16_TYPE |
mlcreech | dda5b68 | 2008-03-14 13:02:08 +0000 | [diff] [blame] | 423 | # ifdef HAVE_UINT16_T |
| 424 | # define UINT16_TYPE uint16_t |
| 425 | # else |
| 426 | # define UINT16_TYPE unsigned short int |
| 427 | # endif |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 428 | #endif |
drh | 939a16d | 2004-07-15 13:37:22 +0000 | [diff] [blame] | 429 | #ifndef INT16_TYPE |
mlcreech | dda5b68 | 2008-03-14 13:02:08 +0000 | [diff] [blame] | 430 | # ifdef HAVE_INT16_T |
| 431 | # define INT16_TYPE int16_t |
| 432 | # else |
| 433 | # define INT16_TYPE short int |
| 434 | # endif |
drh | 939a16d | 2004-07-15 13:37:22 +0000 | [diff] [blame] | 435 | #endif |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 436 | #ifndef UINT8_TYPE |
mlcreech | dda5b68 | 2008-03-14 13:02:08 +0000 | [diff] [blame] | 437 | # ifdef HAVE_UINT8_T |
| 438 | # define UINT8_TYPE uint8_t |
| 439 | # else |
| 440 | # define UINT8_TYPE unsigned char |
| 441 | # endif |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 442 | #endif |
drh | 905793e | 2004-02-21 13:31:09 +0000 | [diff] [blame] | 443 | #ifndef INT8_TYPE |
mlcreech | dda5b68 | 2008-03-14 13:02:08 +0000 | [diff] [blame] | 444 | # ifdef HAVE_INT8_T |
| 445 | # define INT8_TYPE int8_t |
| 446 | # else |
| 447 | # define INT8_TYPE signed char |
| 448 | # endif |
drh | 905793e | 2004-02-21 13:31:09 +0000 | [diff] [blame] | 449 | #endif |
drh | efad999 | 2004-06-22 12:13:55 +0000 | [diff] [blame] | 450 | #ifndef LONGDOUBLE_TYPE |
| 451 | # define LONGDOUBLE_TYPE long double |
| 452 | #endif |
drh | efad999 | 2004-06-22 12:13:55 +0000 | [diff] [blame] | 453 | typedef sqlite_int64 i64; /* 8-byte signed integer */ |
drh | 27436af | 2006-03-28 23:57:17 +0000 | [diff] [blame] | 454 | typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 455 | typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ |
| 456 | typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ |
drh | 939a16d | 2004-07-15 13:37:22 +0000 | [diff] [blame] | 457 | typedef INT16_TYPE i16; /* 2-byte signed integer */ |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 458 | typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 459 | typedef INT8_TYPE i8; /* 1-byte signed integer */ |
drh | 5a2c2c2 | 2001-11-21 02:21:11 +0000 | [diff] [blame] | 460 | |
| 461 | /* |
drh | 35cd643 | 2009-06-05 14:17:21 +0000 | [diff] [blame] | 462 | ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value |
| 463 | ** that can be stored in a u32 without loss of data. The value |
| 464 | ** is 0x00000000ffffffff. But because of quirks of some compilers, we |
| 465 | ** have to specify the value in the less intuitive manner shown: |
| 466 | */ |
| 467 | #define SQLITE_MAX_U32 ((((u64)1)<<32)-1) |
| 468 | |
| 469 | /* |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 470 | ** The datatype used to store estimates of the number of rows in a |
| 471 | ** table or index. This is an unsigned integer type. For 99.9% of |
| 472 | ** the world, a 32-bit integer is sufficient. But a 64-bit integer |
| 473 | ** can be used at compile-time if desired. |
| 474 | */ |
| 475 | #ifdef SQLITE_64BIT_STATS |
| 476 | typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */ |
| 477 | #else |
| 478 | typedef u32 tRowcnt; /* 32-bit is the default */ |
| 479 | #endif |
| 480 | |
| 481 | /* |
drh | bbd42a6 | 2004-05-22 17:41:58 +0000 | [diff] [blame] | 482 | ** Macros to determine whether the machine is big or little endian, |
| 483 | ** evaluated at runtime. |
| 484 | */ |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 485 | #ifdef SQLITE_AMALGAMATION |
drh | b3190c1 | 2008-12-08 21:37:14 +0000 | [diff] [blame] | 486 | const int sqlite3one = 1; |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 487 | #else |
drh | bbd42a6 | 2004-05-22 17:41:58 +0000 | [diff] [blame] | 488 | extern const int sqlite3one; |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 489 | #endif |
drh | 189077f | 2008-10-11 18:11:21 +0000 | [diff] [blame] | 490 | #if defined(i386) || defined(__i386__) || defined(_M_IX86)\ |
| 491 | || defined(__x86_64) || defined(__x86_64__) |
drh | 38def05 | 2007-03-31 15:27:59 +0000 | [diff] [blame] | 492 | # define SQLITE_BIGENDIAN 0 |
| 493 | # define SQLITE_LITTLEENDIAN 1 |
| 494 | # define SQLITE_UTF16NATIVE SQLITE_UTF16LE |
| 495 | #else |
| 496 | # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) |
| 497 | # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) |
| 498 | # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) |
| 499 | #endif |
drh | bbd42a6 | 2004-05-22 17:41:58 +0000 | [diff] [blame] | 500 | |
| 501 | /* |
drh | 0f05035 | 2008-05-09 18:03:13 +0000 | [diff] [blame] | 502 | ** Constants for the largest and smallest possible 64-bit signed integers. |
| 503 | ** These macros are designed to work correctly on both 32-bit and 64-bit |
| 504 | ** compilers. |
| 505 | */ |
| 506 | #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) |
| 507 | #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) |
| 508 | |
danielk1977 | be22965 | 2009-03-20 14:18:51 +0000 | [diff] [blame] | 509 | /* |
| 510 | ** Round up a number to the next larger multiple of 8. This is used |
| 511 | ** to force 8-byte alignment on 64-bit architectures. |
| 512 | */ |
danielk1977 | bc73971 | 2009-03-23 04:33:32 +0000 | [diff] [blame] | 513 | #define ROUND8(x) (((x)+7)&~7) |
| 514 | |
| 515 | /* |
| 516 | ** Round down to the nearest multiple of 8 |
| 517 | */ |
| 518 | #define ROUNDDOWN8(x) ((x)&~7) |
danielk1977 | be22965 | 2009-03-20 14:18:51 +0000 | [diff] [blame] | 519 | |
drh | 0f05035 | 2008-05-09 18:03:13 +0000 | [diff] [blame] | 520 | /* |
drh | 8e14c59 | 2009-12-04 23:10:12 +0000 | [diff] [blame] | 521 | ** Assert that the pointer X is aligned to an 8-byte boundary. This |
| 522 | ** macro is used only within assert() to verify that the code gets |
| 523 | ** all alignment restrictions correct. |
| 524 | ** |
| 525 | ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the |
| 526 | ** underlying malloc() implemention might return us 4-byte aligned |
| 527 | ** pointers. In that case, only verify 4-byte alignment. |
drh | ea598cb | 2009-04-05 12:22:08 +0000 | [diff] [blame] | 528 | */ |
drh | 8e14c59 | 2009-12-04 23:10:12 +0000 | [diff] [blame] | 529 | #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC |
| 530 | # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) |
| 531 | #else |
| 532 | # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) |
| 533 | #endif |
drh | ea598cb | 2009-04-05 12:22:08 +0000 | [diff] [blame] | 534 | |
drh | 188d488 | 2013-04-08 20:47:49 +0000 | [diff] [blame] | 535 | /* |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 536 | ** Disable MMAP on platforms where it is known to not work |
drh | 188d488 | 2013-04-08 20:47:49 +0000 | [diff] [blame] | 537 | */ |
| 538 | #if defined(__OpenBSD__) || defined(__QNXNTO__) |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 539 | # undef SQLITE_MAX_MMAP_SIZE |
| 540 | # define SQLITE_MAX_MMAP_SIZE 0 |
drh | 188d488 | 2013-04-08 20:47:49 +0000 | [diff] [blame] | 541 | #endif |
| 542 | |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 543 | /* |
| 544 | ** Default maximum size of memory used by memory-mapped I/O in the VFS |
| 545 | */ |
| 546 | #ifdef __APPLE__ |
| 547 | # include <TargetConditionals.h> |
| 548 | # if TARGET_OS_IPHONE |
| 549 | # undef SQLITE_MAX_MMAP_SIZE |
| 550 | # define SQLITE_MAX_MMAP_SIZE 0 |
| 551 | # endif |
| 552 | #endif |
| 553 | #ifndef SQLITE_MAX_MMAP_SIZE |
| 554 | # if defined(__linux__) \ |
| 555 | || defined(_WIN32) \ |
| 556 | || (defined(__APPLE__) && defined(__MACH__)) \ |
| 557 | || defined(__sun) |
drh | 2bba8c2 | 2013-04-26 12:08:29 +0000 | [diff] [blame] | 558 | # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */ |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 559 | # else |
| 560 | # define SQLITE_MAX_MMAP_SIZE 0 |
| 561 | # endif |
drh | d16d0bc | 2013-04-16 18:24:34 +0000 | [diff] [blame] | 562 | # define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */ |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 563 | #endif |
| 564 | |
| 565 | /* |
| 566 | ** The default MMAP_SIZE is zero on all platforms. Or, even if a larger |
| 567 | ** default MMAP_SIZE is specified at compile-time, make sure that it does |
| 568 | ** not exceed the maximum mmap size. |
| 569 | */ |
| 570 | #ifndef SQLITE_DEFAULT_MMAP_SIZE |
| 571 | # define SQLITE_DEFAULT_MMAP_SIZE 0 |
drh | d16d0bc | 2013-04-16 18:24:34 +0000 | [diff] [blame] | 572 | # define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */ |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 573 | #endif |
| 574 | #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE |
| 575 | # undef SQLITE_DEFAULT_MMAP_SIZE |
| 576 | # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE |
| 577 | #endif |
drh | e7b34707 | 2009-06-01 18:18:20 +0000 | [diff] [blame] | 578 | |
drh | ea598cb | 2009-04-05 12:22:08 +0000 | [diff] [blame] | 579 | /* |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 580 | ** An instance of the following structure is used to store the busy-handler |
| 581 | ** callback for a given sqlite handle. |
| 582 | ** |
| 583 | ** The sqlite.busyHandler member of the sqlite struct contains the busy |
| 584 | ** callback for the database handle. Each pager opened via the sqlite |
| 585 | ** handle is passed a pointer to sqlite.busyHandler. The busy-handler |
| 586 | ** callback is currently invoked only from within pager.c. |
| 587 | */ |
| 588 | typedef struct BusyHandler BusyHandler; |
| 589 | struct BusyHandler { |
| 590 | int (*xFunc)(void *,int); /* The busy callback */ |
| 591 | void *pArg; /* First arg to busy callback */ |
drh | a4afb65 | 2005-07-09 02:16:02 +0000 | [diff] [blame] | 592 | int nBusy; /* Incremented with each busy call */ |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 593 | }; |
| 594 | |
| 595 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 596 | ** Name of the master database table. The master database table |
| 597 | ** is a special table that holds the names and attributes of all |
| 598 | ** user tables and indices. |
| 599 | */ |
drh | e0bc404 | 2002-06-25 01:09:11 +0000 | [diff] [blame] | 600 | #define MASTER_NAME "sqlite_master" |
| 601 | #define TEMP_MASTER_NAME "sqlite_temp_master" |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 602 | |
| 603 | /* |
danielk1977 | 8e15081 | 2004-05-10 01:17:37 +0000 | [diff] [blame] | 604 | ** The root-page of the master database table. |
| 605 | */ |
| 606 | #define MASTER_ROOT 1 |
| 607 | |
| 608 | /* |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 609 | ** The name of the schema table. |
| 610 | */ |
danielk1977 | 53c0f74 | 2005-03-29 03:10:59 +0000 | [diff] [blame] | 611 | #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 612 | |
| 613 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 614 | ** A convenience macro that returns the number of elements in |
| 615 | ** an array. |
| 616 | */ |
danielk1977 | 2343297 | 2008-11-17 16:42:00 +0000 | [diff] [blame] | 617 | #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 618 | |
| 619 | /* |
drh | 7a5bcc0 | 2013-01-16 17:08:58 +0000 | [diff] [blame] | 620 | ** Determine if the argument is a power of two |
| 621 | */ |
| 622 | #define IsPowerOfTwo(X) (((X)&((X)-1))==0) |
| 623 | |
| 624 | /* |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 625 | ** The following value as a destructor means to use sqlite3DbFree(). |
drh | aa538a5 | 2012-01-19 16:57:16 +0000 | [diff] [blame] | 626 | ** The sqlite3DbFree() routine requires two parameters instead of the |
| 627 | ** one parameter that destructors normally want. So we have to introduce |
| 628 | ** this magic value that the code knows to handle differently. Any |
| 629 | ** pointer will work here as long as it is distinct from SQLITE_STATIC |
| 630 | ** and SQLITE_TRANSIENT. |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 631 | */ |
drh | aa538a5 | 2012-01-19 16:57:16 +0000 | [diff] [blame] | 632 | #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize) |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 633 | |
drh | 78f82d1 | 2008-09-02 00:52:52 +0000 | [diff] [blame] | 634 | /* |
| 635 | ** When SQLITE_OMIT_WSD is defined, it means that the target platform does |
| 636 | ** not support Writable Static Data (WSD) such as global and static variables. |
| 637 | ** All variables must either be on the stack or dynamically allocated from |
| 638 | ** the heap. When WSD is unsupported, the variable declarations scattered |
| 639 | ** throughout the SQLite code must become constants instead. The SQLITE_WSD |
| 640 | ** macro is used for this purpose. And instead of referencing the variable |
| 641 | ** directly, we use its constant as a key to lookup the run-time allocated |
| 642 | ** buffer that holds real variable. The constant is also the initializer |
| 643 | ** for the run-time allocated buffer. |
| 644 | ** |
shane | 2479de3 | 2008-11-10 18:05:35 +0000 | [diff] [blame] | 645 | ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL |
drh | 78f82d1 | 2008-09-02 00:52:52 +0000 | [diff] [blame] | 646 | ** macros become no-ops and have zero performance impact. |
| 647 | */ |
danielk1977 | 075c23a | 2008-09-01 18:34:20 +0000 | [diff] [blame] | 648 | #ifdef SQLITE_OMIT_WSD |
| 649 | #define SQLITE_WSD const |
| 650 | #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) |
| 651 | #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) |
drh | d1d3848 | 2008-10-07 23:46:38 +0000 | [diff] [blame] | 652 | int sqlite3_wsd_init(int N, int J); |
| 653 | void *sqlite3_wsd_find(void *K, int L); |
danielk1977 | 075c23a | 2008-09-01 18:34:20 +0000 | [diff] [blame] | 654 | #else |
| 655 | #define SQLITE_WSD |
| 656 | #define GLOBAL(t,v) v |
| 657 | #define sqlite3GlobalConfig sqlite3Config |
| 658 | #endif |
| 659 | |
danielk1977 | f3d3c27 | 2008-11-19 16:52:44 +0000 | [diff] [blame] | 660 | /* |
| 661 | ** The following macros are used to suppress compiler warnings and to |
| 662 | ** make it clear to human readers when a function parameter is deliberately |
| 663 | ** left unused within the body of a function. This usually happens when |
| 664 | ** a function is called via a function pointer. For example the |
| 665 | ** implementation of an SQL aggregate step callback may not use the |
| 666 | ** parameter indicating the number of arguments passed to the aggregate, |
| 667 | ** if it knows that this is enforced elsewhere. |
| 668 | ** |
| 669 | ** When a function parameter is not used at all within the body of a function, |
| 670 | ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. |
| 671 | ** However, these macros may also be used to suppress warnings related to |
| 672 | ** parameters that may or may not be used depending on compilation options. |
| 673 | ** For example those parameters only used in assert() statements. In these |
| 674 | ** cases the parameters are named as per the usual conventions. |
| 675 | */ |
danielk1977 | 62c14b3 | 2008-11-19 09:05:26 +0000 | [diff] [blame] | 676 | #define UNUSED_PARAMETER(x) (void)(x) |
danielk1977 | f3d3c27 | 2008-11-19 16:52:44 +0000 | [diff] [blame] | 677 | #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) |
danielk1977 | 62c14b3 | 2008-11-19 09:05:26 +0000 | [diff] [blame] | 678 | |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 679 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 680 | ** Forward references to structures |
| 681 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 682 | typedef struct AggInfo AggInfo; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 683 | typedef struct AuthContext AuthContext; |
drh | 0b9f50d | 2009-06-23 20:28:53 +0000 | [diff] [blame] | 684 | typedef struct AutoincInfo AutoincInfo; |
drh | f5e7bb5 | 2008-02-18 14:47:33 +0000 | [diff] [blame] | 685 | typedef struct Bitvec Bitvec; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 686 | typedef struct CollSeq CollSeq; |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 687 | typedef struct Column Column; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 688 | typedef struct Db Db; |
danielk1977 | e501b89 | 2006-01-09 06:29:47 +0000 | [diff] [blame] | 689 | typedef struct Schema Schema; |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 690 | typedef struct Expr Expr; |
| 691 | typedef struct ExprList ExprList; |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 692 | typedef struct ExprSpan ExprSpan; |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 693 | typedef struct FKey FKey; |
dan | d2199f0 | 2010-08-27 17:48:52 +0000 | [diff] [blame] | 694 | typedef struct FuncDestructor FuncDestructor; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 695 | typedef struct FuncDef FuncDef; |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 696 | typedef struct FuncDefHash FuncDefHash; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 697 | typedef struct IdList IdList; |
| 698 | typedef struct Index Index; |
dan | 02fa469 | 2009-08-17 17:06:58 +0000 | [diff] [blame] | 699 | typedef struct IndexSample IndexSample; |
danielk1977 | 8d05984 | 2004-05-12 11:24:02 +0000 | [diff] [blame] | 700 | typedef struct KeyClass KeyClass; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 701 | typedef struct KeyInfo KeyInfo; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 702 | typedef struct Lookaside Lookaside; |
| 703 | typedef struct LookasideSlot LookasideSlot; |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 704 | typedef struct Module Module; |
drh | 626a879 | 2005-01-17 22:08:19 +0000 | [diff] [blame] | 705 | typedef struct NameContext NameContext; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 706 | typedef struct Parse Parse; |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 707 | typedef struct RowSet RowSet; |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 708 | typedef struct Savepoint Savepoint; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 709 | typedef struct Select Select; |
drh | 634d81d | 2012-09-20 15:41:31 +0000 | [diff] [blame] | 710 | typedef struct SelectDest SelectDest; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 711 | typedef struct SrcList SrcList; |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 712 | typedef struct StrAccum StrAccum; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 713 | typedef struct Table Table; |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 714 | typedef struct TableLock TableLock; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 715 | typedef struct Token Token; |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 716 | typedef struct Trigger Trigger; |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 717 | typedef struct TriggerPrg TriggerPrg; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 718 | typedef struct TriggerStep TriggerStep; |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 719 | typedef struct UnpackedRecord UnpackedRecord; |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 720 | typedef struct VTable VTable; |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 721 | typedef struct VtabCtx VtabCtx; |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 722 | typedef struct Walker Walker; |
drh | fe05af8 | 2005-07-21 03:14:59 +0000 | [diff] [blame] | 723 | typedef struct WhereInfo WhereInfo; |
| 724 | typedef struct WhereLevel WhereLevel; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 725 | |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 726 | /* |
| 727 | ** Defer sourcing vdbe.h and btree.h until after the "u8" and |
| 728 | ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque |
| 729 | ** pointer types (i.e. FuncDef) defined above. |
| 730 | */ |
| 731 | #include "btree.h" |
| 732 | #include "vdbe.h" |
| 733 | #include "pager.h" |
danielk1977 | 8c0a791 | 2008-08-20 14:49:23 +0000 | [diff] [blame] | 734 | #include "pcache.h" |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 735 | |
danielk1977 | 1cc5ed8 | 2007-05-16 17:28:43 +0000 | [diff] [blame] | 736 | #include "os.h" |
drh | c7ce76a | 2007-08-30 14:10:30 +0000 | [diff] [blame] | 737 | #include "mutex.h" |
danielk1977 | 1cc5ed8 | 2007-05-16 17:28:43 +0000 | [diff] [blame] | 738 | |
drh | eee4c8c | 2008-02-18 22:24:57 +0000 | [diff] [blame] | 739 | |
drh | 001bbcb | 2003-03-19 03:14:00 +0000 | [diff] [blame] | 740 | /* |
| 741 | ** Each database file to be accessed by the system is an instance |
| 742 | ** of the following structure. There are normally two of these structures |
| 743 | ** in the sqlite.aDb[] array. aDb[0] is the main database file and |
drh | a69d916 | 2003-04-17 22:57:53 +0000 | [diff] [blame] | 744 | ** aDb[1] is the database file used to hold temporary tables. Additional |
| 745 | ** databases may be attached. |
drh | 001bbcb | 2003-03-19 03:14:00 +0000 | [diff] [blame] | 746 | */ |
| 747 | struct Db { |
| 748 | char *zName; /* Name of this database */ |
| 749 | Btree *pBt; /* The B*Tree structure for this database file */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 750 | u8 safety_level; /* How aggressive at syncing data to disk */ |
danielk1977 | e501b89 | 2006-01-09 06:29:47 +0000 | [diff] [blame] | 751 | Schema *pSchema; /* Pointer to database schema (possibly shared) */ |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 752 | }; |
| 753 | |
| 754 | /* |
| 755 | ** An instance of the following structure stores a database schema. |
drh | 2120608 | 2011-04-04 18:22:02 +0000 | [diff] [blame] | 756 | ** |
| 757 | ** Most Schema objects are associated with a Btree. The exception is |
| 758 | ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing. |
| 759 | ** In shared cache mode, a single Schema object can be shared by multiple |
| 760 | ** Btrees that refer to the same underlying BtShared object. |
| 761 | ** |
| 762 | ** Schema objects are automatically deallocated when the last Btree that |
| 763 | ** references them is destroyed. The TEMP Schema is manually freed by |
| 764 | ** sqlite3_close(). |
| 765 | * |
| 766 | ** A thread must be holding a mutex on the corresponding Btree in order |
| 767 | ** to access Schema content. This implies that the thread must also be |
| 768 | ** holding a mutex on the sqlite3 connection pointer that owns the Btree. |
drh | 55a0959 | 2011-06-07 18:31:14 +0000 | [diff] [blame] | 769 | ** For a TEMP Schema, only the connection mutex is required. |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 770 | */ |
danielk1977 | e501b89 | 2006-01-09 06:29:47 +0000 | [diff] [blame] | 771 | struct Schema { |
drh | 001bbcb | 2003-03-19 03:14:00 +0000 | [diff] [blame] | 772 | int schema_cookie; /* Database schema version number for this file */ |
drh | c2a7555 | 2011-03-18 21:55:46 +0000 | [diff] [blame] | 773 | int iGeneration; /* Generation counter. Incremented with each change */ |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 774 | Hash tblHash; /* All tables indexed by name */ |
| 775 | Hash idxHash; /* All (named) indices indexed by name */ |
| 776 | Hash trigHash; /* All triggers indexed by name */ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 777 | Hash fkeyHash; /* All foreign keys by referenced table name */ |
drh | 4794f73 | 2004-11-05 17:17:50 +0000 | [diff] [blame] | 778 | Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 779 | u8 file_format; /* Schema format version for this file */ |
drh | 8079a0d | 2006-01-12 17:20:50 +0000 | [diff] [blame] | 780 | u8 enc; /* Text encoding used by this database */ |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 781 | u16 flags; /* Flags associated with this schema */ |
danielk1977 | 14db266 | 2006-01-09 16:12:04 +0000 | [diff] [blame] | 782 | int cache_size; /* Number of pages to use in the cache */ |
drh | 001bbcb | 2003-03-19 03:14:00 +0000 | [diff] [blame] | 783 | }; |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 784 | |
| 785 | /* |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 786 | ** These macros can be used to test, set, or clear bits in the |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 787 | ** Db.pSchema->flags field. |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 788 | */ |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 789 | #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) |
| 790 | #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) |
| 791 | #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) |
| 792 | #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P) |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 793 | |
| 794 | /* |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 795 | ** Allowed values for the DB.pSchema->flags field. |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 796 | ** |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 797 | ** The DB_SchemaLoaded flag is set after the database schema has been |
| 798 | ** read into internal hash tables. |
| 799 | ** |
| 800 | ** DB_UnresetViews means that one or more views have column names that |
| 801 | ** have been filled out. If the schema changes, these column names might |
| 802 | ** changes and so the view will need to be reset. |
| 803 | */ |
drh | 124b27e | 2004-06-19 16:06:10 +0000 | [diff] [blame] | 804 | #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ |
| 805 | #define DB_UnresetViews 0x0002 /* Some views have defined column names */ |
danielk1977 | b82e7ed | 2006-01-11 14:09:31 +0000 | [diff] [blame] | 806 | #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 807 | |
drh | caa639f | 2008-03-20 00:32:20 +0000 | [diff] [blame] | 808 | /* |
| 809 | ** The number of different kinds of things that can be limited |
| 810 | ** using the sqlite3_limit() interface. |
| 811 | */ |
drh | 417168a | 2009-09-07 18:14:02 +0000 | [diff] [blame] | 812 | #define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1) |
drh | 8bf8dc9 | 2003-05-17 17:35:10 +0000 | [diff] [blame] | 813 | |
| 814 | /* |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 815 | ** Lookaside malloc is a set of fixed-size buffers that can be used |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 816 | ** to satisfy small transient memory allocation requests for objects |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 817 | ** associated with a particular database connection. The use of |
| 818 | ** lookaside malloc provides a significant performance enhancement |
| 819 | ** (approx 10%) by avoiding numerous malloc/free requests while parsing |
| 820 | ** SQL statements. |
| 821 | ** |
| 822 | ** The Lookaside structure holds configuration information about the |
| 823 | ** lookaside malloc subsystem. Each available memory allocation in |
| 824 | ** the lookaside subsystem is stored on a linked list of LookasideSlot |
| 825 | ** objects. |
drh | d9da78a | 2009-03-24 15:08:09 +0000 | [diff] [blame] | 826 | ** |
| 827 | ** Lookaside allocations are only allowed for objects that are associated |
| 828 | ** with a particular database connection. Hence, schema information cannot |
| 829 | ** be stored in lookaside because in shared cache mode the schema information |
| 830 | ** is shared by multiple database connections. Therefore, while parsing |
| 831 | ** schema information, the Lookaside.bEnabled flag is cleared so that |
| 832 | ** lookaside allocations are not used to construct the schema objects. |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 833 | */ |
| 834 | struct Lookaside { |
| 835 | u16 sz; /* Size of each buffer in bytes */ |
drh | d9da78a | 2009-03-24 15:08:09 +0000 | [diff] [blame] | 836 | u8 bEnabled; /* False to disable new lookaside allocations */ |
drh | e9d1c72 | 2008-08-04 20:13:26 +0000 | [diff] [blame] | 837 | u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 838 | int nOut; /* Number of buffers currently checked out */ |
| 839 | int mxOut; /* Highwater mark for nOut */ |
drh | 0b12e7f | 2010-12-20 15:51:58 +0000 | [diff] [blame] | 840 | int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 841 | LookasideSlot *pFree; /* List of available buffers */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 842 | void *pStart; /* First byte of available memory space */ |
| 843 | void *pEnd; /* First byte past end of available space */ |
| 844 | }; |
| 845 | struct LookasideSlot { |
| 846 | LookasideSlot *pNext; /* Next buffer in the list of free buffers */ |
| 847 | }; |
| 848 | |
| 849 | /* |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 850 | ** A hash table for function definitions. |
| 851 | ** |
| 852 | ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. |
| 853 | ** Collisions are on the FuncDef.pHash chain. |
| 854 | */ |
| 855 | struct FuncDefHash { |
| 856 | FuncDef *a[23]; /* Hash table for functions */ |
| 857 | }; |
| 858 | |
| 859 | /* |
drh | a2460e0 | 2010-01-14 00:39:26 +0000 | [diff] [blame] | 860 | ** Each database connection is an instance of the following structure. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 861 | */ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 862 | struct sqlite3 { |
drh | 90f6a5b | 2007-08-15 13:04:54 +0000 | [diff] [blame] | 863 | sqlite3_vfs *pVfs; /* OS Interface */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 864 | struct Vdbe *pVdbe; /* List of active virtual machines */ |
| 865 | CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ |
| 866 | sqlite3_mutex *mutex; /* Connection mutex */ |
drh | 001bbcb | 2003-03-19 03:14:00 +0000 | [diff] [blame] | 867 | Db *aDb; /* All backends */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 868 | int nDb; /* Number of backends currently in use */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 869 | int flags; /* Miscellaneous flags. See below */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 870 | i64 lastRowid; /* ROWID of most recent insert (see above) */ |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 871 | i64 szMmap; /* Default mmap_size setting */ |
drh | 522c26f | 2011-05-07 14:40:29 +0000 | [diff] [blame] | 872 | unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 873 | int errCode; /* Most recent error code (SQLITE_*) */ |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 874 | int errMask; /* & result codes with this before returning */ |
drh | a575967 | 2012-10-30 14:39:12 +0000 | [diff] [blame] | 875 | u16 dbOptFlags; /* Flags to enable/disable optimizations */ |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 876 | u8 autoCommit; /* The auto-commit flag. */ |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 877 | u8 temp_store; /* 1: file 2: memory 0: default */ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 878 | u8 mallocFailed; /* True if we have seen a malloc failure */ |
drh | 3b02013 | 2008-04-17 17:02:01 +0000 | [diff] [blame] | 879 | u8 dfltLockMode; /* Default locking-mode for attached dbs */ |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 880 | signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ |
drh | a756466 | 2010-02-22 19:32:31 +0000 | [diff] [blame] | 881 | u8 suppressErr; /* Do not issue error messages if true */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 882 | u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 883 | u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ |
danielk1977 | f653d78 | 2008-03-20 11:04:21 +0000 | [diff] [blame] | 884 | int nextPagesize; /* Pagesize after VACUUM if >0 */ |
danielk1977 | 64202cf | 2008-11-17 15:31:47 +0000 | [diff] [blame] | 885 | u32 magic; /* Magic number for detect library misuse */ |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 886 | int nChange; /* Value returned by sqlite3_changes() */ |
| 887 | int nTotalChange; /* Value returned by sqlite3_total_changes() */ |
drh | caa639f | 2008-03-20 00:32:20 +0000 | [diff] [blame] | 888 | int aLimit[SQLITE_N_LIMIT]; /* Limits */ |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 889 | struct sqlite3InitInfo { /* Information used during initialization */ |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 890 | int newTnum; /* Rootpage of table being initialized */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 891 | u8 iDb; /* Which db file is being initialized */ |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 892 | u8 busy; /* TRUE if currently initializing */ |
drh | 3d5f74b | 2009-08-06 17:43:31 +0000 | [diff] [blame] | 893 | u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */ |
drh | 1d85d93 | 2004-02-14 23:05:52 +0000 | [diff] [blame] | 894 | } init; |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 895 | int activeVdbeCnt; /* Number of VDBEs currently executing */ |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 896 | int writeVdbeCnt; /* Number of active VDBEs that are writing */ |
dan | 27381bd | 2011-01-22 13:32:29 +0000 | [diff] [blame] | 897 | int vdbeExecCnt; /* Number of nested calls to VdbeExec() */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 898 | int nExtension; /* Number of loaded extensions */ |
| 899 | void **aExtension; /* Array of shared library handles */ |
drh | 19e2d37 | 2005-08-29 23:00:03 +0000 | [diff] [blame] | 900 | void (*xTrace)(void*,const char*); /* Trace function */ |
| 901 | void *pTraceArg; /* Argument to the trace function */ |
| 902 | void (*xProfile)(void*,const char*,u64); /* Profiling function */ |
| 903 | void *pProfileArg; /* Argument to profile function */ |
danielk1977 | 71fd80b | 2005-12-16 06:54:01 +0000 | [diff] [blame] | 904 | void *pCommitArg; /* Argument to xCommitCallback() */ |
| 905 | int (*xCommitCallback)(void*); /* Invoked at every commit. */ |
| 906 | void *pRollbackArg; /* Argument to xRollbackCallback() */ |
| 907 | void (*xRollbackCallback)(void*); /* Invoked at every commit. */ |
danielk1977 | 94eb6a1 | 2005-12-15 15:22:08 +0000 | [diff] [blame] | 908 | void *pUpdateArg; |
| 909 | void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); |
dan | 5cf5353 | 2010-05-01 16:40:20 +0000 | [diff] [blame] | 910 | #ifndef SQLITE_OMIT_WAL |
drh | 7ed91f2 | 2010-04-29 22:34:07 +0000 | [diff] [blame] | 911 | int (*xWalCallback)(void *, sqlite3 *, const char *, int); |
| 912 | void *pWalArg; |
dan | 5cf5353 | 2010-05-01 16:40:20 +0000 | [diff] [blame] | 913 | #endif |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 914 | void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); |
| 915 | void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); |
| 916 | void *pCollNeededArg; |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 917 | sqlite3_value *pErr; /* Most recent error message */ |
| 918 | char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ |
| 919 | char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ |
drh | 881feaa | 2006-07-26 01:39:30 +0000 | [diff] [blame] | 920 | union { |
drh | 39001e7 | 2008-09-12 16:03:47 +0000 | [diff] [blame] | 921 | volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ |
drh | 881feaa | 2006-07-26 01:39:30 +0000 | [diff] [blame] | 922 | double notUsed1; /* Spacer */ |
| 923 | } u1; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 924 | Lookaside lookaside; /* Lookaside malloc configuration */ |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 925 | #ifndef SQLITE_OMIT_AUTHORIZATION |
drh | e22a334 | 2003-04-22 20:30:37 +0000 | [diff] [blame] | 926 | int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); |
| 927 | /* Access authorization function */ |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 928 | void *pAuthArg; /* 1st argument to the access auth function */ |
| 929 | #endif |
danielk1977 | 348bb5d | 2003-10-18 09:37:26 +0000 | [diff] [blame] | 930 | #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
| 931 | int (*xProgress)(void *); /* The progress callback */ |
| 932 | void *pProgressArg; /* Argument to the progress callback */ |
| 933 | int nProgressOps; /* Number of opcodes for progress callback */ |
| 934 | #endif |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 935 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 936 | int nVTrans; /* Allocated size of aVTrans */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 937 | Hash aModule; /* populated by sqlite3_create_module() */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 938 | VtabCtx *pVtabCtx; /* Context for active vtab connect/create */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 939 | VTable **aVTrans; /* Virtual tables with open transactions */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 940 | VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ |
danielk1977 | 6b456a2 | 2005-03-21 04:04:02 +0000 | [diff] [blame] | 941 | #endif |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 942 | FuncDefHash aFunc; /* Hash table of connection functions */ |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 943 | Hash aCollSeq; /* All collating sequences */ |
| 944 | BusyHandler busyHandler; /* Busy callback */ |
| 945 | Db aDbStatic[2]; /* Static space for the 2 default backends */ |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 946 | Savepoint *pSavepoint; /* List of active savepoints */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 947 | int busyTimeout; /* Busy handler timeout, in msec */ |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 948 | int nSavepoint; /* Number of non-transaction savepoints */ |
danielk1977 | bd43455 | 2009-03-18 10:33:00 +0000 | [diff] [blame] | 949 | int nStatement; /* Number of nested statement-transactions */ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 950 | i64 nDeferredCons; /* Net deferred constraints this transaction. */ |
dan | d46def7 | 2010-07-24 11:28:28 +0000 | [diff] [blame] | 951 | int *pnBytesFreed; /* If not NULL, increment this in DbFree() */ |
danielk1977 | 404ca07 | 2009-03-16 13:19:36 +0000 | [diff] [blame] | 952 | |
| 953 | #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY |
| 954 | /* The following variables are all protected by the STATIC_MASTER |
| 955 | ** mutex, not by sqlite3.mutex. They are used by code in notify.c. |
drh | 65a73ba | 2009-04-07 22:06:57 +0000 | [diff] [blame] | 956 | ** |
| 957 | ** When X.pUnlockConnection==Y, that means that X is waiting for Y to |
| 958 | ** unlock so that it can proceed. |
| 959 | ** |
| 960 | ** When X.pBlockingConnection==Y, that means that something that X tried |
| 961 | ** tried to do recently failed with an SQLITE_LOCKED error due to locks |
| 962 | ** held by Y. |
danielk1977 | 404ca07 | 2009-03-16 13:19:36 +0000 | [diff] [blame] | 963 | */ |
| 964 | sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ |
| 965 | sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ |
| 966 | void *pUnlockArg; /* Argument to xUnlockNotify */ |
| 967 | void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ |
| 968 | sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ |
| 969 | #endif |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 970 | }; |
| 971 | |
drh | 03b808a | 2006-03-13 15:06:05 +0000 | [diff] [blame] | 972 | /* |
| 973 | ** A macro to discover the encoding of a database. |
| 974 | */ |
danielk1977 | 14db266 | 2006-01-09 16:12:04 +0000 | [diff] [blame] | 975 | #define ENC(db) ((db)->aDb[0].pSchema->enc) |
| 976 | |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 977 | /* |
drh | 07096f6 | 2009-12-22 23:52:32 +0000 | [diff] [blame] | 978 | ** Possible values for the sqlite3.flags. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 979 | */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 980 | #define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ |
| 981 | #define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */ |
| 982 | #define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */ |
| 983 | #define SQLITE_ShortColNames 0x00000008 /* Show short columns names */ |
| 984 | #define SQLITE_CountRows 0x00000010 /* Count rows changed by INSERT, */ |
drh | 1bee3d7 | 2001-10-15 00:44:35 +0000 | [diff] [blame] | 985 | /* DELETE, or UPDATE and return */ |
| 986 | /* the count using a callback. */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 987 | #define SQLITE_NullCallback 0x00000020 /* Invoke the callback once if the */ |
drh | 6a53534 | 2001-10-19 16:44:56 +0000 | [diff] [blame] | 988 | /* result set is empty */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 989 | #define SQLITE_SqlTrace 0x00000040 /* Debug print SQL as it executes */ |
| 990 | #define SQLITE_VdbeListing 0x00000080 /* Debug listings of VDBE programs */ |
| 991 | #define SQLITE_WriteSchema 0x00000100 /* OK to update SQLITE_MASTER */ |
drh | e096205 | 2013-01-29 19:14:31 +0000 | [diff] [blame] | 992 | #define SQLITE_VdbeAddopTrace 0x00000200 /* Trace sqlite3VdbeAddOp() calls */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 993 | #define SQLITE_IgnoreChecks 0x00000400 /* Do not enforce check constraints */ |
| 994 | #define SQLITE_ReadUncommitted 0x0000800 /* For shared-cache mode */ |
| 995 | #define SQLITE_LegacyFileFmt 0x00001000 /* Create new databases in format 1 */ |
| 996 | #define SQLITE_FullFSync 0x00002000 /* Use full fsync on the backend */ |
| 997 | #define SQLITE_CkptFullFSync 0x00004000 /* Use full fsync for checkpoint */ |
| 998 | #define SQLITE_RecoveryMode 0x00008000 /* Ignore schema errors */ |
| 999 | #define SQLITE_ReverseOrder 0x00010000 /* Reverse unordered SELECTs */ |
| 1000 | #define SQLITE_RecTriggers 0x00020000 /* Enable recursive triggers */ |
| 1001 | #define SQLITE_ForeignKeys 0x00040000 /* Enforce foreign key constraints */ |
| 1002 | #define SQLITE_AutoIndex 0x00080000 /* Enable automatic indexes */ |
| 1003 | #define SQLITE_PreferBuiltin 0x00100000 /* Preference to built-in funcs */ |
| 1004 | #define SQLITE_LoadExtension 0x00200000 /* Enable load_extension */ |
| 1005 | #define SQLITE_EnableTrigger 0x00400000 /* True to enable triggers */ |
drh | 07096f6 | 2009-12-22 23:52:32 +0000 | [diff] [blame] | 1006 | |
| 1007 | /* |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 1008 | ** Bits of the sqlite3.dbOptFlags field that are used by the |
| 1009 | ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to |
| 1010 | ** selectively disable various optimizations. |
drh | 07096f6 | 2009-12-22 23:52:32 +0000 | [diff] [blame] | 1011 | */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 1012 | #define SQLITE_QueryFlattener 0x0001 /* Query flattening */ |
| 1013 | #define SQLITE_ColumnCache 0x0002 /* Column cache */ |
| 1014 | #define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */ |
| 1015 | #define SQLITE_FactorOutConst 0x0008 /* Constant factoring */ |
| 1016 | #define SQLITE_IdxRealAsInt 0x0010 /* Store REAL as INT in indices */ |
| 1017 | #define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */ |
| 1018 | #define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */ |
drh | a9e3fc0 | 2012-09-27 23:27:23 +0000 | [diff] [blame] | 1019 | #define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */ |
drh | a575967 | 2012-10-30 14:39:12 +0000 | [diff] [blame] | 1020 | #define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */ |
drh | eb5bc92 | 2013-01-17 16:43:33 +0000 | [diff] [blame] | 1021 | #define SQLITE_Transitive 0x0200 /* Transitive constraints */ |
drh | a575967 | 2012-10-30 14:39:12 +0000 | [diff] [blame] | 1022 | #define SQLITE_AllOpts 0xffff /* All optimizations */ |
drh | 7e5418e | 2012-09-27 15:05:54 +0000 | [diff] [blame] | 1023 | |
| 1024 | /* |
| 1025 | ** Macros for testing whether or not optimizations are enabled or disabled. |
| 1026 | */ |
| 1027 | #ifndef SQLITE_OMIT_BUILTIN_TEST |
| 1028 | #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) |
| 1029 | #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) |
| 1030 | #else |
| 1031 | #define OptimizationDisabled(db, mask) 0 |
| 1032 | #define OptimizationEnabled(db, mask) 1 |
| 1033 | #endif |
danielk1977 | 34c68fb | 2007-03-14 15:37:04 +0000 | [diff] [blame] | 1034 | |
drh | 58b9576 | 2000-06-02 01:17:37 +0000 | [diff] [blame] | 1035 | /* |
drh | 247be43 | 2002-05-10 05:44:55 +0000 | [diff] [blame] | 1036 | ** Possible values for the sqlite.magic field. |
| 1037 | ** The numbers are obtained at random and have no special meaning, other |
| 1038 | ** than being distinct from one another. |
| 1039 | */ |
| 1040 | #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ |
| 1041 | #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1042 | #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ |
drh | 247be43 | 2002-05-10 05:44:55 +0000 | [diff] [blame] | 1043 | #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ |
| 1044 | #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ |
drh | 4245c40 | 2012-06-02 14:32:21 +0000 | [diff] [blame] | 1045 | #define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */ |
drh | 247be43 | 2002-05-10 05:44:55 +0000 | [diff] [blame] | 1046 | |
| 1047 | /* |
drh | 0bce835 | 2002-02-28 00:41:10 +0000 | [diff] [blame] | 1048 | ** Each SQL function is defined by an instance of the following |
| 1049 | ** structure. A pointer to this structure is stored in the sqlite.aFunc |
drh | 8e0a2f9 | 2002-02-23 23:45:45 +0000 | [diff] [blame] | 1050 | ** hash table. When multiple functions have the same name, the hash table |
| 1051 | ** points to a linked list of these structures. |
drh | 2803757 | 2000-08-02 13:47:41 +0000 | [diff] [blame] | 1052 | */ |
drh | 0bce835 | 2002-02-28 00:41:10 +0000 | [diff] [blame] | 1053 | struct FuncDef { |
drh | e82f5d0 | 2008-10-07 19:53:14 +0000 | [diff] [blame] | 1054 | i16 nArg; /* Number of arguments. -1 means unlimited */ |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 1055 | u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ |
drh | 55ef4d9 | 2005-08-14 01:20:37 +0000 | [diff] [blame] | 1056 | u8 flags; /* Some combination of SQLITE_FUNC_* */ |
drh | f9b596e | 2004-05-26 16:54:42 +0000 | [diff] [blame] | 1057 | void *pUserData; /* User data parameter */ |
| 1058 | FuncDef *pNext; /* Next function with same name */ |
| 1059 | void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ |
| 1060 | void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1061 | void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */ |
danielk1977 | 8c0a791 | 2008-08-20 14:49:23 +0000 | [diff] [blame] | 1062 | char *zName; /* SQL name of the function. */ |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 1063 | FuncDef *pHash; /* Next with a different name but the same hash */ |
dan | d2199f0 | 2010-08-27 17:48:52 +0000 | [diff] [blame] | 1064 | FuncDestructor *pDestructor; /* Reference counted destructor function */ |
| 1065 | }; |
| 1066 | |
| 1067 | /* |
| 1068 | ** This structure encapsulates a user-function destructor callback (as |
| 1069 | ** configured using create_function_v2()) and a reference counter. When |
| 1070 | ** create_function_v2() is called to create a function with a destructor, |
| 1071 | ** a single object of this type is allocated. FuncDestructor.nRef is set to |
| 1072 | ** the number of FuncDef objects created (either 1 or 3, depending on whether |
| 1073 | ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor |
| 1074 | ** member of each of the new FuncDef objects is set to point to the allocated |
| 1075 | ** FuncDestructor. |
| 1076 | ** |
| 1077 | ** Thereafter, when one of the FuncDef objects is deleted, the reference |
| 1078 | ** count on this object is decremented. When it reaches 0, the destructor |
| 1079 | ** is invoked and the FuncDestructor structure freed. |
| 1080 | */ |
| 1081 | struct FuncDestructor { |
| 1082 | int nRef; |
| 1083 | void (*xDestroy)(void *); |
| 1084 | void *pUserData; |
drh | 8e0a2f9 | 2002-02-23 23:45:45 +0000 | [diff] [blame] | 1085 | }; |
drh | 2803757 | 2000-08-02 13:47:41 +0000 | [diff] [blame] | 1086 | |
| 1087 | /* |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 1088 | ** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF |
| 1089 | ** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. There |
| 1090 | ** are assert() statements in the code to verify this. |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1091 | */ |
drh | e82f5d0 | 2008-10-07 19:53:14 +0000 | [diff] [blame] | 1092 | #define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ |
| 1093 | #define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1094 | #define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */ |
drh | e82f5d0 | 2008-10-07 19:53:14 +0000 | [diff] [blame] | 1095 | #define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */ |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 1096 | #define SQLITE_FUNC_COUNT 0x10 /* Built-in count(*) aggregate */ |
| 1097 | #define SQLITE_FUNC_COALESCE 0x20 /* Built-in coalesce() or ifnull() function */ |
| 1098 | #define SQLITE_FUNC_LENGTH 0x40 /* Built-in length() function */ |
| 1099 | #define SQLITE_FUNC_TYPEOF 0x80 /* Built-in typeof() function */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1100 | |
| 1101 | /* |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1102 | ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are |
| 1103 | ** used to create the initializers for the FuncDef structures. |
| 1104 | ** |
| 1105 | ** FUNCTION(zName, nArg, iArg, bNC, xFunc) |
| 1106 | ** Used to create a scalar function definition of a function zName |
| 1107 | ** implemented by C function xFunc that accepts nArg arguments. The |
| 1108 | ** value passed as iArg is cast to a (void*) and made available |
| 1109 | ** as the user-data (sqlite3_user_data()) for the function. If |
drh | f7bca57 | 2009-05-30 14:16:31 +0000 | [diff] [blame] | 1110 | ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1111 | ** |
| 1112 | ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) |
| 1113 | ** Used to create an aggregate function definition implemented by |
| 1114 | ** the C functions xStep and xFinal. The first four parameters |
| 1115 | ** are interpreted in the same way as the first 4 parameters to |
| 1116 | ** FUNCTION(). |
| 1117 | ** |
| 1118 | ** LIKEFUNC(zName, nArg, pArg, flags) |
| 1119 | ** Used to create a scalar function definition of a function zName |
| 1120 | ** that accepts nArg arguments and is implemented by a call to C |
| 1121 | ** function likeFunc. Argument pArg is cast to a (void *) and made |
| 1122 | ** available as the function user-data (sqlite3_user_data()). The |
| 1123 | ** FuncDef.flags variable is set to the value passed as the flags |
| 1124 | ** parameter. |
| 1125 | */ |
| 1126 | #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 1127 | {nArg, SQLITE_UTF8, (bNC*SQLITE_FUNC_NEEDCOLL), \ |
| 1128 | SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} |
| 1129 | #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ |
| 1130 | {nArg, SQLITE_UTF8, (bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags, \ |
drh | 6ac78a0 | 2010-09-28 14:26:36 +0000 | [diff] [blame] | 1131 | SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} |
drh | 21717ed | 2008-10-13 15:35:08 +0000 | [diff] [blame] | 1132 | #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ |
drh | f7bca57 | 2009-05-30 14:16:31 +0000 | [diff] [blame] | 1133 | {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ |
drh | 6ac78a0 | 2010-09-28 14:26:36 +0000 | [diff] [blame] | 1134 | pArg, 0, xFunc, 0, 0, #zName, 0, 0} |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1135 | #define LIKEFUNC(zName, nArg, arg, flags) \ |
drh | 6ac78a0 | 2010-09-28 14:26:36 +0000 | [diff] [blame] | 1136 | {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0} |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1137 | #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ |
drh | f7bca57 | 2009-05-30 14:16:31 +0000 | [diff] [blame] | 1138 | {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \ |
drh | 6ac78a0 | 2010-09-28 14:26:36 +0000 | [diff] [blame] | 1139 | SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0} |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1140 | |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 1141 | /* |
| 1142 | ** All current savepoints are stored in a linked list starting at |
| 1143 | ** sqlite3.pSavepoint. The first element in the list is the most recently |
| 1144 | ** opened savepoint. Savepoints are added to the list by the vdbe |
| 1145 | ** OP_Savepoint instruction. |
| 1146 | */ |
| 1147 | struct Savepoint { |
| 1148 | char *zName; /* Savepoint name (nul-terminated) */ |
drh | fcb9f7a | 2009-10-13 19:19:23 +0000 | [diff] [blame] | 1149 | i64 nDeferredCons; /* Number of deferred fk violations */ |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 1150 | Savepoint *pNext; /* Parent savepoint (if any) */ |
| 1151 | }; |
| 1152 | |
| 1153 | /* |
| 1154 | ** The following are used as the second parameter to sqlite3Savepoint(), |
| 1155 | ** and as the P1 argument to the OP_Savepoint instruction. |
| 1156 | */ |
| 1157 | #define SAVEPOINT_BEGIN 0 |
| 1158 | #define SAVEPOINT_RELEASE 1 |
| 1159 | #define SAVEPOINT_ROLLBACK 2 |
| 1160 | |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 1161 | |
| 1162 | /* |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 1163 | ** Each SQLite module (virtual table definition) is defined by an |
| 1164 | ** instance of the following structure, stored in the sqlite3.aModule |
| 1165 | ** hash table. |
| 1166 | */ |
| 1167 | struct Module { |
| 1168 | const sqlite3_module *pModule; /* Callback pointers */ |
| 1169 | const char *zName; /* Name passed to create_module() */ |
| 1170 | void *pAux; /* pAux passed to create_module() */ |
danielk1977 | 832a58a | 2007-06-22 15:21:15 +0000 | [diff] [blame] | 1171 | void (*xDestroy)(void *); /* Module destructor function */ |
danielk1977 | d1ab1ba | 2006-06-15 04:28:13 +0000 | [diff] [blame] | 1172 | }; |
| 1173 | |
| 1174 | /* |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 1175 | ** information about each column of an SQL table is held in an instance |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 1176 | ** of this structure. |
| 1177 | */ |
| 1178 | struct Column { |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 1179 | char *zName; /* Name of this column */ |
danielk1977 | 7977a17 | 2004-11-09 12:44:37 +0000 | [diff] [blame] | 1180 | Expr *pDflt; /* Default value of this column */ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1181 | char *zDflt; /* Original text of the default value */ |
drh | 382c024 | 2001-10-06 16:33:02 +0000 | [diff] [blame] | 1182 | char *zType; /* Data type for this column */ |
danielk1977 | b3bf556 | 2006-01-10 17:58:23 +0000 | [diff] [blame] | 1183 | char *zColl; /* Collating sequence. If NULL, use the default */ |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 1184 | u8 notNull; /* An OE_ code for handling a NOT NULL constraint */ |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 1185 | char affinity; /* One of the SQLITE_AFF_... values */ |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 1186 | u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 1187 | }; |
| 1188 | |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 1189 | /* Allowed values for Column.colFlags: |
| 1190 | */ |
| 1191 | #define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ |
| 1192 | #define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ |
| 1193 | |
drh | 7020f65 | 2000-06-03 18:06:52 +0000 | [diff] [blame] | 1194 | /* |
drh | a9fd84b | 2004-05-18 23:21:35 +0000 | [diff] [blame] | 1195 | ** A "Collating Sequence" is defined by an instance of the following |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 1196 | ** structure. Conceptually, a collating sequence consists of a name and |
| 1197 | ** a comparison routine that defines the order of that sequence. |
drh | a9fd84b | 2004-05-18 23:21:35 +0000 | [diff] [blame] | 1198 | ** |
drh | e6f1e76 | 2012-12-06 01:03:15 +0000 | [diff] [blame] | 1199 | ** If CollSeq.xCmp is NULL, it means that the |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 1200 | ** collating sequence is undefined. Indices built on an undefined |
| 1201 | ** collating sequence may not be read or written. |
drh | a9fd84b | 2004-05-18 23:21:35 +0000 | [diff] [blame] | 1202 | */ |
| 1203 | struct CollSeq { |
danielk1977 | a9808b3 | 2007-05-07 09:32:45 +0000 | [diff] [blame] | 1204 | char *zName; /* Name of the collating sequence, UTF-8 encoded */ |
| 1205 | u8 enc; /* Text encoding handled by xCmp() */ |
danielk1977 | a9808b3 | 2007-05-07 09:32:45 +0000 | [diff] [blame] | 1206 | void *pUser; /* First argument to xCmp() */ |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 1207 | int (*xCmp)(void*,int, const void*, int, const void*); |
danielk1977 | a9808b3 | 2007-05-07 09:32:45 +0000 | [diff] [blame] | 1208 | void (*xDel)(void*); /* Destructor for pUser */ |
drh | a9fd84b | 2004-05-18 23:21:35 +0000 | [diff] [blame] | 1209 | }; |
| 1210 | |
| 1211 | /* |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1212 | ** A sort order can be either ASC or DESC. |
drh | 8e2ca02 | 2002-06-17 17:07:19 +0000 | [diff] [blame] | 1213 | */ |
drh | 8e2ca02 | 2002-06-17 17:07:19 +0000 | [diff] [blame] | 1214 | #define SQLITE_SO_ASC 0 /* Sort in ascending order */ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1215 | #define SQLITE_SO_DESC 1 /* Sort in ascending order */ |
drh | 8e2ca02 | 2002-06-17 17:07:19 +0000 | [diff] [blame] | 1216 | |
| 1217 | /* |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 1218 | ** Column affinity types. |
drh | 8a51256 | 2005-11-14 22:29:05 +0000 | [diff] [blame] | 1219 | ** |
| 1220 | ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and |
| 1221 | ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1222 | ** the speed a little by numbering the values consecutively. |
drh | 8a51256 | 2005-11-14 22:29:05 +0000 | [diff] [blame] | 1223 | ** |
| 1224 | ** But rather than start with 0 or 1, we begin with 'a'. That way, |
| 1225 | ** when multiple affinity types are concatenated into a string and |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 1226 | ** used as the P4 operand, they will be more readable. |
drh | 8a51256 | 2005-11-14 22:29:05 +0000 | [diff] [blame] | 1227 | ** |
| 1228 | ** Note also that the numeric types are grouped together so that testing |
| 1229 | ** for a numeric type is a single comparison. |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 1230 | */ |
drh | 8a51256 | 2005-11-14 22:29:05 +0000 | [diff] [blame] | 1231 | #define SQLITE_AFF_TEXT 'a' |
| 1232 | #define SQLITE_AFF_NONE 'b' |
| 1233 | #define SQLITE_AFF_NUMERIC 'c' |
| 1234 | #define SQLITE_AFF_INTEGER 'd' |
| 1235 | #define SQLITE_AFF_REAL 'e' |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 1236 | |
drh | 8a51256 | 2005-11-14 22:29:05 +0000 | [diff] [blame] | 1237 | #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 1238 | |
| 1239 | /* |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 1240 | ** The SQLITE_AFF_MASK values masks off the significant bits of an |
| 1241 | ** affinity value. |
| 1242 | */ |
| 1243 | #define SQLITE_AFF_MASK 0x67 |
| 1244 | |
| 1245 | /* |
| 1246 | ** Additional bit values that can be ORed with an affinity without |
| 1247 | ** changing the affinity. |
| 1248 | */ |
| 1249 | #define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */ |
drh | 93a960a | 2008-07-10 00:32:42 +0000 | [diff] [blame] | 1250 | #define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */ |
drh | 6a2fe09 | 2009-09-23 02:29:36 +0000 | [diff] [blame] | 1251 | #define SQLITE_NULLEQ 0x80 /* NULL=NULL */ |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 1252 | |
| 1253 | /* |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 1254 | ** An object of this type is created for each virtual table present in |
| 1255 | ** the database schema. |
| 1256 | ** |
| 1257 | ** If the database schema is shared, then there is one instance of this |
| 1258 | ** structure for each database connection (sqlite3*) that uses the shared |
| 1259 | ** schema. This is because each database connection requires its own unique |
| 1260 | ** instance of the sqlite3_vtab* handle used to access the virtual table |
| 1261 | ** implementation. sqlite3_vtab* handles can not be shared between |
| 1262 | ** database connections, even when the rest of the in-memory database |
| 1263 | ** schema is shared, as the implementation often stores the database |
| 1264 | ** connection handle passed to it via the xConnect() or xCreate() method |
| 1265 | ** during initialization internally. This database connection handle may |
drh | 9bbc2e2 | 2011-04-04 20:40:22 +0000 | [diff] [blame] | 1266 | ** then be used by the virtual table implementation to access real tables |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 1267 | ** within the database. So that they appear as part of the callers |
| 1268 | ** transaction, these accesses need to be made via the same database |
| 1269 | ** connection as that used to execute SQL operations on the virtual table. |
| 1270 | ** |
| 1271 | ** All VTable objects that correspond to a single table in a shared |
| 1272 | ** database schema are initially stored in a linked-list pointed to by |
| 1273 | ** the Table.pVTable member variable of the corresponding Table object. |
| 1274 | ** When an sqlite3_prepare() operation is required to access the virtual |
| 1275 | ** table, it searches the list for the VTable that corresponds to the |
| 1276 | ** database connection doing the preparing so as to use the correct |
| 1277 | ** sqlite3_vtab* handle in the compiled query. |
| 1278 | ** |
| 1279 | ** When an in-memory Table object is deleted (for example when the |
| 1280 | ** schema is being reloaded for some reason), the VTable objects are not |
| 1281 | ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed |
| 1282 | ** immediately. Instead, they are moved from the Table.pVTable list to |
| 1283 | ** another linked list headed by the sqlite3.pDisconnect member of the |
| 1284 | ** corresponding sqlite3 structure. They are then deleted/xDisconnected |
| 1285 | ** next time a statement is prepared using said sqlite3*. This is done |
| 1286 | ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. |
| 1287 | ** Refer to comments above function sqlite3VtabUnlockList() for an |
| 1288 | ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect |
| 1289 | ** list without holding the corresponding sqlite3.mutex mutex. |
| 1290 | ** |
| 1291 | ** The memory for objects of this type is always allocated by |
| 1292 | ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as |
| 1293 | ** the first argument. |
| 1294 | */ |
| 1295 | struct VTable { |
| 1296 | sqlite3 *db; /* Database connection associated with this table */ |
| 1297 | Module *pMod; /* Pointer to module implementation */ |
| 1298 | sqlite3_vtab *pVtab; /* Pointer to vtab instance */ |
| 1299 | int nRef; /* Number of pointers to this structure */ |
dan | b061d05 | 2011-04-25 18:49:57 +0000 | [diff] [blame] | 1300 | u8 bConstraint; /* True if constraints are supported */ |
drh | addd8f8 | 2011-05-25 15:54:09 +0000 | [diff] [blame] | 1301 | int iSavepoint; /* Depth of the SAVEPOINT stack */ |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 1302 | VTable *pNext; /* Next in linked list (see above) */ |
| 1303 | }; |
| 1304 | |
| 1305 | /* |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1306 | ** Each SQL table is represented in memory by an instance of the |
| 1307 | ** following structure. |
| 1308 | ** |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1309 | ** Table.zName is the name of the table. The case of the original |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1310 | ** CREATE TABLE statement is stored, but case is not significant for |
| 1311 | ** comparisons. |
| 1312 | ** |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1313 | ** Table.nCol is the number of columns in this table. Table.aCol is a |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1314 | ** pointer to an array of Column structures, one for each column. |
| 1315 | ** |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1316 | ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of |
| 1317 | ** the column that is that key. Otherwise Table.iPKey is negative. Note |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1318 | ** that the datatype of the PRIMARY KEY must be INTEGER for this field to |
| 1319 | ** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of |
| 1320 | ** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1321 | ** is generated for each row of the table. TF_HasPrimaryKey is set if |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1322 | ** the table has any PRIMARY KEY, INTEGER or otherwise. |
| 1323 | ** |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1324 | ** Table.tnum is the page number for the root BTree page of the table in the |
| 1325 | ** database file. If Table.iDb is the index of the database table backend |
| 1326 | ** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1327 | ** holds temporary tables and indices. If TF_Ephemeral is set |
| 1328 | ** then the table is stored in a file that is automatically deleted |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1329 | ** when the VDBE cursor to the table is closed. In this case Table.tnum |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1330 | ** refers VDBE cursor number that holds the table open, not to the root |
| 1331 | ** page number. Transient tables are used to hold the results of a |
| 1332 | ** sub-query that appears instead of a real table name in the FROM clause |
| 1333 | ** of a SELECT statement. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1334 | */ |
| 1335 | struct Table { |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1336 | char *zName; /* Name of the table or view */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1337 | Column *aCol; /* Information about each column */ |
| 1338 | Index *pIndex; /* List of SQL indexes on this table. */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1339 | Select *pSelect; /* NULL for tables. Points to definition if a view. */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1340 | FKey *pFKey; /* Linked list of all foreign keys in this table */ |
| 1341 | char *zColAff; /* String defining the affinity of each column */ |
drh | ffe07b2 | 2005-11-03 00:41:17 +0000 | [diff] [blame] | 1342 | #ifndef SQLITE_OMIT_CHECK |
drh | 2938f92 | 2012-03-07 19:13:29 +0000 | [diff] [blame] | 1343 | ExprList *pCheck; /* All CHECK constraints */ |
drh | ffe07b2 | 2005-11-03 00:41:17 +0000 | [diff] [blame] | 1344 | #endif |
drh | d815f17 | 2012-09-13 14:42:43 +0000 | [diff] [blame] | 1345 | tRowcnt nRowEst; /* Estimated rows in table - from sqlite_stat1 table */ |
| 1346 | int tnum; /* Root BTree node for this table (see note above) */ |
| 1347 | i16 iPKey; /* If not negative, use aCol[iPKey] as the primary key */ |
| 1348 | i16 nCol; /* Number of columns in this table */ |
| 1349 | u16 nRef; /* Number of pointers to this Table */ |
| 1350 | u8 tabFlags; /* Mask of TF_* values */ |
| 1351 | u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ |
danielk1977 | 19a8e7e | 2005-03-17 05:03:38 +0000 | [diff] [blame] | 1352 | #ifndef SQLITE_OMIT_ALTERTABLE |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1353 | int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ |
danielk1977 | 19a8e7e | 2005-03-17 05:03:38 +0000 | [diff] [blame] | 1354 | #endif |
drh | e09daa9 | 2006-06-10 13:29:31 +0000 | [diff] [blame] | 1355 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1356 | int nModuleArg; /* Number of arguments to the module */ |
| 1357 | char **azModuleArg; /* Text of all module args. [0] is module name */ |
drh | d815f17 | 2012-09-13 14:42:43 +0000 | [diff] [blame] | 1358 | VTable *pVTable; /* List of VTable objects. */ |
drh | e09daa9 | 2006-06-10 13:29:31 +0000 | [diff] [blame] | 1359 | #endif |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 1360 | Trigger *pTrigger; /* List of triggers stored in pSchema */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1361 | Schema *pSchema; /* Schema that contains this table */ |
drh | 588a9a1 | 2008-09-01 15:52:10 +0000 | [diff] [blame] | 1362 | Table *pNextZombie; /* Next on the Parse.pZombieTab list */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1363 | }; |
| 1364 | |
| 1365 | /* |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1366 | ** Allowed values for Tabe.tabFlags. |
| 1367 | */ |
| 1368 | #define TF_Readonly 0x01 /* Read-only system table */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1369 | #define TF_Ephemeral 0x02 /* An ephemeral table */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1370 | #define TF_HasPrimaryKey 0x04 /* Table has a primary key */ |
| 1371 | #define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */ |
| 1372 | #define TF_Virtual 0x10 /* Is a virtual table */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1373 | |
| 1374 | |
| 1375 | /* |
drh | 4cbdda9 | 2006-06-14 19:00:20 +0000 | [diff] [blame] | 1376 | ** Test to see whether or not a table is a virtual table. This is |
| 1377 | ** done as a macro so that it will be optimized out when virtual |
| 1378 | ** table support is omitted from the build. |
| 1379 | */ |
| 1380 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1381 | # define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) |
drh | a371ace | 2012-09-13 14:22:47 +0000 | [diff] [blame] | 1382 | # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) |
drh | 4cbdda9 | 2006-06-14 19:00:20 +0000 | [diff] [blame] | 1383 | #else |
danielk1977 | 034ca14 | 2007-06-26 10:38:54 +0000 | [diff] [blame] | 1384 | # define IsVirtual(X) 0 |
| 1385 | # define IsHiddenColumn(X) 0 |
drh | 4cbdda9 | 2006-06-14 19:00:20 +0000 | [diff] [blame] | 1386 | #endif |
| 1387 | |
| 1388 | /* |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1389 | ** Each foreign key constraint is an instance of the following structure. |
| 1390 | ** |
| 1391 | ** A foreign key is associated with two tables. The "from" table is |
| 1392 | ** the table that contains the REFERENCES clause that creates the foreign |
| 1393 | ** key. The "to" table is the table that is named in the REFERENCES clause. |
| 1394 | ** Consider this example: |
| 1395 | ** |
| 1396 | ** CREATE TABLE ex1( |
| 1397 | ** a INTEGER PRIMARY KEY, |
| 1398 | ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) |
| 1399 | ** ); |
| 1400 | ** |
| 1401 | ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". |
| 1402 | ** |
| 1403 | ** Each REFERENCES clause generates an instance of the following structure |
| 1404 | ** which is attached to the from-table. The to-table need not exist when |
drh | e61922a | 2009-05-02 13:29:37 +0000 | [diff] [blame] | 1405 | ** the from-table is created. The existence of the to-table is not checked. |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1406 | */ |
| 1407 | struct FKey { |
drh | 1f638ce | 2009-09-24 13:48:10 +0000 | [diff] [blame] | 1408 | Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1409 | FKey *pNextFrom; /* Next foreign key in pFrom */ |
drh | 1f638ce | 2009-09-24 13:48:10 +0000 | [diff] [blame] | 1410 | char *zTo; /* Name of table that the key points to (aka: Parent) */ |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 1411 | FKey *pNextTo; /* Next foreign key on table named zTo */ |
| 1412 | FKey *pPrevTo; /* Previous foreign key on table named zTo */ |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1413 | int nCol; /* Number of columns in this key */ |
drh | 4c42983 | 2009-10-12 22:30:49 +0000 | [diff] [blame] | 1414 | /* EV: R-30323-21917 */ |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1415 | u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ |
dan | 8099ce6 | 2009-09-23 08:43:35 +0000 | [diff] [blame] | 1416 | u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ |
| 1417 | Trigger *apTrigger[2]; /* Triggers for aAction[] actions */ |
drh | e61922a | 2009-05-02 13:29:37 +0000 | [diff] [blame] | 1418 | struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ |
| 1419 | int iFrom; /* Index of column in pFrom */ |
| 1420 | char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ |
| 1421 | } aCol[1]; /* One entry for each of nCol column s */ |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1422 | }; |
| 1423 | |
| 1424 | /* |
danielk1977 | aaa40c1 | 2007-09-21 04:28:16 +0000 | [diff] [blame] | 1425 | ** SQLite supports many different ways to resolve a constraint |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1426 | ** error. ROLLBACK processing means that a constraint violation |
drh | 0bd1f4e | 2002-06-06 18:54:39 +0000 | [diff] [blame] | 1427 | ** causes the operation in process to fail and for the current transaction |
drh | 1c92853 | 2002-01-31 15:54:21 +0000 | [diff] [blame] | 1428 | ** to be rolled back. ABORT processing means the operation in process |
| 1429 | ** fails and any prior changes from that one operation are backed out, |
| 1430 | ** but the transaction is not rolled back. FAIL processing means that |
| 1431 | ** the operation in progress stops and returns an error code. But prior |
| 1432 | ** changes due to the same operation are not backed out and no rollback |
| 1433 | ** occurs. IGNORE means that the particular row that caused the constraint |
| 1434 | ** error is not inserted or updated. Processing continues and no error |
| 1435 | ** is returned. REPLACE means that preexisting database rows that caused |
| 1436 | ** a UNIQUE constraint violation are removed so that the new insert or |
| 1437 | ** update can proceed. Processing continues and no error is reported. |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1438 | ** |
| 1439 | ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. |
| 1440 | ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the |
| 1441 | ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign |
| 1442 | ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the |
| 1443 | ** referenced table row is propagated into the row that holds the |
| 1444 | ** foreign key. |
drh | 1c92853 | 2002-01-31 15:54:21 +0000 | [diff] [blame] | 1445 | ** |
drh | 968af52 | 2003-02-11 14:55:40 +0000 | [diff] [blame] | 1446 | ** The following symbolic values are used to record which type |
drh | 1c92853 | 2002-01-31 15:54:21 +0000 | [diff] [blame] | 1447 | ** of action to take. |
drh | 9cfcf5d | 2002-01-29 18:41:24 +0000 | [diff] [blame] | 1448 | */ |
drh | 1c92853 | 2002-01-31 15:54:21 +0000 | [diff] [blame] | 1449 | #define OE_None 0 /* There is no constraint to check */ |
| 1450 | #define OE_Rollback 1 /* Fail the operation and rollback the transaction */ |
| 1451 | #define OE_Abort 2 /* Back out changes but do no rollback transaction */ |
| 1452 | #define OE_Fail 3 /* Stop the operation but leave all prior changes */ |
| 1453 | #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ |
| 1454 | #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ |
drh | c2eef3b | 2002-08-31 18:53:06 +0000 | [diff] [blame] | 1455 | |
| 1456 | #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ |
| 1457 | #define OE_SetNull 7 /* Set the foreign key value to NULL */ |
| 1458 | #define OE_SetDflt 8 /* Set the foreign key value to its default */ |
| 1459 | #define OE_Cascade 9 /* Cascade the changes */ |
| 1460 | |
| 1461 | #define OE_Default 99 /* Do whatever the default action is */ |
drh | 9cfcf5d | 2002-01-29 18:41:24 +0000 | [diff] [blame] | 1462 | |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1463 | |
| 1464 | /* |
| 1465 | ** An instance of the following structure is passed as the first |
| 1466 | ** argument to sqlite3VdbeKeyCompare and is used to control the |
| 1467 | ** comparison of the two index keys. |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1468 | */ |
| 1469 | struct KeyInfo { |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 1470 | sqlite3 *db; /* The database connection */ |
drh | 9b8d027 | 2010-08-09 15:44:21 +0000 | [diff] [blame] | 1471 | u8 enc; /* Text encoding - one of the SQLITE_UTF* values */ |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1472 | u16 nField; /* Number of entries in aColl[] */ |
drh | 3bb9b93 | 2010-08-06 02:10:00 +0000 | [diff] [blame] | 1473 | u8 *aSortOrder; /* Sort order for each column. May be NULL */ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1474 | CollSeq *aColl[1]; /* Collating sequence for each term of the key */ |
| 1475 | }; |
| 1476 | |
drh | 9cfcf5d | 2002-01-29 18:41:24 +0000 | [diff] [blame] | 1477 | /* |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1478 | ** An instance of the following structure holds information about a |
| 1479 | ** single index record that has already been parsed out into individual |
| 1480 | ** values. |
| 1481 | ** |
| 1482 | ** A record is an object that contains one or more fields of data. |
| 1483 | ** Records are used to store the content of a table row and to store |
| 1484 | ** the key of an index. A blob encoding of a record is created by |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1485 | ** the OP_MakeRecord opcode of the VDBE and is disassembled by the |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1486 | ** OP_Column opcode. |
| 1487 | ** |
| 1488 | ** This structure holds a record that has already been disassembled |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1489 | ** into its constituent fields. |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1490 | */ |
| 1491 | struct UnpackedRecord { |
| 1492 | KeyInfo *pKeyInfo; /* Collation and sort-order information */ |
| 1493 | u16 nField; /* Number of entries in apMem[] */ |
drh | 76a3aca | 2011-11-29 15:04:12 +0000 | [diff] [blame] | 1494 | u8 flags; /* Boolean settings. UNPACKED_... below */ |
danielk1977 | de63035 | 2009-05-04 11:42:29 +0000 | [diff] [blame] | 1495 | i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */ |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1496 | Mem *aMem; /* Values */ |
| 1497 | }; |
| 1498 | |
| 1499 | /* |
| 1500 | ** Allowed values of UnpackedRecord.flags |
| 1501 | */ |
drh | 76a3aca | 2011-11-29 15:04:12 +0000 | [diff] [blame] | 1502 | #define UNPACKED_INCRKEY 0x01 /* Make this key an epsilon larger */ |
| 1503 | #define UNPACKED_PREFIX_MATCH 0x02 /* A prefix match is considered OK */ |
| 1504 | #define UNPACKED_PREFIX_SEARCH 0x04 /* Ignore final (rowid) field */ |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1505 | |
| 1506 | /* |
drh | 66b89c8 | 2000-11-28 20:47:17 +0000 | [diff] [blame] | 1507 | ** Each SQL index is represented in memory by an |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1508 | ** instance of the following structure. |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 1509 | ** |
| 1510 | ** The columns of the table that are to be indexed are described |
| 1511 | ** by the aiColumn[] field of this structure. For example, suppose |
| 1512 | ** we have the following table and index: |
| 1513 | ** |
| 1514 | ** CREATE TABLE Ex1(c1 int, c2 int, c3 text); |
| 1515 | ** CREATE INDEX Ex2 ON Ex1(c3,c1); |
| 1516 | ** |
| 1517 | ** In the Table structure describing Ex1, nCol==3 because there are |
| 1518 | ** three columns in the table. In the Index structure describing |
| 1519 | ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. |
| 1520 | ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the |
| 1521 | ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. |
| 1522 | ** The second column to be indexed (c1) has an index of 0 in |
| 1523 | ** Ex1.aCol[], hence Ex2.aiColumn[1]==0. |
drh | ea1ba17 | 2003-04-20 00:00:23 +0000 | [diff] [blame] | 1524 | ** |
| 1525 | ** The Index.onError field determines whether or not the indexed columns |
| 1526 | ** must be unique and what to do if they are not. When Index.onError=OE_None, |
| 1527 | ** it means this is not a unique index. Otherwise it is a unique index |
| 1528 | ** and the value of Index.onError indicate the which conflict resolution |
| 1529 | ** algorithm to employ whenever an attempt is made to insert a non-unique |
| 1530 | ** element. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1531 | */ |
| 1532 | struct Index { |
drh | b376dae | 2013-01-01 14:01:28 +0000 | [diff] [blame] | 1533 | char *zName; /* Name of this index */ |
| 1534 | int *aiColumn; /* Which columns are used by this index. 1st is 0 */ |
| 1535 | tRowcnt *aiRowEst; /* From ANALYZE: Est. rows selected by each column */ |
| 1536 | Table *pTable; /* The SQL table being indexed */ |
| 1537 | char *zColAff; /* String defining the affinity of each column */ |
| 1538 | Index *pNext; /* The next index associated with the same table */ |
| 1539 | Schema *pSchema; /* Schema containing this index */ |
| 1540 | u8 *aSortOrder; /* for each column: True==DESC, False==ASC */ |
| 1541 | char **azColl; /* Array of collation sequence names for index */ |
| 1542 | int tnum; /* DB Page containing root of this index */ |
| 1543 | u16 nColumn; /* Number of columns in table used by this index */ |
| 1544 | u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ |
| 1545 | unsigned autoIndex:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */ |
| 1546 | unsigned bUnordered:1; /* Use this index for == or IN queries only */ |
drh | 7699d1c | 2013-06-04 12:42:29 +0000 | [diff] [blame^] | 1547 | unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */ |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 1548 | #ifdef SQLITE_ENABLE_STAT3 |
drh | 2b9cf66 | 2011-09-22 20:52:56 +0000 | [diff] [blame] | 1549 | int nSample; /* Number of elements in aSample[] */ |
drh | 4e50c5e | 2011-08-13 19:35:19 +0000 | [diff] [blame] | 1550 | tRowcnt avgEq; /* Average nEq value for key values not in aSample */ |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 1551 | IndexSample *aSample; /* Samples of the left-most key */ |
| 1552 | #endif |
dan | 02fa469 | 2009-08-17 17:06:58 +0000 | [diff] [blame] | 1553 | }; |
| 1554 | |
| 1555 | /* |
drh | 74e7c8f | 2011-10-21 19:06:32 +0000 | [diff] [blame] | 1556 | ** Each sample stored in the sqlite_stat3 table is represented in memory |
| 1557 | ** using a structure of this type. See documentation at the top of the |
| 1558 | ** analyze.c source file for additional information. |
dan | 02fa469 | 2009-08-17 17:06:58 +0000 | [diff] [blame] | 1559 | */ |
| 1560 | struct IndexSample { |
| 1561 | union { |
| 1562 | char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */ |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 1563 | double r; /* Value if eType is SQLITE_FLOAT */ |
| 1564 | i64 i; /* Value if eType is SQLITE_INTEGER */ |
dan | 02fa469 | 2009-08-17 17:06:58 +0000 | [diff] [blame] | 1565 | } u; |
| 1566 | u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */ |
drh | 5c62486 | 2011-09-22 18:46:34 +0000 | [diff] [blame] | 1567 | int nByte; /* Size in byte of text or blob. */ |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 1568 | tRowcnt nEq; /* Est. number of rows where the key equals this sample */ |
| 1569 | tRowcnt nLt; /* Est. number of rows where key is less than this sample */ |
drh | 4e50c5e | 2011-08-13 19:35:19 +0000 | [diff] [blame] | 1570 | tRowcnt nDLt; /* Est. number of distinct keys less than this sample */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1571 | }; |
| 1572 | |
| 1573 | /* |
| 1574 | ** Each token coming out of the lexer is an instance of |
drh | 4b59ab5 | 2002-08-24 18:24:51 +0000 | [diff] [blame] | 1575 | ** this structure. Tokens are also used as part of an expression. |
drh | 4efc475 | 2004-01-16 15:55:37 +0000 | [diff] [blame] | 1576 | ** |
| 1577 | ** Note if Token.z==0 then Token.dyn and Token.n are undefined and |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1578 | ** may contain random values. Do not make any assumptions about Token.dyn |
drh | 4efc475 | 2004-01-16 15:55:37 +0000 | [diff] [blame] | 1579 | ** and Token.n when Token.z==0. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1580 | */ |
| 1581 | struct Token { |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1582 | const char *z; /* Text of the token. Not NULL-terminated! */ |
| 1583 | unsigned int n; /* Number of characters in this token */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1584 | }; |
| 1585 | |
| 1586 | /* |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1587 | ** An instance of this structure contains information needed to generate |
| 1588 | ** code for a SELECT that contains aggregate functions. |
| 1589 | ** |
| 1590 | ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a |
| 1591 | ** pointer to this structure. The Expr.iColumn field is the index in |
| 1592 | ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate |
| 1593 | ** code for that node. |
| 1594 | ** |
| 1595 | ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the |
| 1596 | ** original Select structure that describes the SELECT statement. These |
| 1597 | ** fields do not need to be freed when deallocating the AggInfo structure. |
| 1598 | */ |
| 1599 | struct AggInfo { |
| 1600 | u8 directMode; /* Direct rendering mode means take data directly |
| 1601 | ** from source tables rather than from accumulators */ |
| 1602 | u8 useSortingIdx; /* In direct mode, reference the sorting index rather |
| 1603 | ** than the source table */ |
| 1604 | int sortingIdx; /* Cursor number of the sorting index */ |
dan | 5134d13 | 2011-09-02 10:31:11 +0000 | [diff] [blame] | 1605 | int sortingIdxPTab; /* Cursor number of pseudo-table */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1606 | int nSortingColumn; /* Number of columns in the sorting index */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 1607 | ExprList *pGroupBy; /* The group by clause */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1608 | struct AggInfo_col { /* For each column used in source tables */ |
danielk1977 | 0817d0d | 2007-02-14 09:19:36 +0000 | [diff] [blame] | 1609 | Table *pTab; /* Source table */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1610 | int iTable; /* Cursor number of the source table */ |
| 1611 | int iColumn; /* Column number within the source table */ |
| 1612 | int iSorterColumn; /* Column number in the sorting index */ |
| 1613 | int iMem; /* Memory location that acts as accumulator */ |
drh | 5774b80 | 2005-09-07 22:48:16 +0000 | [diff] [blame] | 1614 | Expr *pExpr; /* The original expression */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1615 | } *aCol; |
| 1616 | int nColumn; /* Number of used entries in aCol[] */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1617 | int nAccumulator; /* Number of columns that show through to the output. |
| 1618 | ** Additional columns are used only as parameters to |
| 1619 | ** aggregate functions */ |
| 1620 | struct AggInfo_func { /* For each aggregate function */ |
| 1621 | Expr *pExpr; /* Expression encoding the function */ |
| 1622 | FuncDef *pFunc; /* The aggregate function implementation */ |
| 1623 | int iMem; /* Memory location that acts as accumulator */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1624 | int iDistinct; /* Ephemeral table used to enforce DISTINCT */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1625 | } *aFunc; |
| 1626 | int nFunc; /* Number of entries in aFunc[] */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1627 | }; |
| 1628 | |
| 1629 | /* |
drh | 8677d30 | 2009-11-04 13:17:14 +0000 | [diff] [blame] | 1630 | ** The datatype ynVar is a signed integer, either 16-bit or 32-bit. |
| 1631 | ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater |
| 1632 | ** than 32767 we have to make it 32-bit. 16-bit is preferred because |
| 1633 | ** it uses less memory in the Expr object, which is a big memory user |
| 1634 | ** in systems with lots of prepared statements. And few applications |
| 1635 | ** need more than about 10 or 20 variables. But some extreme users want |
| 1636 | ** to have prepared statements with over 32767 variables, and for them |
| 1637 | ** the option is available (at compile-time). |
| 1638 | */ |
| 1639 | #if SQLITE_MAX_VARIABLE_NUMBER<=32767 |
drh | 481aa74 | 2009-11-05 18:46:02 +0000 | [diff] [blame] | 1640 | typedef i16 ynVar; |
drh | 8677d30 | 2009-11-04 13:17:14 +0000 | [diff] [blame] | 1641 | #else |
| 1642 | typedef int ynVar; |
| 1643 | #endif |
| 1644 | |
| 1645 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1646 | ** Each node of an expression in the parse tree is an instance |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1647 | ** of this structure. |
| 1648 | ** |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1649 | ** Expr.op is the opcode. The integer parser token codes are reused |
| 1650 | ** as opcodes here. For example, the parser defines TK_GE to be an integer |
| 1651 | ** code representing the ">=" operator. This same integer code is reused |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1652 | ** to represent the greater-than-or-equal-to operator in the expression |
| 1653 | ** tree. |
| 1654 | ** |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1655 | ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, |
| 1656 | ** or TK_STRING), then Expr.token contains the text of the SQL literal. If |
| 1657 | ** the expression is a variable (TK_VARIABLE), then Expr.token contains the |
| 1658 | ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), |
| 1659 | ** then Expr.token contains the name of the function. |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1660 | ** |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1661 | ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a |
| 1662 | ** binary operator. Either or both may be NULL. |
| 1663 | ** |
| 1664 | ** Expr.x.pList is a list of arguments if the expression is an SQL function, |
| 1665 | ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)". |
| 1666 | ** Expr.x.pSelect is used if the expression is a sub-select or an expression of |
| 1667 | ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the |
| 1668 | ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is |
| 1669 | ** valid. |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1670 | ** |
| 1671 | ** An expression of the form ID or ID.ID refers to a column in a table. |
| 1672 | ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is |
| 1673 | ** the integer cursor number of a VDBE cursor pointing to that table and |
| 1674 | ** Expr.iColumn is the column number for the specific column. If the |
| 1675 | ** expression is used as a result in an aggregate SELECT, then the |
| 1676 | ** value is also stored in the Expr.iAgg column in the aggregate so that |
| 1677 | ** it can be accessed after all aggregates are computed. |
| 1678 | ** |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1679 | ** If the expression is an unbound variable marker (a question mark |
| 1680 | ** character '?' in the original SQL) then the Expr.iTable holds the index |
| 1681 | ** number for that variable. |
drh | 22f70c3 | 2002-02-18 01:17:00 +0000 | [diff] [blame] | 1682 | ** |
drh | 1398ad3 | 2005-01-19 23:24:50 +0000 | [diff] [blame] | 1683 | ** If the expression is a subquery then Expr.iColumn holds an integer |
| 1684 | ** register number containing the result of the subquery. If the |
| 1685 | ** subquery gives a constant result, then iTable is -1. If the subquery |
| 1686 | ** gives a different answer at different times during statement processing |
| 1687 | ** then iTable is the address of a subroutine that computes the subquery. |
| 1688 | ** |
danielk1977 | aee18ef | 2005-03-09 12:26:50 +0000 | [diff] [blame] | 1689 | ** If the Expr is of type OP_Column, and the table it is selecting from |
| 1690 | ** is a disk table or the "old.*" pseudo-table, then pTab points to the |
| 1691 | ** corresponding table definition. |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1692 | ** |
| 1693 | ** ALLOCATION NOTES: |
| 1694 | ** |
drh | 12ffee8 | 2009-04-08 13:51:51 +0000 | [diff] [blame] | 1695 | ** Expr objects can use a lot of memory space in database schema. To |
| 1696 | ** help reduce memory requirements, sometimes an Expr object will be |
| 1697 | ** truncated. And to reduce the number of memory allocations, sometimes |
| 1698 | ** two or more Expr objects will be stored in a single memory allocation, |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 1699 | ** together with Expr.zToken strings. |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1700 | ** |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1701 | ** If the EP_Reduced and EP_TokenOnly flags are set when |
drh | 12ffee8 | 2009-04-08 13:51:51 +0000 | [diff] [blame] | 1702 | ** an Expr object is truncated. When EP_Reduced is set, then all |
| 1703 | ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees |
| 1704 | ** are contained within the same memory allocation. Note, however, that |
| 1705 | ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately |
| 1706 | ** allocated, regardless of whether or not EP_Reduced is set. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1707 | */ |
| 1708 | struct Expr { |
drh | 1cc093c | 2002-06-24 22:01:57 +0000 | [diff] [blame] | 1709 | u8 op; /* Operation performed by this node */ |
drh | a9fd84b | 2004-05-18 23:21:35 +0000 | [diff] [blame] | 1710 | char affinity; /* The affinity of the column or 0 if not a column */ |
drh | 1af466e | 2009-03-24 15:31:28 +0000 | [diff] [blame] | 1711 | u16 flags; /* Various flags. EP_* See below */ |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 1712 | union { |
| 1713 | char *zToken; /* Token value. Zero terminated and dequoted */ |
drh | d50ffc4 | 2011-03-08 02:38:28 +0000 | [diff] [blame] | 1714 | int iValue; /* Non-negative integer value if EP_IntValue */ |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 1715 | } u; |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1716 | |
| 1717 | /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no |
| 1718 | ** space is allocated for the fields below this point. An attempt to |
| 1719 | ** access them will result in a segfault or malfunction. |
| 1720 | *********************************************************************/ |
| 1721 | |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1722 | Expr *pLeft; /* Left subnode */ |
| 1723 | Expr *pRight; /* Right subnode */ |
| 1724 | union { |
| 1725 | ExprList *pList; /* Function arguments or in "<expr> IN (<expr-list)" */ |
| 1726 | Select *pSelect; /* Used for sub-selects and "<expr> IN (<select>)" */ |
| 1727 | } x; |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1728 | |
| 1729 | /* If the EP_Reduced flag is set in the Expr.flags mask, then no |
| 1730 | ** space is allocated for the fields below this point. An attempt to |
| 1731 | ** access them will result in a segfault or malfunction. |
| 1732 | *********************************************************************/ |
| 1733 | |
drh | 6ec6549 | 2012-09-13 19:59:09 +0000 | [diff] [blame] | 1734 | #if SQLITE_MAX_EXPR_DEPTH>0 |
| 1735 | int nHeight; /* Height of the tree headed by this node */ |
| 1736 | #endif |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1737 | int iTable; /* TK_COLUMN: cursor number of table holding column |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 1738 | ** TK_REGISTER: register number |
| 1739 | ** TK_TRIGGER: 1 -> new, 0 -> old */ |
drh | 8677d30 | 2009-11-04 13:17:14 +0000 | [diff] [blame] | 1740 | ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid. |
dan | 937d0de | 2009-10-15 18:35:38 +0000 | [diff] [blame] | 1741 | ** TK_VARIABLE: variable number (always >= 1). */ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1742 | i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ |
| 1743 | i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ |
dan | fcd4a15 | 2009-08-19 17:17:00 +0000 | [diff] [blame] | 1744 | u8 flags2; /* Second set of flags. EP2_... */ |
drh | 030796d | 2012-08-23 16:18:10 +0000 | [diff] [blame] | 1745 | u8 op2; /* TK_REGISTER: original value of Expr.op |
| 1746 | ** TK_COLUMN: the value of p5 for OP_Column |
| 1747 | ** TK_AGG_FUNCTION: nesting depth */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1748 | AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 1749 | Table *pTab; /* Table for TK_COLUMN expressions. */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1750 | }; |
| 1751 | |
| 1752 | /* |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 1753 | ** The following are the meanings of bits in the Expr.flags field. |
| 1754 | */ |
drh | 678ccce | 2008-03-31 18:19:54 +0000 | [diff] [blame] | 1755 | #define EP_FromJoin 0x0001 /* Originated in ON or USING clause of a join */ |
| 1756 | #define EP_Agg 0x0002 /* Contains one or more aggregate functions */ |
| 1757 | #define EP_Resolved 0x0004 /* IDs have been resolved to COLUMNs */ |
| 1758 | #define EP_Error 0x0008 /* Expression contains one or more errors */ |
| 1759 | #define EP_Distinct 0x0010 /* Aggregate function with DISTINCT keyword */ |
| 1760 | #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */ |
drh | 24fb627 | 2009-05-01 21:13:36 +0000 | [diff] [blame] | 1761 | #define EP_DblQuoted 0x0040 /* token.z was originally in "..." */ |
drh | 678ccce | 2008-03-31 18:19:54 +0000 | [diff] [blame] | 1762 | #define EP_InfixFunc 0x0080 /* True for an infix function: LIKE, GLOB, etc */ |
drh | ae80dde | 2012-12-06 21:16:43 +0000 | [diff] [blame] | 1763 | #define EP_Collate 0x0100 /* Tree contains a TK_COLLATE opeartor */ |
drh | b6da74e | 2009-12-24 16:00:28 +0000 | [diff] [blame] | 1764 | #define EP_FixedDest 0x0200 /* Result needed in a specific register */ |
| 1765 | #define EP_IntValue 0x0400 /* Integer value contained in u.iValue */ |
| 1766 | #define EP_xIsSelect 0x0800 /* x.pSelect is valid (otherwise x.pList is) */ |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 1767 | #define EP_Hint 0x1000 /* Not used */ |
drh | 678a9aa | 2011-12-10 15:55:01 +0000 | [diff] [blame] | 1768 | #define EP_Reduced 0x2000 /* Expr struct is EXPR_REDUCEDSIZE bytes only */ |
| 1769 | #define EP_TokenOnly 0x4000 /* Expr struct is EXPR_TOKENONLYSIZE bytes only */ |
| 1770 | #define EP_Static 0x8000 /* Held in memory not obtained from malloc() */ |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1771 | |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 1772 | /* |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1773 | ** The following are the meanings of bits in the Expr.flags2 field. |
drh | 1af466e | 2009-03-24 15:31:28 +0000 | [diff] [blame] | 1774 | */ |
drh | 33e619f | 2009-05-28 01:00:55 +0000 | [diff] [blame] | 1775 | #define EP2_MallocedToken 0x0001 /* Need to sqlite3DbFree() Expr.zToken */ |
| 1776 | #define EP2_Irreducible 0x0002 /* Cannot EXPRDUP_REDUCE this Expr */ |
| 1777 | |
| 1778 | /* |
| 1779 | ** The pseudo-routine sqlite3ExprSetIrreducible sets the EP2_Irreducible |
| 1780 | ** flag on an expression structure. This flag is used for VV&A only. The |
| 1781 | ** routine is implemented as a macro that only works when in debugging mode, |
| 1782 | ** so as not to burden production code. |
| 1783 | */ |
| 1784 | #ifdef SQLITE_DEBUG |
| 1785 | # define ExprSetIrreducible(X) (X)->flags2 |= EP2_Irreducible |
| 1786 | #else |
| 1787 | # define ExprSetIrreducible(X) |
| 1788 | #endif |
drh | 1af466e | 2009-03-24 15:31:28 +0000 | [diff] [blame] | 1789 | |
| 1790 | /* |
drh | 1f16230 | 2002-10-27 19:35:33 +0000 | [diff] [blame] | 1791 | ** These macros can be used to test, set, or clear bits in the |
| 1792 | ** Expr.flags field. |
| 1793 | */ |
| 1794 | #define ExprHasProperty(E,P) (((E)->flags&(P))==(P)) |
| 1795 | #define ExprHasAnyProperty(E,P) (((E)->flags&(P))!=0) |
| 1796 | #define ExprSetProperty(E,P) (E)->flags|=(P) |
| 1797 | #define ExprClearProperty(E,P) (E)->flags&=~(P) |
| 1798 | |
| 1799 | /* |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1800 | ** Macros to determine the number of bytes required by a normal Expr |
| 1801 | ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags |
| 1802 | ** and an Expr struct with the EP_TokenOnly flag set. |
| 1803 | */ |
drh | 12ffee8 | 2009-04-08 13:51:51 +0000 | [diff] [blame] | 1804 | #define EXPR_FULLSIZE sizeof(Expr) /* Full size */ |
| 1805 | #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */ |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1806 | #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */ |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1807 | |
| 1808 | /* |
| 1809 | ** Flags passed to the sqlite3ExprDup() function. See the header comment |
| 1810 | ** above sqlite3ExprDup() for details. |
| 1811 | */ |
drh | 12ffee8 | 2009-04-08 13:51:51 +0000 | [diff] [blame] | 1812 | #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */ |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 1813 | |
| 1814 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1815 | ** A list of expressions. Each expression may optionally have a |
| 1816 | ** name. An expr/name combination can be used in several ways, such |
| 1817 | ** as the list of "expr AS ID" fields following a "SELECT" or in the |
| 1818 | ** list of "ID = expr" items in an UPDATE. A list of expressions can |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1819 | ** also be used as the argument to a function, in which case the a.zName |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1820 | ** field is not used. |
drh | 0dde473 | 2012-12-19 13:41:03 +0000 | [diff] [blame] | 1821 | ** |
| 1822 | ** By default the Expr.zSpan field holds a human-readable description of |
| 1823 | ** the expression that is used in the generation of error messages and |
| 1824 | ** column labels. In this case, Expr.zSpan is typically the text of a |
| 1825 | ** column expression as it exists in a SELECT statement. However, if |
| 1826 | ** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name |
drh | 3e3f1a5 | 2013-01-03 00:45:56 +0000 | [diff] [blame] | 1827 | ** of the result column in the form: DATABASE.TABLE.COLUMN. This later |
| 1828 | ** form is used for name resolution with nested FROM clauses. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1829 | */ |
| 1830 | struct ExprList { |
| 1831 | int nExpr; /* Number of expressions on the list */ |
drh | 9d2985c | 2005-09-08 01:58:42 +0000 | [diff] [blame] | 1832 | int iECursor; /* VDBE Cursor associated with this ExprList */ |
drh | d872bb1 | 2012-02-02 01:58:08 +0000 | [diff] [blame] | 1833 | struct ExprList_item { /* For each expression in the list */ |
drh | 0dde473 | 2012-12-19 13:41:03 +0000 | [diff] [blame] | 1834 | Expr *pExpr; /* The list of expressions */ |
| 1835 | char *zName; /* Token associated with this expression */ |
| 1836 | char *zSpan; /* Original text of the expression */ |
| 1837 | u8 sortOrder; /* 1 for DESC or 0 for ASC */ |
| 1838 | unsigned done :1; /* A flag to indicate when processing is finished */ |
drh | 3e3f1a5 | 2013-01-03 00:45:56 +0000 | [diff] [blame] | 1839 | unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */ |
drh | 0dde473 | 2012-12-19 13:41:03 +0000 | [diff] [blame] | 1840 | u16 iOrderByCol; /* For ORDER BY, column number in result set */ |
| 1841 | u16 iAlias; /* Index into Parse.aAlias[] for zName */ |
drh | d872bb1 | 2012-02-02 01:58:08 +0000 | [diff] [blame] | 1842 | } *a; /* Alloc a power of two greater or equal to nExpr */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1843 | }; |
| 1844 | |
| 1845 | /* |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 1846 | ** An instance of this structure is used by the parser to record both |
| 1847 | ** the parse tree for an expression and the span of input text for an |
| 1848 | ** expression. |
| 1849 | */ |
| 1850 | struct ExprSpan { |
| 1851 | Expr *pExpr; /* The expression parse tree */ |
| 1852 | const char *zStart; /* First character of input text */ |
| 1853 | const char *zEnd; /* One character past the end of input text */ |
| 1854 | }; |
| 1855 | |
| 1856 | /* |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1857 | ** An instance of this structure can hold a simple list of identifiers, |
| 1858 | ** such as the list "a,b,c" in the following statements: |
| 1859 | ** |
| 1860 | ** INSERT INTO t(a,b,c) VALUES ...; |
| 1861 | ** CREATE INDEX idx ON t(a,b,c); |
| 1862 | ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; |
| 1863 | ** |
| 1864 | ** The IdList.a.idx field is used when the IdList represents the list of |
| 1865 | ** column names after a table name in an INSERT statement. In the statement |
| 1866 | ** |
| 1867 | ** INSERT INTO t(a,b,c) ... |
| 1868 | ** |
| 1869 | ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1870 | */ |
| 1871 | struct IdList { |
drh | 6d4abfb | 2001-10-22 02:58:08 +0000 | [diff] [blame] | 1872 | struct IdList_item { |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1873 | char *zName; /* Name of the identifier */ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 1874 | int idx; /* Index in some Table.aCol[] of a column named zName */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1875 | } *a; |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 1876 | int nId; /* Number of identifiers on the list */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1877 | }; |
| 1878 | |
| 1879 | /* |
drh | 5166986 | 2004-12-18 18:40:26 +0000 | [diff] [blame] | 1880 | ** The bitmask datatype defined below is used for various optimizations. |
drh | ca83ac5 | 2007-02-01 01:40:44 +0000 | [diff] [blame] | 1881 | ** |
| 1882 | ** Changing this from a 64-bit to a 32-bit type limits the number of |
| 1883 | ** tables in a join to 32 instead of 64. But it also reduces the size |
| 1884 | ** of the library by 738 bytes on ix86. |
drh | 5166986 | 2004-12-18 18:40:26 +0000 | [diff] [blame] | 1885 | */ |
drh | ca83ac5 | 2007-02-01 01:40:44 +0000 | [diff] [blame] | 1886 | typedef u64 Bitmask; |
drh | 5166986 | 2004-12-18 18:40:26 +0000 | [diff] [blame] | 1887 | |
| 1888 | /* |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 1889 | ** The number of bits in a Bitmask. "BMS" means "BitMask Size". |
| 1890 | */ |
| 1891 | #define BMS ((int)(sizeof(Bitmask)*8)) |
| 1892 | |
| 1893 | /* |
drh | 7699d1c | 2013-06-04 12:42:29 +0000 | [diff] [blame^] | 1894 | ** A bit in a Bitmask |
| 1895 | */ |
| 1896 | #define MASKBIT(n) (((Bitmask)1)<<(n)) |
| 1897 | |
| 1898 | /* |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1899 | ** The following structure describes the FROM clause of a SELECT statement. |
| 1900 | ** Each table or subquery in the FROM clause is a separate element of |
| 1901 | ** the SrcList.a[] array. |
drh | d24cc42 | 2003-03-27 12:51:24 +0000 | [diff] [blame] | 1902 | ** |
| 1903 | ** With the addition of multiple database support, the following structure |
| 1904 | ** can also be used to describe a particular table such as the table that |
| 1905 | ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL, |
| 1906 | ** such a table must be a simple name: ID. But in SQLite, the table can |
| 1907 | ** now be identified by a database name, a dot, then the table name: ID.ID. |
drh | c49de5d | 2007-01-19 01:06:01 +0000 | [diff] [blame] | 1908 | ** |
| 1909 | ** The jointype starts out showing the join type between the current table |
| 1910 | ** and the next table on the list. The parser builds the list this way. |
| 1911 | ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each |
| 1912 | ** jointype expresses the join between the table and the previous table. |
drh | 2a6a7ee | 2010-04-07 14:33:07 +0000 | [diff] [blame] | 1913 | ** |
| 1914 | ** In the colUsed field, the high-order bit (bit 63) is set if the table |
| 1915 | ** contains more than 63 columns and the 64-th or later column is used. |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1916 | */ |
| 1917 | struct SrcList { |
drh | 23f98da | 2013-05-21 15:52:07 +0000 | [diff] [blame] | 1918 | u8 nSrc; /* Number of tables or subqueries in the FROM clause */ |
| 1919 | u8 nAlloc; /* Number of entries allocated in a[] below */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1920 | struct SrcList_item { |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 1921 | Schema *pSchema; /* Schema to which this item is fixed */ |
drh | 113088e | 2003-03-20 01:16:58 +0000 | [diff] [blame] | 1922 | char *zDatabase; /* Name of database holding this table */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1923 | char *zName; /* Name of the table */ |
| 1924 | char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ |
drh | daffd0e | 2001-04-11 14:28:42 +0000 | [diff] [blame] | 1925 | Table *pTab; /* An SQL table corresponding to zName */ |
| 1926 | Select *pSelect; /* A SELECT statement used in place of a table name */ |
drh | 5b6a9ed | 2011-09-15 23:58:14 +0000 | [diff] [blame] | 1927 | int addrFillSub; /* Address of subroutine to manifest a subquery */ |
| 1928 | int regReturn; /* Register holding return address of addrFillSub */ |
drh | c49de5d | 2007-01-19 01:06:01 +0000 | [diff] [blame] | 1929 | u8 jointype; /* Type of join between this able and the previous */ |
drh | 21172c4 | 2012-10-30 00:29:07 +0000 | [diff] [blame] | 1930 | unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ |
| 1931 | unsigned isCorrelated :1; /* True if sub-query is correlated */ |
| 1932 | unsigned viaCoroutine :1; /* Implemented as a co-routine */ |
dan | ce7e189 | 2010-12-01 19:00:48 +0000 | [diff] [blame] | 1933 | #ifndef SQLITE_OMIT_EXPLAIN |
| 1934 | u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */ |
| 1935 | #endif |
drh | e68fbe7 | 2007-02-13 12:49:24 +0000 | [diff] [blame] | 1936 | int iCursor; /* The VDBE cursor number used to access this table */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 1937 | Expr *pOn; /* The ON clause of a join */ |
| 1938 | IdList *pUsing; /* The USING clause of a join */ |
danielk1977 | cd38d52 | 2009-01-02 17:33:46 +0000 | [diff] [blame] | 1939 | Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */ |
danielk1977 | 85574e3 | 2008-10-06 05:32:18 +0000 | [diff] [blame] | 1940 | char *zIndex; /* Identifier from "INDEXED BY <zIndex>" clause */ |
| 1941 | Index *pIndex; /* Index structure corresponding to zIndex, if any */ |
drh | 113088e | 2003-03-20 01:16:58 +0000 | [diff] [blame] | 1942 | } a[1]; /* One entry for each identifier on the list */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 1943 | }; |
| 1944 | |
| 1945 | /* |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 1946 | ** Permitted values of the SrcList.a.jointype field |
| 1947 | */ |
| 1948 | #define JT_INNER 0x0001 /* Any kind of inner or cross join */ |
drh | 3dec223 | 2005-09-10 15:28:09 +0000 | [diff] [blame] | 1949 | #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */ |
| 1950 | #define JT_NATURAL 0x0004 /* True for a "natural" join */ |
| 1951 | #define JT_LEFT 0x0008 /* Left outer join */ |
| 1952 | #define JT_RIGHT 0x0010 /* Right outer join */ |
| 1953 | #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */ |
| 1954 | #define JT_ERROR 0x0040 /* unknown or unsupported join type */ |
drh | 01f3f25 | 2002-05-24 16:14:15 +0000 | [diff] [blame] | 1955 | |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1956 | |
| 1957 | /* |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 1958 | ** For each nested loop in a WHERE clause implementation, the WhereInfo |
| 1959 | ** structure contains a single instance of this structure. This structure |
mistachkin | d557843 | 2012-08-25 10:01:29 +0000 | [diff] [blame] | 1960 | ** is intended to be private to the where.c module and should not be |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 1961 | ** access or modified by other modules. |
drh | 6d209d8 | 2006-06-27 01:54:26 +0000 | [diff] [blame] | 1962 | ** |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1963 | ** The pIdxInfo field is used to help pick the best index on a |
| 1964 | ** virtual table. The pIdxInfo pointer contains indexing |
drh | 6d209d8 | 2006-06-27 01:54:26 +0000 | [diff] [blame] | 1965 | ** information for the i-th table in the FROM clause before reordering. |
| 1966 | ** All the pIdxInfo pointers are freed by whereInfoFree() in where.c. |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1967 | ** All other information in the i-th WhereLevel object for the i-th table |
| 1968 | ** after FROM clause ordering. |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 1969 | */ |
| 1970 | struct WhereLevel { |
drh | 29dda4a | 2005-07-21 18:23:20 +0000 | [diff] [blame] | 1971 | int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ |
drh | 29dda4a | 2005-07-21 18:23:20 +0000 | [diff] [blame] | 1972 | int iTabCur; /* The VDBE cursor used to access the table */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 1973 | int iIdxCur; /* The VDBE cursor used to access pIdx */ |
drh | b3190c1 | 2008-12-08 21:37:14 +0000 | [diff] [blame] | 1974 | int addrBrk; /* Jump here to break out of the loop */ |
| 1975 | int addrNxt; /* Jump here to start the next IN combination */ |
| 1976 | int addrCont; /* Jump here to continue with the next loop cycle */ |
| 1977 | int addrFirst; /* First instruction of interior of the loop */ |
drh | 7ba39a9 | 2013-05-30 17:43:19 +0000 | [diff] [blame] | 1978 | u8 iFrom; /* FIXME: Which entry in the FROM clause */ |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1979 | u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */ |
| 1980 | int p1, p2; /* Operands of the opcode used to ends the loop */ |
| 1981 | union { /* Information that depends on plan.wsFlags */ |
| 1982 | struct { |
| 1983 | int nIn; /* Number of entries in aInLoop[] */ |
| 1984 | struct InLoop { |
| 1985 | int iCur; /* The VDBE cursor used by this IN operator */ |
| 1986 | int addrInTop; /* Top of the IN loop */ |
drh | 2d96b93 | 2013-02-08 18:48:23 +0000 | [diff] [blame] | 1987 | u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1988 | } *aInLoop; /* Information about each nested IN operator */ |
| 1989 | } in; /* Used when plan.wsFlags&WHERE_IN_ABLE */ |
drh | d40e208 | 2012-08-24 23:24:15 +0000 | [diff] [blame] | 1990 | Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ |
drh | 111a6a7 | 2008-12-21 03:51:16 +0000 | [diff] [blame] | 1991 | } u; |
drh | a18f3d2 | 2013-05-08 03:05:41 +0000 | [diff] [blame] | 1992 | struct WhereLoop *pWLoop; /* The selected WhereLoop object */ |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 1993 | }; |
| 1994 | |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 1995 | /* |
drh | 336a530 | 2009-04-24 15:46:21 +0000 | [diff] [blame] | 1996 | ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin() |
| 1997 | ** and the WhereInfo.wctrlFlags member. |
drh | 08c88eb | 2008-04-10 13:33:18 +0000 | [diff] [blame] | 1998 | */ |
drh | 6df2acd | 2008-12-28 16:55:25 +0000 | [diff] [blame] | 1999 | #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */ |
| 2000 | #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */ |
| 2001 | #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */ |
| 2002 | #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */ |
drh | 336a530 | 2009-04-24 15:46:21 +0000 | [diff] [blame] | 2003 | #define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */ |
drh | 9ef61f4 | 2011-10-07 14:40:59 +0000 | [diff] [blame] | 2004 | #define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */ |
| 2005 | #define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */ |
| 2006 | #define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */ |
| 2007 | #define WHERE_AND_ONLY 0x0080 /* Don't use indices for OR terms */ |
drh | 319f677 | 2013-05-14 15:31:07 +0000 | [diff] [blame] | 2008 | #define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */ |
danielk1977 | a9d1ccb | 2008-01-05 17:39:29 +0000 | [diff] [blame] | 2009 | |
drh | 6b56344 | 2001-11-07 16:48:26 +0000 | [diff] [blame] | 2010 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2011 | ** The WHERE clause processing routine has two halves. The |
| 2012 | ** first part does the start of the WHERE loop and the second |
| 2013 | ** half does the tail of the WHERE loop. An instance of |
| 2014 | ** this structure is returned by the first half and passed |
| 2015 | ** into the second half to give some continuity. |
| 2016 | */ |
| 2017 | struct WhereInfo { |
drh | 46ec5b6 | 2012-09-24 15:30:54 +0000 | [diff] [blame] | 2018 | Parse *pParse; /* Parsing and code generating context */ |
| 2019 | SrcList *pTabList; /* List of tables in the join */ |
drh | 6b7157b | 2013-05-10 02:00:35 +0000 | [diff] [blame] | 2020 | ExprList *pOrderBy; /* The ORDER BY clause or NULL */ |
| 2021 | ExprList *pDistinct; /* DISTINCT ON values, or NULL */ |
drh | 88da644 | 2013-05-27 17:59:37 +0000 | [diff] [blame] | 2022 | Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ |
drh | 46ec5b6 | 2012-09-24 15:30:54 +0000 | [diff] [blame] | 2023 | u16 nOBSat; /* Number of ORDER BY terms satisfied by indices */ |
| 2024 | u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ |
| 2025 | u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE/DELETE */ |
| 2026 | u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */ |
| 2027 | u8 eDistinct; /* One of the WHERE_DISTINCT_* values below */ |
| 2028 | int iTop; /* The very beginning of the WHERE loop */ |
| 2029 | int iContinue; /* Jump here to continue with next record */ |
| 2030 | int iBreak; /* Jump here to break out of the loop */ |
| 2031 | int nLevel; /* Number of nested loop */ |
| 2032 | struct WhereClause *pWC; /* Decomposition of the WHERE clause */ |
drh | f1b5f5b | 2013-05-02 00:15:01 +0000 | [diff] [blame] | 2033 | struct WhereLoop *pLoops; /* List of all WhereLoop objects */ |
drh | 46ec5b6 | 2012-09-24 15:30:54 +0000 | [diff] [blame] | 2034 | double savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ |
| 2035 | double nRowOut; /* Estimated number of output rows */ |
| 2036 | WhereLevel a[1]; /* Information about each nest loop in WHERE */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2037 | }; |
| 2038 | |
drh | e8e4af7 | 2012-09-21 00:04:28 +0000 | [diff] [blame] | 2039 | /* Allowed values for WhereInfo.eDistinct and DistinctCtx.eTnctType */ |
| 2040 | #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */ |
| 2041 | #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */ |
| 2042 | #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */ |
| 2043 | #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */ |
dan | 38cc40c | 2011-06-30 20:17:15 +0000 | [diff] [blame] | 2044 | |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2045 | /* |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2046 | ** A NameContext defines a context in which to resolve table and column |
| 2047 | ** names. The context consists of a list of tables (the pSrcList) field and |
| 2048 | ** a list of named expression (pEList). The named expression list may |
| 2049 | ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or |
| 2050 | ** to the table being operated on by INSERT, UPDATE, or DELETE. The |
| 2051 | ** pEList corresponds to the result set of a SELECT and is NULL for |
| 2052 | ** other statements. |
| 2053 | ** |
| 2054 | ** NameContexts can be nested. When resolving names, the inner-most |
| 2055 | ** context is searched first. If no match is found, the next outer |
| 2056 | ** context is checked. If there is still no match, the next context |
| 2057 | ** is checked. This process continues until either a match is found |
| 2058 | ** or all contexts are check. When a match is found, the nRef member of |
| 2059 | ** the context containing the match is incremented. |
| 2060 | ** |
| 2061 | ** Each subquery gets a new NameContext. The pNext field points to the |
| 2062 | ** NameContext in the parent query. Thus the process of scanning the |
| 2063 | ** NameContext list corresponds to searching through successively outer |
| 2064 | ** subqueries looking for a match. |
| 2065 | */ |
| 2066 | struct NameContext { |
| 2067 | Parse *pParse; /* The parser */ |
| 2068 | SrcList *pSrcList; /* One or more tables used to resolve names */ |
| 2069 | ExprList *pEList; /* Optional list of named expressions */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 2070 | AggInfo *pAggInfo; /* Information about aggregates at this level */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2071 | NameContext *pNext; /* Next outer name context. NULL for outermost */ |
drh | a51009b | 2012-05-21 19:11:25 +0000 | [diff] [blame] | 2072 | int nRef; /* Number of names resolved by this context */ |
| 2073 | int nErr; /* Number of errors encountered while resolving names */ |
| 2074 | u8 ncFlags; /* Zero or more NC_* flags defined below */ |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 2075 | }; |
| 2076 | |
| 2077 | /* |
drh | a51009b | 2012-05-21 19:11:25 +0000 | [diff] [blame] | 2078 | ** Allowed values for the NameContext, ncFlags field. |
| 2079 | */ |
| 2080 | #define NC_AllowAgg 0x01 /* Aggregate functions are allowed here */ |
| 2081 | #define NC_HasAgg 0x02 /* One or more aggregate functions seen */ |
| 2082 | #define NC_IsCheck 0x04 /* True if resolving names in a CHECK constraint */ |
drh | 3a8c4be | 2012-05-21 20:13:39 +0000 | [diff] [blame] | 2083 | #define NC_InAggFunc 0x08 /* True if analyzing arguments to an agg func */ |
drh | a3a5bd9 | 2013-04-13 19:59:58 +0000 | [diff] [blame] | 2084 | #define NC_AsMaybe 0x10 /* Resolve to AS terms of the result set only |
| 2085 | ** if no other resolution is available */ |
drh | a51009b | 2012-05-21 19:11:25 +0000 | [diff] [blame] | 2086 | |
| 2087 | /* |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 2088 | ** An instance of the following structure contains all information |
| 2089 | ** needed to generate code for a single SELECT statement. |
drh | a76b5df | 2002-02-23 02:32:10 +0000 | [diff] [blame] | 2090 | ** |
drh | d11d382 | 2002-06-21 23:01:49 +0000 | [diff] [blame] | 2091 | ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0. |
| 2092 | ** If there is a LIMIT clause, the parser sets nLimit to the value of the |
| 2093 | ** limit and nOffset to the value of the offset (or 0 if there is not |
| 2094 | ** offset). But later on, nLimit and nOffset become the memory locations |
| 2095 | ** in the VDBE that record the limit and offset counters. |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2096 | ** |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2097 | ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes. |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2098 | ** These addresses must be stored so that we can go back and fill in |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 2099 | ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2100 | ** the number of columns in P2 can be computed at the same time |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2101 | ** as the OP_OpenEphm instruction is coded because not |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2102 | ** enough information about the compound query is known at that point. |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2103 | ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences |
drh | 2c79733 | 2012-09-20 14:26:22 +0000 | [diff] [blame] | 2104 | ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2105 | ** sequences for the ORDER BY clause. |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 2106 | */ |
| 2107 | struct Select { |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 2108 | ExprList *pEList; /* The fields of the result */ |
drh | 7b58dae | 2003-07-20 01:16:46 +0000 | [diff] [blame] | 2109 | u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2110 | u16 selFlags; /* Various SF_* values */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2111 | int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ |
| 2112 | int addrOpenEphm[3]; /* OP_OpenEphem opcodes related to this select */ |
| 2113 | double nSelectRow; /* Estimated number of result rows */ |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 2114 | SrcList *pSrc; /* The FROM clause */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 2115 | Expr *pWhere; /* The WHERE clause */ |
| 2116 | ExprList *pGroupBy; /* The GROUP BY clause */ |
| 2117 | Expr *pHaving; /* The HAVING clause */ |
| 2118 | ExprList *pOrderBy; /* The ORDER BY clause */ |
drh | 967e8b7 | 2000-06-21 13:59:10 +0000 | [diff] [blame] | 2119 | Select *pPrior; /* Prior select in a compound select statement */ |
drh | 1e28129 | 2007-12-13 03:45:07 +0000 | [diff] [blame] | 2120 | Select *pNext; /* Next select to the left in a compound */ |
drh | 0342b1f | 2005-09-01 03:07:44 +0000 | [diff] [blame] | 2121 | Select *pRightmost; /* Right-most select in a compound select statement */ |
danielk1977 | a2dc3b1 | 2005-02-05 12:48:48 +0000 | [diff] [blame] | 2122 | Expr *pLimit; /* LIMIT expression. NULL means not used. */ |
| 2123 | Expr *pOffset; /* OFFSET expression. NULL means not used. */ |
drh | 9bb61fe | 2000-06-05 16:01:39 +0000 | [diff] [blame] | 2124 | }; |
| 2125 | |
| 2126 | /* |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2127 | ** Allowed values for Select.selFlags. The "SF" prefix stands for |
| 2128 | ** "Select Flag". |
| 2129 | */ |
drh | 21172c4 | 2012-10-30 00:29:07 +0000 | [diff] [blame] | 2130 | #define SF_Distinct 0x0001 /* Output should be DISTINCT */ |
| 2131 | #define SF_Resolved 0x0002 /* Identifiers have been resolved */ |
| 2132 | #define SF_Aggregate 0x0004 /* Contains aggregate functions */ |
| 2133 | #define SF_UsesEphemeral 0x0008 /* Uses the OpenEphemeral opcode */ |
| 2134 | #define SF_Expanded 0x0010 /* sqlite3SelectExpand() called on this */ |
| 2135 | #define SF_HasTypeInfo 0x0020 /* FROM subqueries have Table metadata */ |
| 2136 | #define SF_UseSorter 0x0040 /* Sort using a sorter */ |
| 2137 | #define SF_Values 0x0080 /* Synthesized from VALUES clause */ |
| 2138 | #define SF_Materialize 0x0100 /* Force materialization of views */ |
drh | 832ee3d | 2012-12-18 19:36:11 +0000 | [diff] [blame] | 2139 | #define SF_NestedFrom 0x0200 /* Part of a parenthesized FROM clause */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2140 | |
| 2141 | |
| 2142 | /* |
| 2143 | ** The results of a select can be distributed in several ways. The |
| 2144 | ** "SRT" prefix means "SELECT Result Type". |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 2145 | */ |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 2146 | #define SRT_Union 1 /* Store result as keys in an index */ |
| 2147 | #define SRT_Except 2 /* Remove result from a UNION index */ |
danielk1977 | 9ed1dfa | 2008-01-02 17:11:14 +0000 | [diff] [blame] | 2148 | #define SRT_Exists 3 /* Store 1 if the result is not empty */ |
| 2149 | #define SRT_Discard 4 /* Do not save the results anywhere */ |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 2150 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 2151 | /* The ORDER BY clause is ignored for all of the above */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2152 | #define IgnorableOrderby(X) ((X->eDest)<=SRT_Discard) |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 2153 | |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2154 | #define SRT_Output 5 /* Output each row of result */ |
danielk1977 | 9ed1dfa | 2008-01-02 17:11:14 +0000 | [diff] [blame] | 2155 | #define SRT_Mem 6 /* Store result in a memory cell */ |
danielk1977 | 0cdc022 | 2008-06-26 18:04:03 +0000 | [diff] [blame] | 2156 | #define SRT_Set 7 /* Store results as keys in an index */ |
danielk1977 | 9ed1dfa | 2008-01-02 17:11:14 +0000 | [diff] [blame] | 2157 | #define SRT_Table 8 /* Store result as data with an automatic rowid */ |
| 2158 | #define SRT_EphemTab 9 /* Create transient tab and store like SRT_Table */ |
drh | e00ee6e | 2008-06-20 15:24:01 +0000 | [diff] [blame] | 2159 | #define SRT_Coroutine 10 /* Generate a single row of result */ |
drh | 2282792 | 2000-06-06 17:27:05 +0000 | [diff] [blame] | 2160 | |
| 2161 | /* |
drh | 634d81d | 2012-09-20 15:41:31 +0000 | [diff] [blame] | 2162 | ** An instance of this object describes where to put of the results of |
| 2163 | ** a SELECT statement. |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2164 | */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2165 | struct SelectDest { |
drh | 634d81d | 2012-09-20 15:41:31 +0000 | [diff] [blame] | 2166 | u8 eDest; /* How to dispose of the results. On of SRT_* above. */ |
| 2167 | char affSdst; /* Affinity used when eDest==SRT_Set */ |
drh | 2b596da | 2012-07-23 21:43:19 +0000 | [diff] [blame] | 2168 | int iSDParm; /* A parameter used by the eDest disposal method */ |
| 2169 | int iSdst; /* Base register where results are written */ |
| 2170 | int nSdst; /* Number of registers allocated */ |
danielk1977 | 6c8c8ce | 2008-01-02 16:27:09 +0000 | [diff] [blame] | 2171 | }; |
| 2172 | |
| 2173 | /* |
drh | 0b9f50d | 2009-06-23 20:28:53 +0000 | [diff] [blame] | 2174 | ** During code generation of statements that do inserts into AUTOINCREMENT |
| 2175 | ** tables, the following information is attached to the Table.u.autoInc.p |
| 2176 | ** pointer of each autoincrement table to record some side information that |
| 2177 | ** the code generator needs. We have to keep per-table autoincrement |
| 2178 | ** information in case inserts are down within triggers. Triggers do not |
| 2179 | ** normally coordinate their activities, but we do need to coordinate the |
| 2180 | ** loading and saving of autoincrement information. |
| 2181 | */ |
| 2182 | struct AutoincInfo { |
| 2183 | AutoincInfo *pNext; /* Next info block in a list of them all */ |
| 2184 | Table *pTab; /* Table this info block refers to */ |
| 2185 | int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ |
| 2186 | int regCtr; /* Memory register holding the rowid counter */ |
| 2187 | }; |
| 2188 | |
| 2189 | /* |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2190 | ** Size of the column cache |
| 2191 | */ |
| 2192 | #ifndef SQLITE_N_COLCACHE |
| 2193 | # define SQLITE_N_COLCACHE 10 |
| 2194 | #endif |
| 2195 | |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 2196 | /* |
| 2197 | ** At least one instance of the following structure is created for each |
| 2198 | ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE |
| 2199 | ** statement. All such objects are stored in the linked list headed at |
| 2200 | ** Parse.pTriggerPrg and deleted once statement compilation has been |
| 2201 | ** completed. |
| 2202 | ** |
| 2203 | ** A Vdbe sub-program that implements the body and WHEN clause of trigger |
| 2204 | ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of |
| 2205 | ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. |
| 2206 | ** The Parse.pTriggerPrg list never contains two entries with the same |
| 2207 | ** values for both pTrigger and orconf. |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2208 | ** |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 2209 | ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2210 | ** accessed (or set to 0 for triggers fired as a result of INSERT |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 2211 | ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to |
| 2212 | ** a mask of new.* columns used by the program. |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 2213 | */ |
| 2214 | struct TriggerPrg { |
| 2215 | Trigger *pTrigger; /* Trigger this program was coded from */ |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 2216 | TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2217 | SubProgram *pProgram; /* Program implementing pTrigger/orconf */ |
| 2218 | int orconf; /* Default ON CONFLICT policy */ |
| 2219 | u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2220 | }; |
| 2221 | |
drh | 6412358 | 2011-04-02 20:01:02 +0000 | [diff] [blame] | 2222 | /* |
| 2223 | ** The yDbMask datatype for the bitmask of all attached databases. |
| 2224 | */ |
drh | 01c7dc8 | 2011-03-23 18:22:34 +0000 | [diff] [blame] | 2225 | #if SQLITE_MAX_ATTACHED>30 |
drh | 6412358 | 2011-04-02 20:01:02 +0000 | [diff] [blame] | 2226 | typedef sqlite3_uint64 yDbMask; |
drh | 01c7dc8 | 2011-03-23 18:22:34 +0000 | [diff] [blame] | 2227 | #else |
drh | 6412358 | 2011-04-02 20:01:02 +0000 | [diff] [blame] | 2228 | typedef unsigned int yDbMask; |
drh | 01c7dc8 | 2011-03-23 18:22:34 +0000 | [diff] [blame] | 2229 | #endif |
| 2230 | |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2231 | /* |
drh | f57b339 | 2001-10-08 13:22:32 +0000 | [diff] [blame] | 2232 | ** An SQL parser context. A copy of this structure is passed through |
| 2233 | ** the parser and down into all the parser action routine in order to |
| 2234 | ** carry around information that is global to the entire parse. |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 2235 | ** |
| 2236 | ** The structure is divided into two parts. When the parser and code |
| 2237 | ** generate call themselves recursively, the first part of the structure |
| 2238 | ** is constant but the second part is reset at the beginning and end of |
| 2239 | ** each recursion. |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 2240 | ** |
| 2241 | ** The nTableLock and aTableLock variables are only used if the shared-cache |
| 2242 | ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are |
| 2243 | ** used to store the set of table-locks required by the statement being |
| 2244 | ** compiled. Function sqlite3TableLock() is used to add entries to the |
| 2245 | ** list. |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2246 | */ |
| 2247 | struct Parse { |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2248 | sqlite3 *db; /* The main database structure */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2249 | char *zErrMsg; /* An error message */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2250 | Vdbe *pVdbe; /* An engine for executing database bytecode */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2251 | int rc; /* Return code from execution */ |
drh | 836faa4 | 2003-01-11 13:30:57 +0000 | [diff] [blame] | 2252 | u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ |
drh | a6ecd33 | 2004-06-10 00:29:09 +0000 | [diff] [blame] | 2253 | u8 checkSchema; /* Causes schema cookie check after an error */ |
drh | 205f48e | 2004-11-05 00:43:11 +0000 | [diff] [blame] | 2254 | u8 nested; /* Number of nested calls to the parser/code generator */ |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 2255 | u8 nTempReg; /* Number of temporary registers in aTempReg[] */ |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 2256 | u8 nTempInUse; /* Number of aTempReg[] currently checked out */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2257 | u8 nColCache; /* Number of entries in aColCache[] */ |
| 2258 | u8 iColCache; /* Next entry in aColCache[] to replace */ |
| 2259 | u8 isMultiWrite; /* True if statement may modify/insert multiple rows */ |
| 2260 | u8 mayAbort; /* True if statement may throw an ABORT exception */ |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 2261 | int aTempReg[8]; /* Holding area for temporary registers */ |
| 2262 | int nRangeReg; /* Size of the temporary register block */ |
| 2263 | int iRangeReg; /* First register in temporary register block */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2264 | int nErr; /* Number of errors seen */ |
drh | 832508b | 2002-03-02 17:04:07 +0000 | [diff] [blame] | 2265 | int nTab; /* Number of previously allocated VDBE cursors */ |
drh | 19a775c | 2000-06-05 18:54:46 +0000 | [diff] [blame] | 2266 | int nMem; /* Number of memory cells used so far */ |
drh | fef5208 | 2000-06-06 01:50:43 +0000 | [diff] [blame] | 2267 | int nSet; /* Number of sets used so far */ |
dan | 1d8cb21 | 2011-12-09 13:24:16 +0000 | [diff] [blame] | 2268 | int nOnce; /* Number of OP_Once instructions so far */ |
drh | aa9b896 | 2008-01-08 02:57:55 +0000 | [diff] [blame] | 2269 | int ckBase; /* Base register of data during check constraints */ |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2270 | int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */ |
| 2271 | int iCacheCnt; /* Counter used to generate aColCache[].lru values */ |
drh | 2f7794c | 2008-04-01 03:27:39 +0000 | [diff] [blame] | 2272 | struct yColCache { |
drh | e55cbd7 | 2008-03-31 23:48:03 +0000 | [diff] [blame] | 2273 | int iTable; /* Table cursor number */ |
| 2274 | int iColumn; /* Table column number */ |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2275 | u8 tempReg; /* iReg is a temp register that needs to be freed */ |
| 2276 | int iLevel; /* Nesting level */ |
| 2277 | int iReg; /* Reg with value of this column. 0 means none. */ |
| 2278 | int lru; /* Least recently used entry has the smallest value */ |
| 2279 | } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */ |
drh | 6412358 | 2011-04-02 20:01:02 +0000 | [diff] [blame] | 2280 | yDbMask writeMask; /* Start a write transaction on these databases */ |
| 2281 | yDbMask cookieMask; /* Bitmask of schema verified databases */ |
drh | fcd35c7 | 2005-05-21 02:48:08 +0000 | [diff] [blame] | 2282 | int cookieGoto; /* Address of OP_Goto to cookie verifier subroutine */ |
drh | c797d4d | 2007-05-08 01:08:49 +0000 | [diff] [blame] | 2283 | int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2284 | int regRowid; /* Register holding rowid of CREATE TABLE entry */ |
| 2285 | int regRoot; /* Register holding root page number for new objects */ |
| 2286 | int nMaxArg; /* Max args passed to user function by sub-program */ |
drh | 2938f92 | 2012-03-07 19:13:29 +0000 | [diff] [blame] | 2287 | Token constraintName;/* Name of the constraint currently being parsed */ |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 2288 | #ifndef SQLITE_OMIT_SHARED_CACHE |
| 2289 | int nTableLock; /* Number of locks in aTableLock */ |
| 2290 | TableLock *aTableLock; /* Required table locks for shared-cache mode */ |
| 2291 | #endif |
drh | 0b9f50d | 2009-06-23 20:28:53 +0000 | [diff] [blame] | 2292 | AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 2293 | |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2294 | /* Information used while coding trigger programs. */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2295 | Parse *pToplevel; /* Parse structure for main program (or NULL) */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2296 | Table *pTriggerTab; /* Table triggers are being coded for */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2297 | double nQueryLoop; /* Estimated number of iterations of a query */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2298 | u32 oldmask; /* Mask of old.* columns referenced */ |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 2299 | u32 newmask; /* Mask of new.* columns referenced */ |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2300 | u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ |
| 2301 | u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ |
dan | d66c830 | 2009-09-28 14:49:01 +0000 | [diff] [blame] | 2302 | u8 disableTriggers; /* True to disable triggers */ |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2303 | |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 2304 | /* Above is constant between recursions. Below is reset before and after |
| 2305 | ** each recursion */ |
| 2306 | |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2307 | int nVar; /* Number of '?' variables seen in the SQL so far */ |
| 2308 | int nzVar; /* Number of available slots in azVar[] */ |
| 2309 | u8 explain; /* True if the EXPLAIN flag is found on the query */ |
| 2310 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 2311 | u8 declareVtab; /* True if inside sqlite3_declare_vtab() */ |
| 2312 | int nVtabLock; /* Number of virtual tables to lock */ |
| 2313 | #endif |
| 2314 | int nAlias; /* Number of aliased result set columns */ |
| 2315 | int nHeight; /* Expression tree height of current sub-select */ |
| 2316 | #ifndef SQLITE_OMIT_EXPLAIN |
| 2317 | int iSelectId; /* ID of current select for EXPLAIN output */ |
| 2318 | int iNextSelectId; /* Next available select ID for EXPLAIN output */ |
| 2319 | #endif |
| 2320 | char **azVar; /* Pointers to names of parameters */ |
| 2321 | Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */ |
| 2322 | int *aAlias; /* Register used to hold aliased result */ |
| 2323 | const char *zTail; /* All SQL text past the last semicolon parsed */ |
| 2324 | Table *pNewTable; /* A table being constructed by CREATE TABLE */ |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 2325 | Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ |
drh | f197484 | 2004-11-05 03:56:00 +0000 | [diff] [blame] | 2326 | const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2327 | Token sNameToken; /* Token with unqualified schema object name */ |
| 2328 | Token sLastToken; /* The last token parsed */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2329 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2330 | Token sArg; /* Complete text of a module argument */ |
| 2331 | Table **apVtabLock; /* Pointer to virtual tables needing locking */ |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 2332 | #endif |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2333 | Table *pZombieTab; /* List of Table objects to delete after code gen */ |
| 2334 | TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2335 | }; |
| 2336 | |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2337 | /* |
| 2338 | ** Return true if currently inside an sqlite3_declare_vtab() call. |
| 2339 | */ |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 2340 | #ifdef SQLITE_OMIT_VIRTUALTABLE |
| 2341 | #define IN_DECLARE_VTAB 0 |
| 2342 | #else |
| 2343 | #define IN_DECLARE_VTAB (pParse->declareVtab) |
| 2344 | #endif |
| 2345 | |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2346 | /* |
drh | 85e2096 | 2003-04-25 17:52:11 +0000 | [diff] [blame] | 2347 | ** An instance of the following structure can be declared on a stack and used |
| 2348 | ** to save the Parse.zAuthContext value so that it can be restored later. |
| 2349 | */ |
| 2350 | struct AuthContext { |
| 2351 | const char *zAuthContext; /* Put saved Parse.zAuthContext here */ |
| 2352 | Parse *pParse; /* The Parse structure */ |
| 2353 | }; |
| 2354 | |
| 2355 | /* |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 2356 | ** Bitfield flags for P5 value in various opcodes. |
rdc | b0c374f | 2004-02-20 22:53:38 +0000 | [diff] [blame] | 2357 | */ |
drh | 3e9ca09 | 2009-09-08 01:14:48 +0000 | [diff] [blame] | 2358 | #define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */ |
| 2359 | #define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */ |
| 2360 | #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */ |
| 2361 | #define OPFLAG_APPEND 0x08 /* This is likely to be an append */ |
| 2362 | #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */ |
| 2363 | #define OPFLAG_CLEARCACHE 0x20 /* Clear pseudo-table cache in OP_Column */ |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 2364 | #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */ |
| 2365 | #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */ |
dan | 428c218 | 2012-08-06 18:50:11 +0000 | [diff] [blame] | 2366 | #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */ |
| 2367 | #define OPFLAG_P2ISREG 0x02 /* P2 to OP_Open** is a register number */ |
drh | 953f761 | 2012-12-07 22:18:54 +0000 | [diff] [blame] | 2368 | #define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */ |
rdc | b0c374f | 2004-02-20 22:53:38 +0000 | [diff] [blame] | 2369 | |
| 2370 | /* |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2371 | * Each trigger present in the database schema is stored as an instance of |
| 2372 | * struct Trigger. |
| 2373 | * |
| 2374 | * Pointers to instances of struct Trigger are stored in two ways. |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2375 | * 1. In the "trigHash" hash table (part of the sqlite3* that represents the |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2376 | * database). This allows Trigger structures to be retrieved by name. |
| 2377 | * 2. All triggers associated with a single table form a linked list, using the |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 2378 | * pNext member of struct Trigger. A pointer to the first element of the |
| 2379 | * linked list is stored as the "pTrigger" member of the associated |
| 2380 | * struct Table. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2381 | * |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 2382 | * The "step_list" member points to the first element of a linked list |
| 2383 | * containing the SQL statements specified as the trigger program. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2384 | */ |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 2385 | struct Trigger { |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2386 | char *zName; /* The name of the trigger */ |
drh | dc37945 | 2002-05-15 12:45:43 +0000 | [diff] [blame] | 2387 | char *table; /* The table or view to which the trigger applies */ |
drh | f0f258b | 2003-04-21 18:48:45 +0000 | [diff] [blame] | 2388 | u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 2389 | u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ |
shane | 467bcf3 | 2008-11-24 20:01:32 +0000 | [diff] [blame] | 2390 | Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */ |
drh | dc37945 | 2002-05-15 12:45:43 +0000 | [diff] [blame] | 2391 | IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger, |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2392 | the <column-list> is stored here */ |
danielk1977 | e501b89 | 2006-01-09 06:29:47 +0000 | [diff] [blame] | 2393 | Schema *pSchema; /* Schema containing the trigger */ |
| 2394 | Schema *pTabSchema; /* Schema containing the table */ |
drh | dc37945 | 2002-05-15 12:45:43 +0000 | [diff] [blame] | 2395 | TriggerStep *step_list; /* Link list of trigger program steps */ |
drh | dc37945 | 2002-05-15 12:45:43 +0000 | [diff] [blame] | 2396 | Trigger *pNext; /* Next trigger associated with the table */ |
danielk1977 | c3f9bad | 2002-05-15 08:30:12 +0000 | [diff] [blame] | 2397 | }; |
| 2398 | |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2399 | /* |
drh | dca7684 | 2004-12-07 14:06:13 +0000 | [diff] [blame] | 2400 | ** A trigger is either a BEFORE or an AFTER trigger. The following constants |
| 2401 | ** determine which. |
| 2402 | ** |
| 2403 | ** If there are multiple triggers, you might of some BEFORE and some AFTER. |
| 2404 | ** In that cases, the constants below can be ORed together. |
| 2405 | */ |
| 2406 | #define TRIGGER_BEFORE 1 |
| 2407 | #define TRIGGER_AFTER 2 |
| 2408 | |
| 2409 | /* |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2410 | * An instance of struct TriggerStep is used to store a single SQL statement |
| 2411 | * that is a part of a trigger-program. |
| 2412 | * |
| 2413 | * Instances of struct TriggerStep are stored in a singly linked list (linked |
| 2414 | * using the "pNext" member) referenced by the "step_list" member of the |
| 2415 | * associated struct Trigger instance. The first element of the linked list is |
| 2416 | * the first step of the trigger-program. |
| 2417 | * |
| 2418 | * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or |
| 2419 | * "SELECT" statement. The meanings of the other members is determined by the |
| 2420 | * value of "op" as follows: |
| 2421 | * |
| 2422 | * (op == TK_INSERT) |
| 2423 | * orconf -> stores the ON CONFLICT algorithm |
| 2424 | * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then |
| 2425 | * this stores a pointer to the SELECT statement. Otherwise NULL. |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2426 | * target -> A token holding the quoted name of the table to insert into. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2427 | * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then |
| 2428 | * this stores values to be inserted. Otherwise NULL. |
| 2429 | * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ... |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 2430 | * statement, then this stores the column-names to be |
| 2431 | * inserted into. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2432 | * |
| 2433 | * (op == TK_DELETE) |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2434 | * target -> A token holding the quoted name of the table to delete from. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2435 | * pWhere -> The WHERE clause of the DELETE statement if one is specified. |
| 2436 | * Otherwise NULL. |
| 2437 | * |
| 2438 | * (op == TK_UPDATE) |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2439 | * target -> A token holding the quoted name of the table to update rows of. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2440 | * pWhere -> The WHERE clause of the UPDATE statement if one is specified. |
| 2441 | * Otherwise NULL. |
| 2442 | * pExprList -> A list of the columns to update and the expressions to update |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2443 | * them to. See sqlite3Update() documentation of "pChanges" |
drh | ad3cab5 | 2002-05-24 02:04:32 +0000 | [diff] [blame] | 2444 | * argument. |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2445 | * |
| 2446 | */ |
| 2447 | struct TriggerStep { |
drh | b1819a0 | 2009-07-03 15:37:27 +0000 | [diff] [blame] | 2448 | u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ |
| 2449 | u8 orconf; /* OE_Rollback etc. */ |
drh | a69d916 | 2003-04-17 22:57:53 +0000 | [diff] [blame] | 2450 | Trigger *pTrig; /* The trigger that this step is a part of */ |
drh | b1819a0 | 2009-07-03 15:37:27 +0000 | [diff] [blame] | 2451 | Select *pSelect; /* SELECT statment or RHS of INSERT INTO .. SELECT ... */ |
| 2452 | Token target; /* Target table for DELETE, UPDATE, INSERT */ |
| 2453 | Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ |
| 2454 | ExprList *pExprList; /* SET clause for UPDATE. VALUES clause for INSERT */ |
| 2455 | IdList *pIdList; /* Column names for INSERT */ |
drh | 187e4c6 | 2006-02-27 22:22:27 +0000 | [diff] [blame] | 2456 | TriggerStep *pNext; /* Next in the link-list */ |
| 2457 | TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ |
danielk1977 | d99bc93 | 2002-05-16 00:13:12 +0000 | [diff] [blame] | 2458 | }; |
| 2459 | |
| 2460 | /* |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 2461 | ** The following structure contains information used by the sqliteFix... |
| 2462 | ** routines as they walk the parse tree to make database references |
| 2463 | ** explicit. |
| 2464 | */ |
| 2465 | typedef struct DbFixer DbFixer; |
| 2466 | struct DbFixer { |
| 2467 | Parse *pParse; /* The parsing context. Error messages written here */ |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 2468 | Schema *pSchema; /* Fix items to this schema */ |
drh | f26e09c | 2003-05-31 16:21:12 +0000 | [diff] [blame] | 2469 | const char *zDb; /* Make sure all objects are contained in this database */ |
| 2470 | const char *zType; /* Type of the container - used for error messages */ |
| 2471 | const Token *pName; /* Name of the container - used for error messages */ |
| 2472 | }; |
| 2473 | |
| 2474 | /* |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 2475 | ** An objected used to accumulate the text of a string where we |
| 2476 | ** do not necessarily know how big the string will be in the end. |
| 2477 | */ |
| 2478 | struct StrAccum { |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2479 | sqlite3 *db; /* Optional database for lookaside. Can be NULL */ |
| 2480 | char *zBase; /* A base allocation. Not from malloc. */ |
| 2481 | char *zText; /* The string collected so far */ |
| 2482 | int nChar; /* Length of the string so far */ |
| 2483 | int nAlloc; /* Amount of space allocated in zText */ |
drh | bb4957f | 2008-03-20 14:03:29 +0000 | [diff] [blame] | 2484 | int mxAlloc; /* Maximum allowed string length */ |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 2485 | u8 mallocFailed; /* Becomes true if any memory allocation fails */ |
drh | b975598 | 2010-07-24 16:34:37 +0000 | [diff] [blame] | 2486 | u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */ |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 2487 | u8 tooBig; /* Becomes true if string size exceeds limits */ |
| 2488 | }; |
| 2489 | |
| 2490 | /* |
drh | 234c39d | 2004-07-24 03:30:47 +0000 | [diff] [blame] | 2491 | ** A pointer to this structure is used to communicate information |
| 2492 | ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback. |
| 2493 | */ |
| 2494 | typedef struct { |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2495 | sqlite3 *db; /* The database being initialized */ |
drh | 234c39d | 2004-07-24 03:30:47 +0000 | [diff] [blame] | 2496 | char **pzErrMsg; /* Error message stored here */ |
drh | a451017 | 2012-02-02 15:50:17 +0000 | [diff] [blame] | 2497 | int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ |
drh | 15ca1df | 2006-07-26 13:43:30 +0000 | [diff] [blame] | 2498 | int rc; /* Result code stored here */ |
drh | 234c39d | 2004-07-24 03:30:47 +0000 | [diff] [blame] | 2499 | } InitData; |
| 2500 | |
drh | b6c2989 | 2004-11-22 19:12:19 +0000 | [diff] [blame] | 2501 | /* |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 2502 | ** Structure containing global configuration data for the SQLite library. |
drh | 3358979 | 2008-06-18 13:27:46 +0000 | [diff] [blame] | 2503 | ** |
| 2504 | ** This structure also contains some state information. |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 2505 | */ |
| 2506 | struct Sqlite3Config { |
drh | fec00ea | 2008-06-14 16:56:21 +0000 | [diff] [blame] | 2507 | int bMemstat; /* True to enable memory status */ |
| 2508 | int bCoreMutex; /* True to enable core mutexing */ |
| 2509 | int bFullMutex; /* True to enable full mutexing */ |
dan | cd74b61 | 2011-04-22 19:37:32 +0000 | [diff] [blame] | 2510 | int bOpenUri; /* True to interpret filenames as URIs */ |
drh | de9a7b8 | 2012-09-17 20:44:46 +0000 | [diff] [blame] | 2511 | int bUseCis; /* Use covering indices for full-scans */ |
drh | 0a687d1 | 2008-07-08 14:52:07 +0000 | [diff] [blame] | 2512 | int mxStrlen; /* Maximum string length */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2513 | int szLookaside; /* Default lookaside buffer size */ |
| 2514 | int nLookaside; /* Default lookaside buffer count */ |
drh | fec00ea | 2008-06-14 16:56:21 +0000 | [diff] [blame] | 2515 | sqlite3_mem_methods m; /* Low-level memory allocation interface */ |
danielk1977 | 6d2ab0e | 2008-06-17 17:21:18 +0000 | [diff] [blame] | 2516 | sqlite3_mutex_methods mutex; /* Low-level mutex interface */ |
dan | 22e21ff | 2011-11-08 20:08:44 +0000 | [diff] [blame] | 2517 | sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */ |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 2518 | void *pHeap; /* Heap storage space */ |
drh | 3358979 | 2008-06-18 13:27:46 +0000 | [diff] [blame] | 2519 | int nHeap; /* Size of pHeap[] */ |
| 2520 | int mnReq, mxReq; /* Min and max heap requests sizes */ |
drh | 9b4c59f | 2013-04-15 17:03:42 +0000 | [diff] [blame] | 2521 | sqlite3_int64 szMmap; /* mmap() space per open file */ |
| 2522 | sqlite3_int64 mxMmap; /* Maximum value for szMmap */ |
drh | 3358979 | 2008-06-18 13:27:46 +0000 | [diff] [blame] | 2523 | void *pScratch; /* Scratch memory */ |
| 2524 | int szScratch; /* Size of each scratch buffer */ |
| 2525 | int nScratch; /* Number of scratch buffers */ |
| 2526 | void *pPage; /* Page cache memory */ |
| 2527 | int szPage; /* Size of each page in pPage[] */ |
| 2528 | int nPage; /* Number of pages in pPage[] */ |
drh | 1875f7a | 2008-12-08 18:19:17 +0000 | [diff] [blame] | 2529 | int mxParserStack; /* maximum depth of the parser stack */ |
| 2530 | int sharedCacheEnabled; /* true if shared-cache mode enabled */ |
| 2531 | /* The above might be initialized to non-zero. The following need to always |
| 2532 | ** initially be zero, however. */ |
danielk1977 | 71bc31c | 2008-06-26 08:29:34 +0000 | [diff] [blame] | 2533 | int isInit; /* True after initialization has finished */ |
danielk1977 | 502b4e0 | 2008-09-02 14:07:24 +0000 | [diff] [blame] | 2534 | int inProgress; /* True while initialization in progress */ |
dan | e1ab219 | 2009-08-17 15:16:19 +0000 | [diff] [blame] | 2535 | int isMutexInit; /* True after mutexes are initialized */ |
danielk1977 | 71bc31c | 2008-06-26 08:29:34 +0000 | [diff] [blame] | 2536 | int isMallocInit; /* True after malloc is initialized */ |
dan | e1ab219 | 2009-08-17 15:16:19 +0000 | [diff] [blame] | 2537 | int isPCacheInit; /* True after malloc is initialized */ |
danielk1977 | 71bc31c | 2008-06-26 08:29:34 +0000 | [diff] [blame] | 2538 | sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */ |
drh | 93ed56d | 2008-08-12 15:21:11 +0000 | [diff] [blame] | 2539 | int nRefInitMutex; /* Number of users of pInitMutex */ |
drh | 3f28070 | 2010-02-18 18:45:09 +0000 | [diff] [blame] | 2540 | void (*xLog)(void*,int,const char*); /* Function for logging */ |
| 2541 | void *pLogArg; /* First argument to xLog() */ |
dan | c17d696 | 2011-06-21 12:47:30 +0000 | [diff] [blame] | 2542 | int bLocaltimeFault; /* True to fail localtime() calls */ |
dan | ac45593 | 2012-11-26 19:50:41 +0000 | [diff] [blame] | 2543 | #ifdef SQLITE_ENABLE_SQLLOG |
| 2544 | void(*xSqllog)(void*,sqlite3*,const char*, int); |
| 2545 | void *pSqllogArg; |
| 2546 | #endif |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 2547 | }; |
| 2548 | |
| 2549 | /* |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2550 | ** Context pointer passed down through the tree-walk. |
| 2551 | */ |
| 2552 | struct Walker { |
| 2553 | int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */ |
| 2554 | int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */ |
| 2555 | Parse *pParse; /* Parser context. */ |
drh | 030796d | 2012-08-23 16:18:10 +0000 | [diff] [blame] | 2556 | int walkerDepth; /* Number of subqueries */ |
drh | aa87f9a | 2013-04-25 00:57:10 +0000 | [diff] [blame] | 2557 | u8 bSelectDepthFirst; /* Do subqueries first */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2558 | union { /* Extra data for callback */ |
| 2559 | NameContext *pNC; /* Naming context */ |
| 2560 | int i; /* Integer value */ |
drh | 374fdce | 2012-04-17 16:38:53 +0000 | [diff] [blame] | 2561 | SrcList *pSrcList; /* FROM clause */ |
drh | 030796d | 2012-08-23 16:18:10 +0000 | [diff] [blame] | 2562 | struct SrcCount *pSrcCount; /* Counting column references */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2563 | } u; |
| 2564 | }; |
| 2565 | |
| 2566 | /* Forward declarations */ |
| 2567 | int sqlite3WalkExpr(Walker*, Expr*); |
| 2568 | int sqlite3WalkExprList(Walker*, ExprList*); |
| 2569 | int sqlite3WalkSelect(Walker*, Select*); |
| 2570 | int sqlite3WalkSelectExpr(Walker*, Select*); |
| 2571 | int sqlite3WalkSelectFrom(Walker*, Select*); |
| 2572 | |
| 2573 | /* |
| 2574 | ** Return code from the parse-tree walking primitives and their |
| 2575 | ** callbacks. |
| 2576 | */ |
drh | 2bf90f1 | 2008-12-09 13:04:29 +0000 | [diff] [blame] | 2577 | #define WRC_Continue 0 /* Continue down into children */ |
| 2578 | #define WRC_Prune 1 /* Omit children but continue walking siblings */ |
| 2579 | #define WRC_Abort 2 /* Abandon the tree walk */ |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2580 | |
| 2581 | /* |
drh | 6615095 | 2007-07-23 19:12:41 +0000 | [diff] [blame] | 2582 | ** Assuming zIn points to the first byte of a UTF-8 character, |
| 2583 | ** advance zIn to point to the first byte of the next UTF-8 character. |
drh | 4a91911 | 2007-05-15 11:55:09 +0000 | [diff] [blame] | 2584 | */ |
drh | 4a91911 | 2007-05-15 11:55:09 +0000 | [diff] [blame] | 2585 | #define SQLITE_SKIP_UTF8(zIn) { \ |
| 2586 | if( (*(zIn++))>=0xc0 ){ \ |
| 2587 | while( (*zIn & 0xc0)==0x80 ){ zIn++; } \ |
| 2588 | } \ |
| 2589 | } |
| 2590 | |
drh | 4a91911 | 2007-05-15 11:55:09 +0000 | [diff] [blame] | 2591 | /* |
drh | 9978c97 | 2010-02-23 17:36:32 +0000 | [diff] [blame] | 2592 | ** The SQLITE_*_BKPT macros are substitutes for the error codes with |
| 2593 | ** the same name but without the _BKPT suffix. These macros invoke |
| 2594 | ** routines that report the line-number on which the error originated |
| 2595 | ** using sqlite3_log(). The routines also provide a convenient place |
| 2596 | ** to set a debugger breakpoint. |
drh | 4928570 | 2005-09-17 15:20:26 +0000 | [diff] [blame] | 2597 | */ |
drh | 9978c97 | 2010-02-23 17:36:32 +0000 | [diff] [blame] | 2598 | int sqlite3CorruptError(int); |
| 2599 | int sqlite3MisuseError(int); |
| 2600 | int sqlite3CantopenError(int); |
| 2601 | #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__) |
| 2602 | #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__) |
| 2603 | #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__) |
| 2604 | |
drh | 4928570 | 2005-09-17 15:20:26 +0000 | [diff] [blame] | 2605 | |
| 2606 | /* |
drh | b4a1fed | 2010-02-03 19:55:13 +0000 | [diff] [blame] | 2607 | ** FTS4 is really an extension for FTS3. It is enabled using the |
| 2608 | ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all |
| 2609 | ** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3. |
| 2610 | */ |
| 2611 | #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) |
| 2612 | # define SQLITE_ENABLE_FTS3 |
| 2613 | #endif |
| 2614 | |
| 2615 | /* |
drh | 79f02ce | 2009-05-07 14:11:52 +0000 | [diff] [blame] | 2616 | ** The ctype.h header is needed for non-ASCII systems. It is also |
| 2617 | ** needed by FTS3 when FTS3 is included in the amalgamation. |
| 2618 | */ |
| 2619 | #if !defined(SQLITE_ASCII) || \ |
| 2620 | (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION)) |
| 2621 | # include <ctype.h> |
| 2622 | #endif |
| 2623 | |
| 2624 | /* |
danielk1977 | 78ca0e7 | 2009-01-20 16:53:39 +0000 | [diff] [blame] | 2625 | ** The following macros mimic the standard library functions toupper(), |
| 2626 | ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The |
| 2627 | ** sqlite versions only work for ASCII characters, regardless of locale. |
| 2628 | */ |
| 2629 | #ifdef SQLITE_ASCII |
| 2630 | # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20)) |
| 2631 | # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01) |
drh | dc86e2b | 2009-01-24 11:30:42 +0000 | [diff] [blame] | 2632 | # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06) |
| 2633 | # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02) |
danielk1977 | 78ca0e7 | 2009-01-20 16:53:39 +0000 | [diff] [blame] | 2634 | # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04) |
| 2635 | # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08) |
| 2636 | # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)]) |
| 2637 | #else |
danielk1977 | 78ca0e7 | 2009-01-20 16:53:39 +0000 | [diff] [blame] | 2638 | # define sqlite3Toupper(x) toupper((unsigned char)(x)) |
| 2639 | # define sqlite3Isspace(x) isspace((unsigned char)(x)) |
| 2640 | # define sqlite3Isalnum(x) isalnum((unsigned char)(x)) |
drh | dc86e2b | 2009-01-24 11:30:42 +0000 | [diff] [blame] | 2641 | # define sqlite3Isalpha(x) isalpha((unsigned char)(x)) |
danielk1977 | 78ca0e7 | 2009-01-20 16:53:39 +0000 | [diff] [blame] | 2642 | # define sqlite3Isdigit(x) isdigit((unsigned char)(x)) |
| 2643 | # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x)) |
| 2644 | # define sqlite3Tolower(x) tolower((unsigned char)(x)) |
| 2645 | #endif |
| 2646 | |
| 2647 | /* |
drh | 7589723 | 2000-05-29 14:26:00 +0000 | [diff] [blame] | 2648 | ** Internal function prototypes |
| 2649 | */ |
drh | 3fa9730 | 2012-02-22 16:58:36 +0000 | [diff] [blame] | 2650 | #define sqlite3StrICmp sqlite3_stricmp |
drh | ea67883 | 2008-12-10 19:26:22 +0000 | [diff] [blame] | 2651 | int sqlite3Strlen30(const char*); |
danielk1977 | ee0484c | 2009-07-28 16:44:26 +0000 | [diff] [blame] | 2652 | #define sqlite3StrNICmp sqlite3_strnicmp |
danielk1977 | 2e588c7 | 2005-12-09 14:25:08 +0000 | [diff] [blame] | 2653 | |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 2654 | int sqlite3MallocInit(void); |
drh | fec00ea | 2008-06-14 16:56:21 +0000 | [diff] [blame] | 2655 | void sqlite3MallocEnd(void); |
| 2656 | void *sqlite3Malloc(int); |
| 2657 | void *sqlite3MallocZero(int); |
| 2658 | void *sqlite3DbMallocZero(sqlite3*, int); |
| 2659 | void *sqlite3DbMallocRaw(sqlite3*, int); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2660 | char *sqlite3DbStrDup(sqlite3*,const char*); |
| 2661 | char *sqlite3DbStrNDup(sqlite3*,const char*, int); |
drh | fec00ea | 2008-06-14 16:56:21 +0000 | [diff] [blame] | 2662 | void *sqlite3Realloc(void*, int); |
drh | 97c8ec3 | 2007-08-27 21:49:34 +0000 | [diff] [blame] | 2663 | void *sqlite3DbReallocOrFree(sqlite3 *, void *, int); |
danielk1977 | a1644fd | 2007-08-29 12:31:25 +0000 | [diff] [blame] | 2664 | void *sqlite3DbRealloc(sqlite3 *, void *, int); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2665 | void sqlite3DbFree(sqlite3*, void*); |
| 2666 | int sqlite3MallocSize(void*); |
| 2667 | int sqlite3DbMallocSize(sqlite3*, void*); |
drh | facf030 | 2008-06-17 15:12:00 +0000 | [diff] [blame] | 2668 | void *sqlite3ScratchMalloc(int); |
| 2669 | void sqlite3ScratchFree(void*); |
| 2670 | void *sqlite3PageMalloc(int); |
| 2671 | void sqlite3PageFree(void*); |
drh | fec00ea | 2008-06-14 16:56:21 +0000 | [diff] [blame] | 2672 | void sqlite3MemSetDefault(void); |
danielk1977 | 171bfed | 2008-06-23 09:50:50 +0000 | [diff] [blame] | 2673 | void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); |
drh | 50d1b5f | 2010-08-27 12:21:06 +0000 | [diff] [blame] | 2674 | int sqlite3HeapNearlyFull(void); |
danielk1977 | 2e588c7 | 2005-12-09 14:25:08 +0000 | [diff] [blame] | 2675 | |
drh | e7b34707 | 2009-06-01 18:18:20 +0000 | [diff] [blame] | 2676 | /* |
| 2677 | ** On systems with ample stack space and that support alloca(), make |
| 2678 | ** use of alloca() to obtain space for large automatic objects. By default, |
| 2679 | ** obtain space from malloc(). |
| 2680 | ** |
| 2681 | ** The alloca() routine never returns NULL. This will cause code paths |
| 2682 | ** that deal with sqlite3StackAlloc() failures to be unreachable. |
| 2683 | */ |
| 2684 | #ifdef SQLITE_USE_ALLOCA |
| 2685 | # define sqlite3StackAllocRaw(D,N) alloca(N) |
| 2686 | # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N) |
| 2687 | # define sqlite3StackFree(D,P) |
| 2688 | #else |
| 2689 | # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N) |
| 2690 | # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N) |
| 2691 | # define sqlite3StackFree(D,P) sqlite3DbFree(D,P) |
| 2692 | #endif |
| 2693 | |
danielk1977 | f3d3c27 | 2008-11-19 16:52:44 +0000 | [diff] [blame] | 2694 | #ifdef SQLITE_ENABLE_MEMSYS3 |
| 2695 | const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); |
| 2696 | #endif |
| 2697 | #ifdef SQLITE_ENABLE_MEMSYS5 |
| 2698 | const sqlite3_mem_methods *sqlite3MemGetMemsys5(void); |
| 2699 | #endif |
| 2700 | |
| 2701 | |
drh | 18472fa | 2008-10-07 15:25:48 +0000 | [diff] [blame] | 2702 | #ifndef SQLITE_MUTEX_OMIT |
dan | 558814f | 2010-06-02 05:53:53 +0000 | [diff] [blame] | 2703 | sqlite3_mutex_methods const *sqlite3DefaultMutex(void); |
| 2704 | sqlite3_mutex_methods const *sqlite3NoopMutex(void); |
drh | 65bbf29 | 2008-06-19 01:03:17 +0000 | [diff] [blame] | 2705 | sqlite3_mutex *sqlite3MutexAlloc(int); |
| 2706 | int sqlite3MutexInit(void); |
| 2707 | int sqlite3MutexEnd(void); |
| 2708 | #endif |
danielk1977 | 6d2ab0e | 2008-06-17 17:21:18 +0000 | [diff] [blame] | 2709 | |
drh | f714199 | 2008-06-19 00:16:08 +0000 | [diff] [blame] | 2710 | int sqlite3StatusValue(int); |
| 2711 | void sqlite3StatusAdd(int, int); |
| 2712 | void sqlite3StatusSet(int, int); |
| 2713 | |
drh | 85c8f29 | 2010-01-13 17:39:53 +0000 | [diff] [blame] | 2714 | #ifndef SQLITE_OMIT_FLOATING_POINT |
| 2715 | int sqlite3IsNaN(double); |
| 2716 | #else |
| 2717 | # define sqlite3IsNaN(X) 0 |
| 2718 | #endif |
drh | 0de3ae9 | 2008-04-28 16:55:26 +0000 | [diff] [blame] | 2719 | |
drh | f089aa4 | 2008-07-08 19:34:06 +0000 | [diff] [blame] | 2720 | void sqlite3VXPrintf(StrAccum*, int, const char*, va_list); |
drh | c7bc4fd | 2009-11-25 18:03:42 +0000 | [diff] [blame] | 2721 | #ifndef SQLITE_OMIT_TRACE |
| 2722 | void sqlite3XPrintf(StrAccum*, const char*, ...); |
| 2723 | #endif |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2724 | char *sqlite3MPrintf(sqlite3*,const char*, ...); |
| 2725 | char *sqlite3VMPrintf(sqlite3*,const char*, va_list); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2726 | char *sqlite3MAppendf(sqlite3*,char*,const char*,...); |
drh | 87cc3b3 | 2007-05-08 21:45:27 +0000 | [diff] [blame] | 2727 | #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) |
| 2728 | void sqlite3DebugPrintf(const char*, ...); |
drh | d919fe1 | 2007-12-11 19:34:44 +0000 | [diff] [blame] | 2729 | #endif |
| 2730 | #if defined(SQLITE_TEST) |
drh | e8f52c5 | 2008-07-12 14:52:20 +0000 | [diff] [blame] | 2731 | void *sqlite3TestTextToPtr(const char*); |
drh | 87cc3b3 | 2007-05-08 21:45:27 +0000 | [diff] [blame] | 2732 | #endif |
drh | 7e02e5e | 2011-12-06 19:44:51 +0000 | [diff] [blame] | 2733 | |
| 2734 | /* Output formatting for SQLITE_TESTCTRL_EXPLAIN */ |
drh | 678a9aa | 2011-12-10 15:55:01 +0000 | [diff] [blame] | 2735 | #if defined(SQLITE_ENABLE_TREE_EXPLAIN) |
drh | 7e02e5e | 2011-12-06 19:44:51 +0000 | [diff] [blame] | 2736 | void sqlite3ExplainBegin(Vdbe*); |
| 2737 | void sqlite3ExplainPrintf(Vdbe*, const char*, ...); |
| 2738 | void sqlite3ExplainNL(Vdbe*); |
| 2739 | void sqlite3ExplainPush(Vdbe*); |
| 2740 | void sqlite3ExplainPop(Vdbe*); |
| 2741 | void sqlite3ExplainFinish(Vdbe*); |
| 2742 | void sqlite3ExplainSelect(Vdbe*, Select*); |
| 2743 | void sqlite3ExplainExpr(Vdbe*, Expr*); |
| 2744 | void sqlite3ExplainExprList(Vdbe*, ExprList*); |
| 2745 | const char *sqlite3VdbeExplanation(Vdbe*); |
| 2746 | #else |
| 2747 | # define sqlite3ExplainBegin(X) |
| 2748 | # define sqlite3ExplainSelect(A,B) |
| 2749 | # define sqlite3ExplainExpr(A,B) |
| 2750 | # define sqlite3ExplainExprList(A,B) |
| 2751 | # define sqlite3ExplainFinish(X) |
| 2752 | # define sqlite3VdbeExplanation(X) 0 |
| 2753 | #endif |
| 2754 | |
| 2755 | |
drh | f089aa4 | 2008-07-08 19:34:06 +0000 | [diff] [blame] | 2756 | void sqlite3SetString(char **, sqlite3*, const char*, ...); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2757 | void sqlite3ErrorMsg(Parse*, const char*, ...); |
drh | 24fb627 | 2009-05-01 21:13:36 +0000 | [diff] [blame] | 2758 | int sqlite3Dequote(char*); |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 2759 | int sqlite3KeywordCode(const unsigned char*, int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2760 | int sqlite3RunParser(Parse*, const char*, char **); |
drh | 8024205 | 2004-06-09 00:48:12 +0000 | [diff] [blame] | 2761 | void sqlite3FinishCoding(Parse*); |
drh | 892d317 | 2008-01-10 03:46:36 +0000 | [diff] [blame] | 2762 | int sqlite3GetTempReg(Parse*); |
| 2763 | void sqlite3ReleaseTempReg(Parse*,int); |
| 2764 | int sqlite3GetTempRange(Parse*,int); |
| 2765 | void sqlite3ReleaseTempRange(Parse*,int,int); |
drh | cdc6955 | 2011-12-06 13:24:59 +0000 | [diff] [blame] | 2766 | void sqlite3ClearTempRegCache(Parse*); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2767 | Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int); |
| 2768 | Expr *sqlite3Expr(sqlite3*,int,const char*); |
| 2769 | void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2770 | Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 2771 | Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2772 | Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*); |
drh | fa6bc00 | 2004-09-07 16:19:52 +0000 | [diff] [blame] | 2773 | void sqlite3ExprAssignVarNumber(Parse*, Expr*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2774 | void sqlite3ExprDelete(sqlite3*, Expr*); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2775 | ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*); |
| 2776 | void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int); |
| 2777 | void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2778 | void sqlite3ExprListDelete(sqlite3*, ExprList*); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2779 | int sqlite3Init(sqlite3*, char**); |
drh | 234c39d | 2004-07-24 03:30:47 +0000 | [diff] [blame] | 2780 | int sqlite3InitCallback(void*, int, char**, char**); |
danielk1977 | 91cf71b | 2004-06-26 06:37:06 +0000 | [diff] [blame] | 2781 | void sqlite3Pragma(Parse*,Token*,Token*,Token*,int); |
drh | 81028a4 | 2012-05-15 18:28:27 +0000 | [diff] [blame] | 2782 | void sqlite3ResetAllSchemasOfConnection(sqlite3*); |
| 2783 | void sqlite3ResetOneSchema(sqlite3*,int); |
| 2784 | void sqlite3CollapseDatabaseArray(sqlite3*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2785 | void sqlite3BeginParse(Parse*,int); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2786 | void sqlite3CommitInternalChanges(sqlite3*); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2787 | Table *sqlite3ResultSetOfSelect(Parse*,Select*); |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 2788 | void sqlite3OpenMasterTable(Parse *, int); |
danielk1977 | f1a381e | 2006-06-16 08:01:02 +0000 | [diff] [blame] | 2789 | void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2790 | void sqlite3AddColumn(Parse*,Token*); |
| 2791 | void sqlite3AddNotNull(Parse*, int); |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 2792 | void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int); |
drh | ffe07b2 | 2005-11-03 00:41:17 +0000 | [diff] [blame] | 2793 | void sqlite3AddCheckConstraint(Parse*, Expr*); |
drh | 487e262 | 2005-06-25 18:42:14 +0000 | [diff] [blame] | 2794 | void sqlite3AddColumnType(Parse*,Token*); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 2795 | void sqlite3AddDefaultValue(Parse*,ExprSpan*); |
danielk1977 | 3900250 | 2007-11-12 09:50:26 +0000 | [diff] [blame] | 2796 | void sqlite3AddCollateType(Parse*, Token*); |
danielk1977 | 19a8e7e | 2005-03-17 05:03:38 +0000 | [diff] [blame] | 2797 | void sqlite3EndTable(Parse*,Token*,Token*,Select*); |
drh | 522c26f | 2011-05-07 14:40:29 +0000 | [diff] [blame] | 2798 | int sqlite3ParseUri(const char*,const char*,unsigned int*, |
| 2799 | sqlite3_vfs**,char**,char **); |
drh | 421377e | 2012-03-15 21:28:54 +0000 | [diff] [blame] | 2800 | Btree *sqlite3DbNameToBtree(sqlite3*,const char*); |
dan | 1d8cb21 | 2011-12-09 13:24:16 +0000 | [diff] [blame] | 2801 | int sqlite3CodeOnce(Parse *); |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2802 | |
drh | f5e7bb5 | 2008-02-18 14:47:33 +0000 | [diff] [blame] | 2803 | Bitvec *sqlite3BitvecCreate(u32); |
| 2804 | int sqlite3BitvecTest(Bitvec*, u32); |
| 2805 | int sqlite3BitvecSet(Bitvec*, u32); |
drh | e98c904 | 2009-06-02 21:31:38 +0000 | [diff] [blame] | 2806 | void sqlite3BitvecClear(Bitvec*, u32, void*); |
drh | f5e7bb5 | 2008-02-18 14:47:33 +0000 | [diff] [blame] | 2807 | void sqlite3BitvecDestroy(Bitvec*); |
danielk1977 | bea2a94 | 2009-01-20 17:06:27 +0000 | [diff] [blame] | 2808 | u32 sqlite3BitvecSize(Bitvec*); |
drh | 3088d59 | 2008-03-21 16:45:47 +0000 | [diff] [blame] | 2809 | int sqlite3BitvecBuiltinTest(int,int*); |
drh | f5e7bb5 | 2008-02-18 14:47:33 +0000 | [diff] [blame] | 2810 | |
drh | 3d4501e | 2008-12-04 20:40:10 +0000 | [diff] [blame] | 2811 | RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int); |
| 2812 | void sqlite3RowSetClear(RowSet*); |
| 2813 | void sqlite3RowSetInsert(RowSet*, i64); |
drh | 733bf1b | 2009-04-22 00:47:00 +0000 | [diff] [blame] | 2814 | int sqlite3RowSetTest(RowSet*, u8 iBatch, i64); |
drh | 3d4501e | 2008-12-04 20:40:10 +0000 | [diff] [blame] | 2815 | int sqlite3RowSetNext(RowSet*, i64*); |
| 2816 | |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 2817 | void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int); |
danielk1977 | fe3fcbe2 | 2006-06-12 12:08:45 +0000 | [diff] [blame] | 2818 | |
| 2819 | #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2820 | int sqlite3ViewGetColumnNames(Parse*,Table*); |
| 2821 | #else |
| 2822 | # define sqlite3ViewGetColumnNames(A,B) 0 |
| 2823 | #endif |
| 2824 | |
drh | a073384 | 2005-12-29 01:11:36 +0000 | [diff] [blame] | 2825 | void sqlite3DropTable(Parse*, SrcList*, int, int); |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 2826 | void sqlite3CodeDropTable(Parse*, Table*, int, int); |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 2827 | void sqlite3DeleteTable(sqlite3*, Table*); |
drh | 0b9f50d | 2009-06-23 20:28:53 +0000 | [diff] [blame] | 2828 | #ifndef SQLITE_OMIT_AUTOINCREMENT |
| 2829 | void sqlite3AutoincrementBegin(Parse *pParse); |
| 2830 | void sqlite3AutoincrementEnd(Parse *pParse); |
| 2831 | #else |
| 2832 | # define sqlite3AutoincrementBegin(X) |
| 2833 | # define sqlite3AutoincrementEnd(X) |
| 2834 | #endif |
drh | 5f08526 | 2012-09-15 13:29:23 +0000 | [diff] [blame] | 2835 | int sqlite3CodeCoroutine(Parse*, Select*, SelectDest*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2836 | void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int); |
drh | 6c53515 | 2012-02-02 03:38:30 +0000 | [diff] [blame] | 2837 | void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2838 | IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2839 | int sqlite3IdListIndex(IdList*,const char*); |
drh | a78c22c | 2008-11-11 18:28:58 +0000 | [diff] [blame] | 2840 | SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2841 | SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*); |
danielk1977 | b1c685b | 2008-10-06 16:18:39 +0000 | [diff] [blame] | 2842 | SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, |
danielk1977 | 85574e3 | 2008-10-06 05:32:18 +0000 | [diff] [blame] | 2843 | Token*, Select*, Expr*, IdList*); |
danielk1977 | b1c685b | 2008-10-06 16:18:39 +0000 | [diff] [blame] | 2844 | void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); |
| 2845 | int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); |
drh | 61dfc31 | 2006-12-16 16:25:15 +0000 | [diff] [blame] | 2846 | void sqlite3SrcListShiftJoinType(SrcList*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2847 | void sqlite3SrcListAssignCursors(Parse*, SrcList*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2848 | void sqlite3IdListDelete(sqlite3*, IdList*); |
| 2849 | void sqlite3SrcListDelete(sqlite3*, SrcList*); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 2850 | Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*, |
drh | 4d91a70 | 2006-01-04 15:54:36 +0000 | [diff] [blame] | 2851 | Token*, int, int); |
| 2852 | void sqlite3DropIndex(Parse*, SrcList*, int); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2853 | int sqlite3Select(Parse*, Select*, SelectDest*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2854 | Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*, |
drh | 832ee3d | 2012-12-18 19:36:11 +0000 | [diff] [blame] | 2855 | Expr*,ExprList*,u16,Expr*,Expr*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2856 | void sqlite3SelectDelete(sqlite3*, Select*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2857 | Table *sqlite3SrcListLookup(Parse*, SrcList*); |
| 2858 | int sqlite3IsReadOnly(Parse*, Table*, int); |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 2859 | void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int); |
shane | 273f619 | 2008-10-10 04:34:16 +0000 | [diff] [blame] | 2860 | #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) |
drh | 4bde370 | 2013-02-19 18:34:12 +0000 | [diff] [blame] | 2861 | Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,Expr*,char*); |
shane | 4281bd4 | 2008-10-07 05:27:11 +0000 | [diff] [blame] | 2862 | #endif |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2863 | void sqlite3DeleteFrom(Parse*, SrcList*, Expr*); |
| 2864 | void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int); |
drh | 46ec5b6 | 2012-09-24 15:30:54 +0000 | [diff] [blame] | 2865 | WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2866 | void sqlite3WhereEnd(WhereInfo*); |
drh | a748fdc | 2012-03-28 01:34:47 +0000 | [diff] [blame] | 2867 | int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8); |
drh | 5c092e8 | 2010-05-14 19:24:02 +0000 | [diff] [blame] | 2868 | void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int); |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 2869 | void sqlite3ExprCodeMove(Parse*, int, int, int); |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2870 | void sqlite3ExprCacheStore(Parse*, int, int, int); |
| 2871 | void sqlite3ExprCachePush(Parse*); |
| 2872 | void sqlite3ExprCachePop(Parse*, int); |
drh | f49f352 | 2009-12-30 14:12:38 +0000 | [diff] [blame] | 2873 | void sqlite3ExprCacheRemove(Parse*, int, int); |
drh | ceea332 | 2009-04-23 13:22:42 +0000 | [diff] [blame] | 2874 | void sqlite3ExprCacheClear(Parse*); |
drh | da250ea | 2008-04-01 05:07:14 +0000 | [diff] [blame] | 2875 | void sqlite3ExprCacheAffinityChange(Parse*, int, int); |
drh | 389a1ad | 2008-01-03 23:44:53 +0000 | [diff] [blame] | 2876 | int sqlite3ExprCode(Parse*, Expr*, int); |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 2877 | int sqlite3ExprCodeTemp(Parse*, Expr*, int*); |
drh | 678ccce | 2008-03-31 18:19:54 +0000 | [diff] [blame] | 2878 | int sqlite3ExprCodeTarget(Parse*, Expr*, int); |
drh | 2dcef11 | 2008-01-12 19:03:48 +0000 | [diff] [blame] | 2879 | int sqlite3ExprCodeAndCache(Parse*, Expr*, int); |
drh | 678ccce | 2008-03-31 18:19:54 +0000 | [diff] [blame] | 2880 | void sqlite3ExprCodeConstants(Parse*, Expr*); |
drh | 191b54c | 2008-04-15 12:14:21 +0000 | [diff] [blame] | 2881 | int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2882 | void sqlite3ExprIfTrue(Parse*, Expr*, int, int); |
| 2883 | void sqlite3ExprIfFalse(Parse*, Expr*, int, int); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2884 | Table *sqlite3FindTable(sqlite3*,const char*, const char*); |
drh | ca42411 | 2008-01-25 15:04:48 +0000 | [diff] [blame] | 2885 | Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*); |
dan | 41fb5cd | 2012-10-04 19:33:00 +0000 | [diff] [blame] | 2886 | Table *sqlite3LocateTableItem(Parse*,int isView,struct SrcList_item *); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2887 | Index *sqlite3FindIndex(sqlite3*,const char*, const char*); |
| 2888 | void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*); |
| 2889 | void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*); |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 2890 | void sqlite3Vacuum(Parse*); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2891 | int sqlite3RunVacuum(char**, sqlite3*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2892 | char *sqlite3NameFromToken(sqlite3*, Token*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2893 | int sqlite3ExprCompare(Expr*, Expr*); |
drh | 8c6f666 | 2010-04-26 19:17:26 +0000 | [diff] [blame] | 2894 | int sqlite3ExprListCompare(ExprList*, ExprList*); |
drh | d2b3e23 | 2008-01-23 14:51:49 +0000 | [diff] [blame] | 2895 | void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*); |
| 2896 | void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*); |
drh | 030796d | 2012-08-23 16:18:10 +0000 | [diff] [blame] | 2897 | int sqlite3FunctionUsesThisSrc(Expr*, SrcList*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2898 | Vdbe *sqlite3GetVdbe(Parse*); |
drh | 2fa1868 | 2008-03-19 14:15:34 +0000 | [diff] [blame] | 2899 | void sqlite3PrngSaveState(void); |
| 2900 | void sqlite3PrngRestoreState(void); |
| 2901 | void sqlite3PrngResetState(void); |
drh | 0f198a7 | 2012-02-13 16:43:16 +0000 | [diff] [blame] | 2902 | void sqlite3RollbackAll(sqlite3*,int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2903 | void sqlite3CodeVerifySchema(Parse*, int); |
dan | 5796675 | 2011-04-09 17:32:58 +0000 | [diff] [blame] | 2904 | void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); |
drh | 684917c | 2004-10-05 02:41:42 +0000 | [diff] [blame] | 2905 | void sqlite3BeginTransaction(Parse*, int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2906 | void sqlite3CommitTransaction(Parse*); |
| 2907 | void sqlite3RollbackTransaction(Parse*); |
danielk1977 | fd7f045 | 2008-12-17 17:30:26 +0000 | [diff] [blame] | 2908 | void sqlite3Savepoint(Parse*, int, Token*); |
| 2909 | void sqlite3CloseSavepoints(sqlite3 *); |
drh | 4245c40 | 2012-06-02 14:32:21 +0000 | [diff] [blame] | 2910 | void sqlite3LeaveMutexAndCloseZombie(sqlite3*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2911 | int sqlite3ExprIsConstant(Expr*); |
drh | 0a16837 | 2007-06-08 00:20:47 +0000 | [diff] [blame] | 2912 | int sqlite3ExprIsConstantNotJoin(Expr*); |
drh | eb55bd2 | 2005-06-30 17:04:21 +0000 | [diff] [blame] | 2913 | int sqlite3ExprIsConstantOrFunction(Expr*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2914 | int sqlite3ExprIsInteger(Expr*, int*); |
drh | 039fc32 | 2009-11-17 18:31:47 +0000 | [diff] [blame] | 2915 | int sqlite3ExprCanBeNull(const Expr*); |
drh | 2f2855b | 2009-11-18 01:25:26 +0000 | [diff] [blame] | 2916 | void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int); |
drh | 039fc32 | 2009-11-17 18:31:47 +0000 | [diff] [blame] | 2917 | int sqlite3ExprNeedsNoAffinityChange(const Expr*, char); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2918 | int sqlite3IsRowid(const char*); |
dan | 2283d46 | 2009-09-08 15:55:15 +0000 | [diff] [blame] | 2919 | void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int); |
drh | 2d401ab | 2008-01-10 23:50:11 +0000 | [diff] [blame] | 2920 | void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*); |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2921 | int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int); |
drh | 04adf41 | 2008-01-08 18:57:50 +0000 | [diff] [blame] | 2922 | void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int, |
danielk1977 | de63035 | 2009-05-04 11:42:29 +0000 | [diff] [blame] | 2923 | int*,int,int,int,int,int*); |
dan | 2832ad4 | 2009-08-31 15:27:27 +0000 | [diff] [blame] | 2924 | void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int); |
drh | aa9b896 | 2008-01-08 02:57:55 +0000 | [diff] [blame] | 2925 | int sqlite3OpenTableAndIndices(Parse*, Table*, int, int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2926 | void sqlite3BeginWriteOperation(Parse*, int, int); |
drh | ff738bc | 2009-09-24 00:09:58 +0000 | [diff] [blame] | 2927 | void sqlite3MultiWrite(Parse*); |
| 2928 | void sqlite3MayAbort(Parse*); |
drh | d91c1a1 | 2013-02-09 13:58:25 +0000 | [diff] [blame] | 2929 | void sqlite3HaltConstraint(Parse*, int, int, char*, int); |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 2930 | Expr *sqlite3ExprDup(sqlite3*,Expr*,int); |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 2931 | ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int); |
| 2932 | SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2933 | IdList *sqlite3IdListDup(sqlite3*,IdList*); |
danielk1977 | 6ab3a2e | 2009-02-19 14:39:25 +0000 | [diff] [blame] | 2934 | Select *sqlite3SelectDup(sqlite3*,Select*,int); |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 2935 | void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*); |
drh | 89d5d6a | 2012-04-07 00:09:21 +0000 | [diff] [blame] | 2936 | FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,u8); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 2937 | void sqlite3RegisterBuiltinFunctions(sqlite3*); |
drh | 777c538 | 2008-08-21 20:21:34 +0000 | [diff] [blame] | 2938 | void sqlite3RegisterDateTimeFunctions(void); |
drh | 70a8ca3 | 2008-08-21 18:49:27 +0000 | [diff] [blame] | 2939 | void sqlite3RegisterGlobalFunctions(void); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 2940 | int sqlite3SafetyCheckOk(sqlite3*); |
| 2941 | int sqlite3SafetyCheckSickOrOk(sqlite3*); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 2942 | void sqlite3ChangeCookie(Parse*, int); |
shane | fa4e62f | 2008-09-01 21:59:42 +0000 | [diff] [blame] | 2943 | |
| 2944 | #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) |
drh | 2a5d825 | 2008-08-22 12:30:52 +0000 | [diff] [blame] | 2945 | void sqlite3MaterializeView(Parse*, Table*, Expr*, int); |
shane | fa4e62f | 2008-09-01 21:59:42 +0000 | [diff] [blame] | 2946 | #endif |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2947 | |
| 2948 | #ifndef SQLITE_OMIT_TRIGGER |
| 2949 | void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*, |
drh | 60218d2 | 2007-04-06 11:26:00 +0000 | [diff] [blame] | 2950 | Expr*,int, int); |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2951 | void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*); |
drh | fdd48a7 | 2006-09-11 23:45:48 +0000 | [diff] [blame] | 2952 | void sqlite3DropTrigger(Parse*, SrcList*, int); |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 2953 | void sqlite3DropTriggerPtr(Parse*, Trigger*); |
danielk1977 | 2f886d1 | 2009-02-28 10:47:41 +0000 | [diff] [blame] | 2954 | Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask); |
| 2955 | Trigger *sqlite3TriggerList(Parse *, Table *); |
dan | 165921a | 2009-08-28 18:53:45 +0000 | [diff] [blame] | 2956 | void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *, |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 2957 | int, int, int); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 2958 | void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int); |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2959 | void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2960 | void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2961 | TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*); |
| 2962 | TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*, |
shane | 5eff7cf | 2009-08-10 03:57:58 +0000 | [diff] [blame] | 2963 | ExprList*,Select*,u8); |
| 2964 | TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 2965 | TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2966 | void sqlite3DeleteTrigger(sqlite3*, Trigger*); |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2967 | void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 2968 | u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2969 | # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2970 | #else |
danielk1977 | 62c14b3 | 2008-11-19 09:05:26 +0000 | [diff] [blame] | 2971 | # define sqlite3TriggersExist(B,C,D,E,F) 0 |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2972 | # define sqlite3DeleteTrigger(A,B) |
drh | cdd536f | 2006-03-17 00:04:03 +0000 | [diff] [blame] | 2973 | # define sqlite3DropTriggerPtr(A,B) |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2974 | # define sqlite3UnlinkAndDeleteTrigger(A,B,C) |
dan | 94d7f50 | 2009-09-24 09:05:49 +0000 | [diff] [blame] | 2975 | # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) |
dan | 75cbd98 | 2009-09-21 16:06:03 +0000 | [diff] [blame] | 2976 | # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) |
danielk1977 | 2943c37 | 2009-04-07 14:14:22 +0000 | [diff] [blame] | 2977 | # define sqlite3TriggerList(X, Y) 0 |
dan | 65a7cd1 | 2009-09-01 12:16:01 +0000 | [diff] [blame] | 2978 | # define sqlite3ParseToplevel(p) p |
dan | bb5f168 | 2009-11-27 12:12:34 +0000 | [diff] [blame] | 2979 | # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 2980 | #endif |
| 2981 | |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2982 | int sqlite3JoinType(Parse*, Token*, Token*, Token*); |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 2983 | void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2984 | void sqlite3DeferForeignKey(Parse*, int); |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 2985 | #ifndef SQLITE_OMIT_AUTHORIZATION |
drh | 728b577 | 2007-09-18 15:55:07 +0000 | [diff] [blame] | 2986 | void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2987 | int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*); |
| 2988 | void sqlite3AuthContextPush(Parse*, AuthContext*, const char*); |
| 2989 | void sqlite3AuthContextPop(AuthContext*); |
dan | 02470b2 | 2009-10-03 07:04:11 +0000 | [diff] [blame] | 2990 | int sqlite3AuthReadCol(Parse*, const char *, const char *, int); |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 2991 | #else |
danielk1977 | b5258c3 | 2007-10-04 18:11:15 +0000 | [diff] [blame] | 2992 | # define sqlite3AuthRead(a,b,c,d) |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2993 | # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK |
| 2994 | # define sqlite3AuthContextPush(a,b,c) |
| 2995 | # define sqlite3AuthContextPop(a) ((void)(a)) |
drh | ed6c867 | 2003-01-12 18:02:16 +0000 | [diff] [blame] | 2996 | #endif |
danielk1977 | f744bb5 | 2005-12-06 17:19:11 +0000 | [diff] [blame] | 2997 | void sqlite3Attach(Parse*, Expr*, Expr*, Expr*); |
| 2998 | void sqlite3Detach(Parse*, Expr*); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 2999 | int sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*); |
| 3000 | int sqlite3FixSrcList(DbFixer*, SrcList*); |
| 3001 | int sqlite3FixSelect(DbFixer*, Select*); |
| 3002 | int sqlite3FixExpr(DbFixer*, Expr*); |
| 3003 | int sqlite3FixExprList(DbFixer*, ExprList*); |
| 3004 | int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); |
drh | 9339da1 | 2010-09-30 00:50:49 +0000 | [diff] [blame] | 3005 | int sqlite3AtoF(const char *z, double*, int, u8); |
drh | fec19aa | 2004-05-19 20:41:03 +0000 | [diff] [blame] | 3006 | int sqlite3GetInt32(const char *, int*); |
drh | 60ac3f4 | 2010-11-23 18:59:27 +0000 | [diff] [blame] | 3007 | int sqlite3Atoi(const char*); |
drh | ee85813 | 2007-05-08 20:37:38 +0000 | [diff] [blame] | 3008 | int sqlite3Utf16ByteLen(const void *pData, int nChar); |
| 3009 | int sqlite3Utf8CharLen(const char *pData, int nByte); |
drh | 4261096 | 2012-09-17 18:56:32 +0000 | [diff] [blame] | 3010 | u32 sqlite3Utf8Read(const u8**); |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 3011 | |
| 3012 | /* |
| 3013 | ** Routines to read and write variable-length integers. These used to |
| 3014 | ** be defined locally, but now we use the varint routines in the util.c |
shane | 952856a | 2008-04-28 17:41:30 +0000 | [diff] [blame] | 3015 | ** file. Code should use the MACRO forms below, as the Varint32 versions |
| 3016 | ** are coded to assume the single byte case is already handled (which |
| 3017 | ** the MACRO form does). |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 3018 | */ |
drh | 35b5a33 | 2008-04-05 18:41:42 +0000 | [diff] [blame] | 3019 | int sqlite3PutVarint(unsigned char*, u64); |
| 3020 | int sqlite3PutVarint32(unsigned char*, u32); |
drh | 1bd10f8 | 2008-12-10 21:19:56 +0000 | [diff] [blame] | 3021 | u8 sqlite3GetVarint(const unsigned char *, u64 *); |
| 3022 | u8 sqlite3GetVarint32(const unsigned char *, u32 *); |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 3023 | int sqlite3VarintLen(u64 v); |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 3024 | |
| 3025 | /* |
| 3026 | ** The header of a record consists of a sequence variable-length integers. |
| 3027 | ** These integers are almost always small and are encoded as a single byte. |
| 3028 | ** The following macros take advantage this fact to provide a fast encode |
| 3029 | ** and decode of the integers in a record header. It is faster for the common |
| 3030 | ** case where the integer is a single byte. It is a little slower when the |
| 3031 | ** integer is two or more bytes. But overall it is faster. |
| 3032 | ** |
| 3033 | ** The following expressions are equivalent: |
| 3034 | ** |
| 3035 | ** x = sqlite3GetVarint32( A, &B ); |
| 3036 | ** x = sqlite3PutVarint32( A, B ); |
| 3037 | ** |
| 3038 | ** x = getVarint32( A, B ); |
| 3039 | ** x = putVarint32( A, B ); |
| 3040 | ** |
| 3041 | */ |
drh | 4bde370 | 2013-02-19 18:34:12 +0000 | [diff] [blame] | 3042 | #define getVarint32(A,B) \ |
| 3043 | (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B))) |
| 3044 | #define putVarint32(A,B) \ |
| 3045 | (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\ |
| 3046 | sqlite3PutVarint32((A),(B))) |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 3047 | #define getVarint sqlite3GetVarint |
| 3048 | #define putVarint sqlite3PutVarint |
| 3049 | |
| 3050 | |
dan | 69f8bb9 | 2009-08-13 19:21:16 +0000 | [diff] [blame] | 3051 | const char *sqlite3IndexAffinityStr(Vdbe *, Index *); |
danielk1977 | a37cdde | 2004-05-16 11:15:36 +0000 | [diff] [blame] | 3052 | void sqlite3TableAffinityStr(Vdbe *, Table *); |
danielk1977 | e014a83 | 2004-05-17 10:48:57 +0000 | [diff] [blame] | 3053 | char sqlite3CompareAffinity(Expr *pExpr, char aff2); |
danielk1977 | e014a83 | 2004-05-17 10:48:57 +0000 | [diff] [blame] | 3054 | int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity); |
danielk1977 | bf3b721 | 2004-05-18 10:06:24 +0000 | [diff] [blame] | 3055 | char sqlite3ExprAffinity(Expr *pExpr); |
drh | 9339da1 | 2010-09-30 00:50:49 +0000 | [diff] [blame] | 3056 | int sqlite3Atoi64(const char*, i64*, int, u8); |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 3057 | void sqlite3Error(sqlite3*, int, const char*,...); |
drh | ca48c90 | 2008-01-18 14:08:24 +0000 | [diff] [blame] | 3058 | void *sqlite3HexToBlob(sqlite3*, const char *z, int n); |
dan | cd74b61 | 2011-04-22 19:37:32 +0000 | [diff] [blame] | 3059 | u8 sqlite3HexToInt(int h); |
danielk1977 | ef2cb63 | 2004-05-29 02:37:19 +0000 | [diff] [blame] | 3060 | int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); |
mistachkin | dd08ca0 | 2013-04-30 07:58:15 +0000 | [diff] [blame] | 3061 | |
| 3062 | #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) || \ |
| 3063 | defined(SQLITE_DEBUG_OS_TRACE) |
mistachkin | f2c1c99 | 2013-04-28 01:44:43 +0000 | [diff] [blame] | 3064 | const char *sqlite3ErrName(int); |
mistachkin | dd08ca0 | 2013-04-30 07:58:15 +0000 | [diff] [blame] | 3065 | #endif |
| 3066 | |
danielk1977 | f20b21c | 2004-05-31 23:56:42 +0000 | [diff] [blame] | 3067 | const char *sqlite3ErrStr(int); |
danielk1977 | 8a41449 | 2004-06-29 08:59:35 +0000 | [diff] [blame] | 3068 | int sqlite3ReadSchema(Parse *pParse); |
drh | c4a64fa | 2009-05-11 20:53:28 +0000 | [diff] [blame] | 3069 | CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int); |
| 3070 | CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName); |
danielk1977 | 7cedc8d | 2004-06-10 10:50:08 +0000 | [diff] [blame] | 3071 | CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr); |
drh | 0a8a406 | 2012-12-07 18:38:16 +0000 | [diff] [blame] | 3072 | Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, Token*); |
| 3073 | Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*); |
| 3074 | Expr *sqlite3ExprSkipCollate(Expr*); |
danielk1977 | 7cedc8d | 2004-06-10 10:50:08 +0000 | [diff] [blame] | 3075 | int sqlite3CheckCollSeq(Parse *, CollSeq *); |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 3076 | int sqlite3CheckObjectName(Parse *, const char *); |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 3077 | void sqlite3VdbeSetChanges(sqlite3 *, int); |
drh | 158b9cb | 2011-03-05 20:59:46 +0000 | [diff] [blame] | 3078 | int sqlite3AddInt64(i64*,i64); |
| 3079 | int sqlite3SubInt64(i64*,i64); |
| 3080 | int sqlite3MulInt64(i64*,i64); |
drh | d50ffc4 | 2011-03-08 02:38:28 +0000 | [diff] [blame] | 3081 | int sqlite3AbsInt32(int); |
drh | 81cc516 | 2011-05-17 20:36:21 +0000 | [diff] [blame] | 3082 | #ifdef SQLITE_ENABLE_8_3_NAMES |
| 3083 | void sqlite3FileSuffix3(const char*, char*); |
| 3084 | #else |
| 3085 | # define sqlite3FileSuffix3(X,Y) |
| 3086 | #endif |
drh | 38d9c61 | 2012-01-31 14:24:47 +0000 | [diff] [blame] | 3087 | u8 sqlite3GetBoolean(const char *z,int); |
danielk1977 | 4e6af13 | 2004-06-10 14:01:08 +0000 | [diff] [blame] | 3088 | |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 3089 | const void *sqlite3ValueText(sqlite3_value*, u8); |
| 3090 | int sqlite3ValueBytes(sqlite3_value*, u8); |
| 3091 | void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3092 | void(*)(void*)); |
danielk1977 | 4e6af13 | 2004-06-10 14:01:08 +0000 | [diff] [blame] | 3093 | void sqlite3ValueFree(sqlite3_value*); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3094 | sqlite3_value *sqlite3ValueNew(sqlite3 *); |
dan | b7dca7d | 2010-03-05 16:32:12 +0000 | [diff] [blame] | 3095 | char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); |
drh | faacf17 | 2011-08-12 01:51:45 +0000 | [diff] [blame] | 3096 | #ifdef SQLITE_ENABLE_STAT3 |
shane | cea72b2 | 2009-09-07 04:38:36 +0000 | [diff] [blame] | 3097 | char *sqlite3Utf8to16(sqlite3 *, u8, char *, int, int *); |
dan | 69188d9 | 2009-08-19 08:18:32 +0000 | [diff] [blame] | 3098 | #endif |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3099 | int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **); |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 3100 | void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 3101 | #ifndef SQLITE_AMALGAMATION |
drh | a6c2ed9 | 2009-11-14 23:22:23 +0000 | [diff] [blame] | 3102 | extern const unsigned char sqlite3OpcodeProperty[]; |
drh | 4e5ffc5 | 2004-08-31 00:52:37 +0000 | [diff] [blame] | 3103 | extern const unsigned char sqlite3UpperToLower[]; |
danielk1977 | 78ca0e7 | 2009-01-20 16:53:39 +0000 | [diff] [blame] | 3104 | extern const unsigned char sqlite3CtypeMap[]; |
drh | 094430e | 2010-07-14 18:24:06 +0000 | [diff] [blame] | 3105 | extern const Token sqlite3IntTokens[]; |
danielk1977 | 075c23a | 2008-09-01 18:34:20 +0000 | [diff] [blame] | 3106 | extern SQLITE_WSD struct Sqlite3Config sqlite3Config; |
| 3107 | extern SQLITE_WSD FuncDefHash sqlite3GlobalFunctions; |
drh | f83dc1e | 2010-06-03 12:09:52 +0000 | [diff] [blame] | 3108 | #ifndef SQLITE_OMIT_WSD |
drh | ddb68e1 | 2009-02-05 16:53:43 +0000 | [diff] [blame] | 3109 | extern int sqlite3PendingByte; |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 3110 | #endif |
drh | f83dc1e | 2010-06-03 12:09:52 +0000 | [diff] [blame] | 3111 | #endif |
drh | cdf011d | 2011-04-04 21:25:28 +0000 | [diff] [blame] | 3112 | void sqlite3RootPageMoved(sqlite3*, int, int, int); |
drh | 4343fea | 2004-11-05 23:46:15 +0000 | [diff] [blame] | 3113 | void sqlite3Reindex(Parse*, Token*, Token*); |
drh | 545f587 | 2010-04-24 14:02:59 +0000 | [diff] [blame] | 3114 | void sqlite3AlterFunctions(void); |
danielk1977 | 9fd2a9a | 2004-11-12 13:42:30 +0000 | [diff] [blame] | 3115 | void sqlite3AlterRenameTable(Parse*, SrcList*, Token*); |
| 3116 | int sqlite3GetToken(const unsigned char *, int *); |
drh | 2958a4e | 2004-11-12 03:56:15 +0000 | [diff] [blame] | 3117 | void sqlite3NestedParse(Parse*, const char*, ...); |
drh | d89bd00 | 2005-01-22 03:03:54 +0000 | [diff] [blame] | 3118 | void sqlite3ExpirePreparedStatements(sqlite3*); |
drh | 1450bc6 | 2009-10-30 13:25:56 +0000 | [diff] [blame] | 3119 | int sqlite3CodeSubselect(Parse *, Expr *, int, int); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 3120 | void sqlite3SelectPrep(Parse*, Select*, NameContext*); |
drh | 3e3f1a5 | 2013-01-03 00:45:56 +0000 | [diff] [blame] | 3121 | int sqlite3MatchSpanName(const char*, const char*, const char*, const char*); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 3122 | int sqlite3ResolveExprNames(NameContext*, Expr*); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 3123 | void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*); |
| 3124 | int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*); |
danielk1977 | c7538b5 | 2009-07-27 10:05:04 +0000 | [diff] [blame] | 3125 | void sqlite3ColumnDefault(Vdbe *, Table *, int, int); |
danielk1977 | 19a8e7e | 2005-03-17 05:03:38 +0000 | [diff] [blame] | 3126 | void sqlite3AlterFinishAddColumn(Parse *, Token *); |
| 3127 | void sqlite3AlterBeginAddColumn(Parse *, SrcList *); |
drh | 79e72a5 | 2012-10-05 14:43:40 +0000 | [diff] [blame] | 3128 | CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); |
drh | b7916a7 | 2009-05-27 10:31:29 +0000 | [diff] [blame] | 3129 | char sqlite3AffinityType(const char*); |
drh | 9f18e8a | 2005-07-08 12:13:04 +0000 | [diff] [blame] | 3130 | void sqlite3Analyze(Parse*, Token*, Token*); |
drh | a4afb65 | 2005-07-09 02:16:02 +0000 | [diff] [blame] | 3131 | int sqlite3InvokeBusyHandler(BusyHandler*); |
drh | ff2d5ea | 2005-07-23 00:41:48 +0000 | [diff] [blame] | 3132 | int sqlite3FindDb(sqlite3*, Token*); |
danielk1977 | 0410302 | 2009-02-03 16:51:24 +0000 | [diff] [blame] | 3133 | int sqlite3FindDbName(sqlite3 *, const char *); |
drh | cf1be45 | 2007-05-12 12:08:51 +0000 | [diff] [blame] | 3134 | int sqlite3AnalysisLoad(sqlite3*,int iDB); |
dan | d46def7 | 2010-07-24 11:28:28 +0000 | [diff] [blame] | 3135 | void sqlite3DeleteIndexSamples(sqlite3*,Index*); |
drh | 51147ba | 2005-07-23 22:59:55 +0000 | [diff] [blame] | 3136 | void sqlite3DefaultRowEst(Index*); |
drh | 55ef4d9 | 2005-08-14 01:20:37 +0000 | [diff] [blame] | 3137 | void sqlite3RegisterLikeFunctions(sqlite3*, int); |
drh | d64fe2f | 2005-08-28 17:00:23 +0000 | [diff] [blame] | 3138 | int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 3139 | void sqlite3MinimumFileFormat(Parse*, int, int); |
drh | b6ee660 | 2011-04-04 13:40:53 +0000 | [diff] [blame] | 3140 | void sqlite3SchemaClear(void *); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3141 | Schema *sqlite3SchemaGet(sqlite3 *, Btree *); |
danielk1977 | e501b89 | 2006-01-09 06:29:47 +0000 | [diff] [blame] | 3142 | int sqlite3SchemaToIndex(sqlite3 *db, Schema *); |
danielk1977 | b3bf556 | 2006-01-10 17:58:23 +0000 | [diff] [blame] | 3143 | KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *); |
danielk1977 | 771151b | 2006-01-17 13:21:40 +0000 | [diff] [blame] | 3144 | int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *, |
| 3145 | void (*)(sqlite3_context*,int,sqlite3_value **), |
dan | d2199f0 | 2010-08-27 17:48:52 +0000 | [diff] [blame] | 3146 | void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*), |
| 3147 | FuncDestructor *pDestructor |
| 3148 | ); |
danielk1977 | 54f0198 | 2006-01-18 15:25:17 +0000 | [diff] [blame] | 3149 | int sqlite3ApiExit(sqlite3 *db, int); |
danielk1977 | ddfb2f0 | 2006-02-17 12:25:14 +0000 | [diff] [blame] | 3150 | int sqlite3OpenTempDatabase(Parse *); |
drh | 69dab1d | 2006-06-27 14:37:20 +0000 | [diff] [blame] | 3151 | |
drh | f089aa4 | 2008-07-08 19:34:06 +0000 | [diff] [blame] | 3152 | void sqlite3StrAccumInit(StrAccum*, char*, int, int); |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 3153 | void sqlite3StrAccumAppend(StrAccum*,const char*,int); |
drh | 7e02e5e | 2011-12-06 19:44:51 +0000 | [diff] [blame] | 3154 | void sqlite3AppendSpace(StrAccum*,int); |
drh | ade8648 | 2007-11-28 22:36:40 +0000 | [diff] [blame] | 3155 | char *sqlite3StrAccumFinish(StrAccum*); |
| 3156 | void sqlite3StrAccumReset(StrAccum*); |
drh | 1013c93 | 2008-01-06 00:25:21 +0000 | [diff] [blame] | 3157 | void sqlite3SelectDestInit(SelectDest*,int,int); |
dan | f7b0b0a | 2009-10-19 15:52:32 +0000 | [diff] [blame] | 3158 | Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3159 | |
danielk1977 | 0410302 | 2009-02-03 16:51:24 +0000 | [diff] [blame] | 3160 | void sqlite3BackupRestart(sqlite3_backup *); |
| 3161 | void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); |
| 3162 | |
drh | 95bdbbb | 2007-07-23 19:31:16 +0000 | [diff] [blame] | 3163 | /* |
| 3164 | ** The interface to the LEMON-generated parser |
| 3165 | */ |
| 3166 | void *sqlite3ParserAlloc(void*(*)(size_t)); |
| 3167 | void sqlite3ParserFree(void*, void(*)(void*)); |
| 3168 | void sqlite3Parser(void*, int, Token, Parse*); |
drh | ec424a5 | 2008-07-25 15:39:03 +0000 | [diff] [blame] | 3169 | #ifdef YYTRACKMAXSTACKDEPTH |
| 3170 | int sqlite3ParserStackPeak(void*); |
| 3171 | #endif |
drh | 95bdbbb | 2007-07-23 19:31:16 +0000 | [diff] [blame] | 3172 | |
drh | 7aaa878 | 2009-05-20 02:40:45 +0000 | [diff] [blame] | 3173 | void sqlite3AutoLoadExtensions(sqlite3*); |
drh | 69dab1d | 2006-06-27 14:37:20 +0000 | [diff] [blame] | 3174 | #ifndef SQLITE_OMIT_LOAD_EXTENSION |
| 3175 | void sqlite3CloseExtensions(sqlite3*); |
| 3176 | #else |
| 3177 | # define sqlite3CloseExtensions(X) |
| 3178 | #endif |
danielk1977 | e302663 | 2004-06-22 11:29:02 +0000 | [diff] [blame] | 3179 | |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 3180 | #ifndef SQLITE_OMIT_SHARED_CACHE |
| 3181 | void sqlite3TableLock(Parse *, int, int, u8, const char *); |
| 3182 | #else |
| 3183 | #define sqlite3TableLock(v,w,x,y,z) |
| 3184 | #endif |
| 3185 | |
drh | 53c1402 | 2007-05-10 17:23:11 +0000 | [diff] [blame] | 3186 | #ifdef SQLITE_TEST |
| 3187 | int sqlite3Utf8To8(unsigned char*); |
| 3188 | #endif |
| 3189 | |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3190 | #ifdef SQLITE_OMIT_VIRTUALTABLE |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 3191 | # define sqlite3VtabClear(Y) |
danielk1977 | 9dbee7d | 2008-08-02 15:32:39 +0000 | [diff] [blame] | 3192 | # define sqlite3VtabSync(X,Y) SQLITE_OK |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 3193 | # define sqlite3VtabRollback(X) |
| 3194 | # define sqlite3VtabCommit(X) |
danielk1977 | 093e0f6 | 2008-11-13 18:00:14 +0000 | [diff] [blame] | 3195 | # define sqlite3VtabInSync(db) 0 |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 3196 | # define sqlite3VtabLock(X) |
| 3197 | # define sqlite3VtabUnlock(X) |
| 3198 | # define sqlite3VtabUnlockList(X) |
dan | a311b80 | 2011-04-26 19:21:34 +0000 | [diff] [blame] | 3199 | # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK |
drh | c3c8dac | 2011-10-12 19:04:07 +0000 | [diff] [blame] | 3200 | # define sqlite3GetVTable(X,Y) ((VTable*)0) |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3201 | #else |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 3202 | void sqlite3VtabClear(sqlite3 *db, Table*); |
dan | bba02a9 | 2012-05-15 17:15:34 +0000 | [diff] [blame] | 3203 | void sqlite3VtabDisconnect(sqlite3 *db, Table *p); |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 3204 | int sqlite3VtabSync(sqlite3 *db, char **); |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 3205 | int sqlite3VtabRollback(sqlite3 *db); |
| 3206 | int sqlite3VtabCommit(sqlite3 *db); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 3207 | void sqlite3VtabLock(VTable *); |
| 3208 | void sqlite3VtabUnlock(VTable *); |
| 3209 | void sqlite3VtabUnlockList(sqlite3*); |
dan | a311b80 | 2011-04-26 19:21:34 +0000 | [diff] [blame] | 3210 | int sqlite3VtabSavepoint(sqlite3 *, int, int); |
drh | c3c8dac | 2011-10-12 19:04:07 +0000 | [diff] [blame] | 3211 | VTable *sqlite3GetVTable(sqlite3*, Table*); |
danielk1977 | 093e0f6 | 2008-11-13 18:00:14 +0000 | [diff] [blame] | 3212 | # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3213 | #endif |
drh | 4f3dd15 | 2008-04-28 18:46:43 +0000 | [diff] [blame] | 3214 | void sqlite3VtabMakeWritable(Parse*,Table*); |
drh | b421b89 | 2012-01-28 19:41:53 +0000 | [diff] [blame] | 3215 | void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int); |
drh | b9bb7c1 | 2006-06-11 23:41:55 +0000 | [diff] [blame] | 3216 | void sqlite3VtabFinishParse(Parse*, Token*); |
| 3217 | void sqlite3VtabArgInit(Parse*); |
| 3218 | void sqlite3VtabArgExtend(Parse*, Token*); |
danielk1977 | 78efaba | 2006-06-12 06:09:17 +0000 | [diff] [blame] | 3219 | int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **); |
danielk1977 | 7e6ebfb | 2006-06-12 11:24:37 +0000 | [diff] [blame] | 3220 | int sqlite3VtabCallConnect(Parse*, Table*); |
danielk1977 | 9e39ce8 | 2006-06-12 16:01:21 +0000 | [diff] [blame] | 3221 | int sqlite3VtabCallDestroy(sqlite3*, int, const char *); |
danielk1977 | 595a523 | 2009-07-24 17:58:53 +0000 | [diff] [blame] | 3222 | int sqlite3VtabBegin(sqlite3 *, VTable *); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 3223 | FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*); |
drh | b7481e7 | 2006-09-16 21:45:14 +0000 | [diff] [blame] | 3224 | void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**); |
drh | 5f18a22 | 2009-11-26 14:01:53 +0000 | [diff] [blame] | 3225 | int sqlite3VdbeParameterIndex(Vdbe*, const char*, int); |
shane | 4a27a28 | 2008-09-04 04:32:49 +0000 | [diff] [blame] | 3226 | int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *); |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 3227 | int sqlite3Reprepare(Vdbe*); |
drh | b1a6c3c | 2008-03-20 16:30:17 +0000 | [diff] [blame] | 3228 | void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*); |
drh | 0a0e131 | 2007-08-07 17:04:59 +0000 | [diff] [blame] | 3229 | CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *); |
drh | 1c51414 | 2009-04-30 12:25:10 +0000 | [diff] [blame] | 3230 | int sqlite3TempInMemory(const sqlite3*); |
dan | 28e5386 | 2010-04-21 06:19:12 +0000 | [diff] [blame] | 3231 | const char *sqlite3JournalModename(int); |
dan | 06a2d82 | 2012-10-10 09:46:29 +0000 | [diff] [blame] | 3232 | #ifndef SQLITE_OMIT_WAL |
| 3233 | int sqlite3Checkpoint(sqlite3*, int, int, int*, int*); |
| 3234 | int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int); |
| 3235 | #endif |
danielk1977 | d829335 | 2009-04-30 09:10:37 +0000 | [diff] [blame] | 3236 | |
dan | 75cbd98 | 2009-09-21 16:06:03 +0000 | [diff] [blame] | 3237 | /* Declarations for functions in fkey.c. All of these are replaced by |
| 3238 | ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign |
| 3239 | ** key functionality is available. If OMIT_TRIGGER is defined but |
| 3240 | ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In |
| 3241 | ** this case foreign keys are parsed, but no other functionality is |
| 3242 | ** provided (enforcement of FK constraints requires the triggers sub-system). |
| 3243 | */ |
| 3244 | #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) |
dan | e7a94d8 | 2009-10-01 16:09:04 +0000 | [diff] [blame] | 3245 | void sqlite3FkCheck(Parse*, Table*, int, int); |
dan | d66c830 | 2009-09-28 14:49:01 +0000 | [diff] [blame] | 3246 | void sqlite3FkDropTable(Parse*, SrcList *, Table*); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 3247 | void sqlite3FkActions(Parse*, Table*, ExprList*, int); |
dan | e7a94d8 | 2009-10-01 16:09:04 +0000 | [diff] [blame] | 3248 | int sqlite3FkRequired(Parse*, Table*, int*, int); |
| 3249 | u32 sqlite3FkOldmask(Parse*, Table*); |
dan | 432cc5b | 2009-09-26 17:51:48 +0000 | [diff] [blame] | 3250 | FKey *sqlite3FkReferences(Table *); |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 3251 | #else |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 3252 | #define sqlite3FkActions(a,b,c,d) |
dan | e7a94d8 | 2009-10-01 16:09:04 +0000 | [diff] [blame] | 3253 | #define sqlite3FkCheck(a,b,c,d) |
dan | d66c830 | 2009-09-28 14:49:01 +0000 | [diff] [blame] | 3254 | #define sqlite3FkDropTable(a,b,c) |
dan | e7a94d8 | 2009-10-01 16:09:04 +0000 | [diff] [blame] | 3255 | #define sqlite3FkOldmask(a,b) 0 |
| 3256 | #define sqlite3FkRequired(a,b,c,d) 0 |
dan | 1da40a3 | 2009-09-19 17:00:31 +0000 | [diff] [blame] | 3257 | #endif |
dan | 75cbd98 | 2009-09-21 16:06:03 +0000 | [diff] [blame] | 3258 | #ifndef SQLITE_OMIT_FOREIGN_KEY |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 3259 | void sqlite3FkDelete(sqlite3 *, Table*); |
drh | 6c5b915 | 2012-12-17 16:46:37 +0000 | [diff] [blame] | 3260 | int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**); |
dan | 75cbd98 | 2009-09-21 16:06:03 +0000 | [diff] [blame] | 3261 | #else |
dan | 1feeaed | 2010-07-23 15:41:47 +0000 | [diff] [blame] | 3262 | #define sqlite3FkDelete(a,b) |
drh | 6c5b915 | 2012-12-17 16:46:37 +0000 | [diff] [blame] | 3263 | #define sqlite3FkLocateIndex(a,b,c,d,e) |
dan | 75cbd98 | 2009-09-21 16:06:03 +0000 | [diff] [blame] | 3264 | #endif |
| 3265 | |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3266 | |
| 3267 | /* |
| 3268 | ** Available fault injectors. Should be numbered beginning with 0. |
| 3269 | */ |
| 3270 | #define SQLITE_FAULTINJECTOR_MALLOC 0 |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 3271 | #define SQLITE_FAULTINJECTOR_COUNT 1 |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3272 | |
| 3273 | /* |
danielk1977 | ef05f2d | 2008-06-20 11:05:37 +0000 | [diff] [blame] | 3274 | ** The interface to the code in fault.c used for identifying "benign" |
| 3275 | ** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST |
| 3276 | ** is not defined. |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3277 | */ |
drh | 3088d59 | 2008-03-21 16:45:47 +0000 | [diff] [blame] | 3278 | #ifndef SQLITE_OMIT_BUILTIN_TEST |
danielk1977 | 2d1d86f | 2008-06-20 14:59:51 +0000 | [diff] [blame] | 3279 | void sqlite3BeginBenignMalloc(void); |
| 3280 | void sqlite3EndBenignMalloc(void); |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3281 | #else |
danielk1977 | 2d1d86f | 2008-06-20 14:59:51 +0000 | [diff] [blame] | 3282 | #define sqlite3BeginBenignMalloc() |
danielk1977 | 867d05a | 2008-06-23 14:03:45 +0000 | [diff] [blame] | 3283 | #define sqlite3EndBenignMalloc() |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3284 | #endif |
drh | 643167f | 2008-01-22 21:30:53 +0000 | [diff] [blame] | 3285 | |
danielk1977 | 9a96b66 | 2007-11-29 17:05:18 +0000 | [diff] [blame] | 3286 | #define IN_INDEX_ROWID 1 |
| 3287 | #define IN_INDEX_EPH 2 |
drh | 1ccce44 | 2013-03-12 20:38:51 +0000 | [diff] [blame] | 3288 | #define IN_INDEX_INDEX_ASC 3 |
| 3289 | #define IN_INDEX_INDEX_DESC 4 |
danielk1977 | 0cdc022 | 2008-06-26 18:04:03 +0000 | [diff] [blame] | 3290 | int sqlite3FindInIndex(Parse *, Expr *, int*); |
danielk1977 | 9a96b66 | 2007-11-29 17:05:18 +0000 | [diff] [blame] | 3291 | |
danielk1977 | c7b6017 | 2007-08-22 11:22:03 +0000 | [diff] [blame] | 3292 | #ifdef SQLITE_ENABLE_ATOMIC_WRITE |
| 3293 | int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int); |
| 3294 | int sqlite3JournalSize(sqlite3_vfs *); |
danielk1977 | f55b899 | 2007-08-24 08:15:53 +0000 | [diff] [blame] | 3295 | int sqlite3JournalCreate(sqlite3_file *); |
dan | 3de0f18 | 2012-12-05 10:01:35 +0000 | [diff] [blame] | 3296 | int sqlite3JournalExists(sqlite3_file *p); |
danielk1977 | c7b6017 | 2007-08-22 11:22:03 +0000 | [diff] [blame] | 3297 | #else |
| 3298 | #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile) |
dan | 3de0f18 | 2012-12-05 10:01:35 +0000 | [diff] [blame] | 3299 | #define sqlite3JournalExists(p) 1 |
danielk1977 | c7b6017 | 2007-08-22 11:22:03 +0000 | [diff] [blame] | 3300 | #endif |
| 3301 | |
danielk1977 | b317538 | 2008-10-17 18:51:52 +0000 | [diff] [blame] | 3302 | void sqlite3MemJournalOpen(sqlite3_file *); |
drh | 3a5990a | 2008-12-20 02:14:39 +0000 | [diff] [blame] | 3303 | int sqlite3MemJournalSize(void); |
danielk1977 | b317538 | 2008-10-17 18:51:52 +0000 | [diff] [blame] | 3304 | int sqlite3IsMemJournal(sqlite3_file *); |
| 3305 | |
drh | 0224d26 | 2008-05-28 13:49:34 +0000 | [diff] [blame] | 3306 | #if SQLITE_MAX_EXPR_DEPTH>0 |
danielk1977 | 4b5255a | 2008-06-05 16:47:39 +0000 | [diff] [blame] | 3307 | void sqlite3ExprSetHeight(Parse *pParse, Expr *p); |
danielk1977 | fc97606 | 2007-05-10 10:46:56 +0000 | [diff] [blame] | 3308 | int sqlite3SelectExprHeight(Select *); |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 3309 | int sqlite3ExprCheckHeight(Parse*, int); |
danielk1977 | fc97606 | 2007-05-10 10:46:56 +0000 | [diff] [blame] | 3310 | #else |
danielk1977 | 4b5255a | 2008-06-05 16:47:39 +0000 | [diff] [blame] | 3311 | #define sqlite3ExprSetHeight(x,y) |
drh | 0224d26 | 2008-05-28 13:49:34 +0000 | [diff] [blame] | 3312 | #define sqlite3SelectExprHeight(x) 0 |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 3313 | #define sqlite3ExprCheckHeight(x,y) |
danielk1977 | fc97606 | 2007-05-10 10:46:56 +0000 | [diff] [blame] | 3314 | #endif |
| 3315 | |
drh | a315289 | 2007-05-05 11:48:52 +0000 | [diff] [blame] | 3316 | u32 sqlite3Get4byte(const u8*); |
drh | a315289 | 2007-05-05 11:48:52 +0000 | [diff] [blame] | 3317 | void sqlite3Put4byte(u8*, u32); |
| 3318 | |
danielk1977 | 404ca07 | 2009-03-16 13:19:36 +0000 | [diff] [blame] | 3319 | #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY |
| 3320 | void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *); |
| 3321 | void sqlite3ConnectionUnlocked(sqlite3 *db); |
| 3322 | void sqlite3ConnectionClosed(sqlite3 *db); |
| 3323 | #else |
| 3324 | #define sqlite3ConnectionBlocked(x,y) |
| 3325 | #define sqlite3ConnectionUnlocked(x) |
| 3326 | #define sqlite3ConnectionClosed(x) |
| 3327 | #endif |
| 3328 | |
drh | 6e73683 | 2007-05-11 12:30:03 +0000 | [diff] [blame] | 3329 | #ifdef SQLITE_DEBUG |
| 3330 | void sqlite3ParserTrace(FILE*, char *); |
| 3331 | #endif |
| 3332 | |
drh | b060341 | 2007-02-28 04:47:26 +0000 | [diff] [blame] | 3333 | /* |
| 3334 | ** If the SQLITE_ENABLE IOTRACE exists then the global variable |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 3335 | ** sqlite3IoTrace is a pointer to a printf-like routine used to |
drh | b060341 | 2007-02-28 04:47:26 +0000 | [diff] [blame] | 3336 | ** print I/O tracing messages. |
| 3337 | */ |
| 3338 | #ifdef SQLITE_ENABLE_IOTRACE |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 3339 | # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; } |
danielk1977 | b4622b6 | 2007-03-02 06:24:19 +0000 | [diff] [blame] | 3340 | void sqlite3VdbeIOTraceSql(Vdbe*); |
drh | e265b08 | 2008-05-01 17:03:49 +0000 | [diff] [blame] | 3341 | SQLITE_EXTERN void (*sqlite3IoTrace)(const char*,...); |
drh | b060341 | 2007-02-28 04:47:26 +0000 | [diff] [blame] | 3342 | #else |
| 3343 | # define IOTRACE(A) |
danielk1977 | b4622b6 | 2007-03-02 06:24:19 +0000 | [diff] [blame] | 3344 | # define sqlite3VdbeIOTraceSql(X) |
drh | b060341 | 2007-02-28 04:47:26 +0000 | [diff] [blame] | 3345 | #endif |
drh | b060341 | 2007-02-28 04:47:26 +0000 | [diff] [blame] | 3346 | |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3347 | /* |
| 3348 | ** These routines are available for the mem2.c debugging memory allocator |
| 3349 | ** only. They are used to verify that different "types" of memory |
| 3350 | ** allocations are properly tracked by the system. |
| 3351 | ** |
| 3352 | ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of |
| 3353 | ** the MEMTYPE_* macros defined below. The type must be a bitmask with |
| 3354 | ** a single bit set. |
| 3355 | ** |
| 3356 | ** sqlite3MemdebugHasType() returns true if any of the bits in its second |
| 3357 | ** argument match the type set by the previous sqlite3MemdebugSetType(). |
| 3358 | ** sqlite3MemdebugHasType() is intended for use inside assert() statements. |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3359 | ** |
drh | 174b9a1 | 2010-07-26 11:07:20 +0000 | [diff] [blame] | 3360 | ** sqlite3MemdebugNoType() returns true if none of the bits in its second |
| 3361 | ** argument match the type set by the previous sqlite3MemdebugSetType(). |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3362 | ** |
| 3363 | ** Perhaps the most important point is the difference between MEMTYPE_HEAP |
drh | 174b9a1 | 2010-07-26 11:07:20 +0000 | [diff] [blame] | 3364 | ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means |
| 3365 | ** it might have been allocated by lookaside, except the allocation was |
| 3366 | ** too large or lookaside was already full. It is important to verify |
| 3367 | ** that allocations that might have been satisfied by lookaside are not |
| 3368 | ** passed back to non-lookaside free() routines. Asserts such as the |
| 3369 | ** example above are placed on the non-lookaside free() routines to verify |
| 3370 | ** this constraint. |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3371 | ** |
| 3372 | ** All of this is no-op for a production build. It only comes into |
| 3373 | ** play when the SQLITE_MEMDEBUG compile-time option is used. |
| 3374 | */ |
| 3375 | #ifdef SQLITE_MEMDEBUG |
| 3376 | void sqlite3MemdebugSetType(void*,u8); |
| 3377 | int sqlite3MemdebugHasType(void*,u8); |
drh | 174b9a1 | 2010-07-26 11:07:20 +0000 | [diff] [blame] | 3378 | int sqlite3MemdebugNoType(void*,u8); |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3379 | #else |
| 3380 | # define sqlite3MemdebugSetType(X,Y) /* no-op */ |
| 3381 | # define sqlite3MemdebugHasType(X,Y) 1 |
drh | 174b9a1 | 2010-07-26 11:07:20 +0000 | [diff] [blame] | 3382 | # define sqlite3MemdebugNoType(X,Y) 1 |
danielk1977 | e302663 | 2004-06-22 11:29:02 +0000 | [diff] [blame] | 3383 | #endif |
drh | 174b9a1 | 2010-07-26 11:07:20 +0000 | [diff] [blame] | 3384 | #define MEMTYPE_HEAP 0x01 /* General heap allocations */ |
| 3385 | #define MEMTYPE_LOOKASIDE 0x02 /* Might have been lookaside memory */ |
| 3386 | #define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */ |
| 3387 | #define MEMTYPE_PCACHE 0x08 /* Page cache allocations */ |
| 3388 | #define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */ |
drh | 107b56e | 2010-03-12 16:32:53 +0000 | [diff] [blame] | 3389 | |
| 3390 | #endif /* _SQLITEINT_H_ */ |