1/*
2** 2008 June 13
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
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.
10**
11*************************************************************************
12**
13** This file contains definitions of global variables and constants.
14*/
15#include "sqliteInt.h"
16
17/* An array to map all upper-case characters into their corresponding
18** lower-case character.
19**
20** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
21** handle case conversions for the UTF character set since the tables
22** involved are nearly as big or bigger than SQLite itself.
23*/
24const unsigned char sqlite3UpperToLower[] = {
25#ifdef SQLITE_ASCII
26 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
27 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
28 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
29 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
30 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
31 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
32 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
33 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
34 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
35 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
36 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
37 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
38 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
39 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
40 252,253,254,255,
41#endif
42#ifdef SQLITE_EBCDIC
43 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */
44 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
45 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
46 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
47 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
48 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
49 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */
50 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */
51 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
52 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */
53 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
54 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
55 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
56 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
57 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */
58 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */
59#endif
60/* All of the upper-to-lower conversion data is above. The following
61** 18 integers are completely unrelated. They are appended to the
62** sqlite3UpperToLower[] array to avoid UBSAN warnings. Here's what is
63** going on:
64**
65** The SQL comparison operators (<>, =, >, <=, <, and >=) are implemented
66** by invoking sqlite3MemCompare(A,B) which compares values A and B and
67** returns negative, zero, or positive if A is less then, equal to, or
68** greater than B, respectively. Then the true false results is found by
69** consulting sqlite3aLTb[opcode], sqlite3aEQb[opcode], or
70** sqlite3aGTb[opcode] depending on whether the result of compare(A,B)
71** is negative, zero, or positive, where opcode is the specific opcode.
72** The only works because the comparison opcodes are consecutive and in
73** this order: NE EQ GT LE LT GE. Various assert()s throughout the code
74** ensure that is the case.
75**
76** These elements must be appended to another array. Otherwise the
77** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus
78** be undefined behavior. That's goofy, but the C-standards people thought
79** it was a good idea, so here we are.
80*/
81/* NE EQ GT LE LT GE */
82 1, 0, 0, 1, 1, 0, /* aLTb[]: Use when compare(A,B) less than zero */
83 0, 1, 0, 1, 0, 1, /* aEQb[]: Use when compare(A,B) equals zero */
84 1, 0, 1, 0, 0, 1 /* aGTb[]: Use when compare(A,B) greater than zero*/
85};
86const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne];
87const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne];
88const unsigned char *sqlite3aGTb = &sqlite3UpperToLower[256+12-OP_Ne];
89
90/*
91** The following 256 byte lookup table is used to support SQLites built-in
92** equivalents to the following standard library functions:
93**
94** isspace() 0x01
95** isalpha() 0x02
96** isdigit() 0x04
97** isalnum() 0x06
98** isxdigit() 0x08
99** toupper() 0x20
100** SQLite identifier character 0x40
101** Quote character 0x80
102**
103** Bit 0x20 is set if the mapped character requires translation to upper
104** case. i.e. if the character is a lower-case ASCII character.
105** If x is a lower-case ASCII character, then its upper-case equivalent
106** is (x - 0x20). Therefore toupper() can be implemented as:
107**
108** (x & ~(map[x]&0x20))
109**
110** The equivalent of tolower() is implemented using the sqlite3UpperToLower[]
111** array. tolower() is used more often than toupper() by SQLite.
112**
113** Bit 0x40 is set if the character is non-alphanumeric and can be used in an
114** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any
115** non-ASCII UTF character. Hence the test for whether or not a character is
116** part of an identifier is 0x46.
117*/
118const unsigned char sqlite3CtypeMap[256] = {
119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */
120 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */
121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */
122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */
123 0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80, /* 20..27 !"#$%&' */
124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */
125 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */
126 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */
127
128 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */
129 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */
130 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */
131 0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */
132 0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */
133 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */
134 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */
135 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */
136
137 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */
138 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */
139 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */
140 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */
141 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */
142 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */
143 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */
144 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */
145
146 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */
147 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */
148 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */
149 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */
150 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */
151 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */
152 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */
153 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */
154};
155
156/* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards
157** compatibility for legacy applications, the URI filename capability is
158** disabled by default.
159**
160** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled
161** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
162**
163** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally
164** disabled. The default value may be changed by compiling with the
165** SQLITE_USE_URI symbol defined.
166*/
167#ifndef SQLITE_USE_URI
168# define SQLITE_USE_URI 0
169#endif
170
171/* EVIDENCE-OF: R-38720-18127 The default setting is determined by the
172** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
173** that compile-time option is omitted.
174*/
175#if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN)
176# define SQLITE_ALLOW_COVERING_INDEX_SCAN 1
177#else
178# if !SQLITE_ALLOW_COVERING_INDEX_SCAN
179# error "Compile-time disabling of covering index scan using the\
180 -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\
181 Contact SQLite developers if this is a problem for you, and\
182 delete this #error macro to continue with your build."
183# endif
184#endif
185
186/* The minimum PMA size is set to this value multiplied by the database
187** page size in bytes.
188*/
189#ifndef SQLITE_SORTER_PMASZ
190# define SQLITE_SORTER_PMASZ 250
191#endif
192
193/* Statement journals spill to disk when their size exceeds the following
194** threshold (in bytes). 0 means that statement journals are created and
195** written to disk immediately (the default behavior for SQLite versions
196** before 3.12.0). -1 means always keep the entire statement journal in
197** memory. (The statement journal is also always held entirely in memory
198** if journal_mode=MEMORY or if temp_store=MEMORY, regardless of this
199** setting.)
200*/
201#ifndef SQLITE_STMTJRNL_SPILL
202# define SQLITE_STMTJRNL_SPILL (64*1024)
203#endif
204
205/*
206** The default lookaside-configuration, the format "SZ,N". SZ is the
207** number of bytes in each lookaside slot (should be a multiple of 8)
208** and N is the number of slots. The lookaside-configuration can be
209** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
210** or at run-time for an individual database connection using
211** sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE);
212**
213** With the two-size-lookaside enhancement, less lookaside is required.
214** The default configuration of 1200,40 actually provides 30 1200-byte slots
215** and 93 128-byte slots, which is more lookaside than is available
216** using the older 1200,100 configuration without two-size-lookaside.
217*/
218#ifndef SQLITE_DEFAULT_LOOKASIDE
219# ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE
220# define SQLITE_DEFAULT_LOOKASIDE 1200,100 /* 120KB of memory */
221# else
222# define SQLITE_DEFAULT_LOOKASIDE 1200,40 /* 48KB of memory */
223# endif
224#endif
225
226
227/* The default maximum size of an in-memory database created using
228** sqlite3_deserialize()
229*/
230#ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE
231# define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824
232#endif
233
234/*
235** The following singleton contains the global configuration for
236** the SQLite library.
237*/
238SQLITE_WSD struct Sqlite3Config sqlite3Config = {
239 SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */
240 1, /* bCoreMutex */
241 SQLITE_THREADSAFE==1, /* bFullMutex */
242 SQLITE_USE_URI, /* bOpenUri */
243 SQLITE_ALLOW_COVERING_INDEX_SCAN, /* bUseCis */
244 0, /* bSmallMalloc */
245 1, /* bExtraSchemaChecks */
246 0x7ffffffe, /* mxStrlen */
247 0, /* neverCorrupt */
248 SQLITE_DEFAULT_LOOKASIDE, /* szLookaside, nLookaside */
249 SQLITE_STMTJRNL_SPILL, /* nStmtSpill */
250 {0,0,0,0,0,0,0,0}, /* m */
251 {0,0,0,0,0,0,0,0,0}, /* mutex */
252 {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
253 (void*)0, /* pHeap */
254 0, /* nHeap */
255 0, 0, /* mnHeap, mxHeap */
256 SQLITE_DEFAULT_MMAP_SIZE, /* szMmap */
257 SQLITE_MAX_MMAP_SIZE, /* mxMmap */
258 (void*)0, /* pPage */
259 0, /* szPage */
260 SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */
261 0, /* mxParserStack */
262 0, /* sharedCacheEnabled */
263 SQLITE_SORTER_PMASZ, /* szPma */
264 /* All the rest should always be initialized to zero */
265 0, /* isInit */
266 0, /* inProgress */
267 0, /* isMutexInit */
268 0, /* isMallocInit */
269 0, /* isPCacheInit */
270 0, /* nRefInitMutex */
271 0, /* pInitMutex */
272 0, /* xLog */
273 0, /* pLogArg */
274#ifdef SQLITE_ENABLE_SQLLOG
275 0, /* xSqllog */
276 0, /* pSqllogArg */
277#endif
278#ifdef SQLITE_VDBE_COVERAGE
279 0, /* xVdbeBranch */
280 0, /* pVbeBranchArg */
281#endif
282#ifndef SQLITE_OMIT_DESERIALIZE
283 SQLITE_MEMDB_DEFAULT_MAXSIZE, /* mxMemdbSize */
284#endif
285#ifndef SQLITE_UNTESTABLE
286 0, /* xTestCallback */
287#endif
288 0, /* bLocaltimeFault */
289 0, /* xAltLocaltime */
290 0x7ffffffe, /* iOnceResetThreshold */
291 SQLITE_DEFAULT_SORTERREF_SIZE, /* szSorterRef */
292 0, /* iPrngSeed */
293#ifdef SQLITE_DEBUG
294 {0,0,0,0,0,0} /* aTune */
295#endif
296};
297
298/*
299** Hash table for global functions - functions common to all
300** database connections. After initialization, this table is
301** read-only.
302*/
303FuncDefHash sqlite3BuiltinFunctions;
304
305#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
306/*
307** Counter used for coverage testing. Does not come into play for
308** release builds.
309**
310** Access to this global variable is not mutex protected. This might
311** result in TSAN warnings. But as the variable does not exist in
312** release builds, that should not be a concern.
313*/
314unsigned int sqlite3CoverageCounter;
315#endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */
316
317#ifdef VDBE_PROFILE
318/*
319** The following performance counter can be used in place of
320** sqlite3Hwtime() for profiling. This is a no-op on standard builds.
321*/
322sqlite3_uint64 sqlite3NProfileCnt = 0;
323#endif
324
325/*
326** The value of the "pending" byte must be 0x40000000 (1 byte past the
327** 1-gibabyte boundary) in a compatible database. SQLite never uses
328** the database page that contains the pending byte. It never attempts
329** to read or write that page. The pending byte page is set aside
330** for use by the VFS layers as space for managing file locks.
331**
332** During testing, it is often desirable to move the pending byte to
333** a different position in the file. This allows code that has to
334** deal with the pending byte to run on files that are much smaller
335** than 1 GiB. The sqlite3_test_control() interface can be used to
336** move the pending byte.
337**
338** IMPORTANT: Changing the pending byte to any value other than
339** 0x40000000 results in an incompatible database file format!
340** Changing the pending byte during operation will result in undefined
341** and incorrect behavior.
342*/
343#ifndef SQLITE_OMIT_WSD
344int sqlite3PendingByte = 0x40000000;
345#endif
346
347/*
348** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
349*/
350u32 sqlite3TreeTrace = 0;
351u32 sqlite3WhereTrace = 0;
352
353#include "opcodes.h"
354/*
355** Properties of opcodes. The OPFLG_INITIALIZER macro is
356** created by mkopcodeh.awk during compilation. Data is obtained
357** from the comments following the "case OP_xxxx:" statements in
358** the vdbe.c file.
359*/
360const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
361
362/*
363** Name of the default collating sequence
364*/
365const char sqlite3StrBINARY[] = "BINARY";
366
367/*
368** Standard typenames. These names must match the COLTYPE_* definitions.
369** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
370**
371** sqlite3StdType[] The actual names of the datatypes.
372**
373** sqlite3StdTypeLen[] The length (in bytes) of each entry
374** in sqlite3StdType[].
375**
376** sqlite3StdTypeAffinity[] The affinity associated with each entry
377** in sqlite3StdType[].
378*/
379const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 };
380const char sqlite3StdTypeAffinity[] = {
381 SQLITE_AFF_NUMERIC,
382 SQLITE_AFF_BLOB,
383 SQLITE_AFF_INTEGER,
384 SQLITE_AFF_INTEGER,
385 SQLITE_AFF_REAL,
386 SQLITE_AFF_TEXT
387};
388const char *sqlite3StdType[] = {
389 "ANY",
390 "BLOB",
391 "INT",
392 "INTEGER",
393 "REAL",
394 "TEXT"
395};
396