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