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 | */ |
24 | const 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 | }; |
86 | const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne]; |
87 | const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne]; |
88 | const 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 | */ |
118 | const 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 | */ |
238 | SQLITE_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 | */ |
303 | FuncDefHash 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 | */ |
314 | unsigned 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 | */ |
322 | sqlite3_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 |
344 | int sqlite3PendingByte = 0x40000000; |
345 | #endif |
346 | |
347 | /* |
348 | ** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS. |
349 | */ |
350 | u32 sqlite3TreeTrace = 0; |
351 | u32 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 | */ |
360 | const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; |
361 | |
362 | /* |
363 | ** Name of the default collating sequence |
364 | */ |
365 | const 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 | */ |
379 | const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 }; |
380 | const 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 | }; |
388 | const char *sqlite3StdType[] = { |
389 | "ANY" , |
390 | "BLOB" , |
391 | "INT" , |
392 | "INTEGER" , |
393 | "REAL" , |
394 | "TEXT" |
395 | }; |
396 | |