src/global.c

   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 ** URI filenames are enabled by default if SQLITE_HAS_CODEC is
 168 ** enabled.
 169 */
 170 #ifndef SQLITE_USE_URI
 171 /* BEGIN SQLCIPHER */
 172 # ifdef SQLITE_HAS_CODEC
 173 #  define SQLITE_USE_URI 1
 174 # else
 175 #  define SQLITE_USE_URI 0
 176 # endif
 177 /* END SQLCIPHER */
 178 #endif
 179
 180 /* EVIDENCE-OF: R-38720-18127 The default setting is determined by the
 181 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
 182 ** that compile-time option is omitted.
 183 */
 184 #if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN)
 185 # define SQLITE_ALLOW_COVERING_INDEX_SCAN 1
 186 #else
 187 # if !SQLITE_ALLOW_COVERING_INDEX_SCAN
 188 #   error "Compile-time disabling of covering index scan using the\
 189  -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\
 190  Contact SQLite developers if this is a problem for you, and\
 191  delete this #error macro to continue with your build."
 192 # endif
 193 #endif
 194
 195 /* The minimum PMA size is set to this value multiplied by the database
 196 ** page size in bytes.
 197 */
 198 #ifndef SQLITE_SORTER_PMASZ
 199 # define SQLITE_SORTER_PMASZ 250
 200 #endif
 201
 202 /* Statement journals spill to disk when their size exceeds the following
 203 ** threshold (in bytes). 0 means that statement journals are created and
 204 ** written to disk immediately (the default behavior for SQLite versions
 205 ** before 3.12.0).  -1 means always keep the entire statement journal in
 206 ** memory.  (The statement journal is also always held entirely in memory
 207 ** if journal_mode=MEMORY or if temp_store=MEMORY, regardless of this
 208 ** setting.)
 209 */
 210 #ifndef SQLITE_STMTJRNL_SPILL
 211 # define SQLITE_STMTJRNL_SPILL (64*1024)
 212 #endif
 213
 214 /*
 215 ** The default lookaside-configuration, the format "SZ,N".  SZ is the
 216 ** number of bytes in each lookaside slot (should be a multiple of 8)
 217 ** and N is the number of slots.  The lookaside-configuration can be
 218 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
 219 ** or at run-time for an individual database connection using
 220 ** sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE);
 221 **
 222 ** With the two-size-lookaside enhancement, less lookaside is required.
 223 ** The default configuration of 1200,40 actually provides 30 1200-byte slots
 224 ** and 93 128-byte slots, which is more lookaside than is available
 225 ** using the older 1200,100 configuration without two-size-lookaside.
 226 */
 227 #ifndef SQLITE_DEFAULT_LOOKASIDE
 228 # ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE
 229 #   define SQLITE_DEFAULT_LOOKASIDE 1200,100  /* 120KB of memory */
 230 # else
 231 #   define SQLITE_DEFAULT_LOOKASIDE 1200,40   /* 48KB of memory */
 232 # endif
 233 #endif
 234
 235
 236 /* The default maximum size of an in-memory database created using
 237 ** sqlite3_deserialize()
 238 */
 239 #ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE
 240 # define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824
 241 #endif
 242
 243 /*
 244 ** The following singleton contains the global configuration for
 245 ** the SQLite library.
 246 */
 247 SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 248    SQLITE_DEFAULT_MEMSTATUS,  /* bMemstat */
 249    1,                         /* bCoreMutex */
 250    SQLITE_THREADSAFE==1,      /* bFullMutex */
 251    SQLITE_USE_URI,            /* bOpenUri */
 252    SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */
 253    0,                         /* bSmallMalloc */
 254    1,                         /* bExtraSchemaChecks */
 255    0x7ffffffe,                /* mxStrlen */
 256    0,                         /* neverCorrupt */
 257    SQLITE_DEFAULT_LOOKASIDE,  /* szLookaside, nLookaside */
 258    SQLITE_STMTJRNL_SPILL,     /* nStmtSpill */
 259    {0,0,0,0,0,0,0,0},         /* m */
 260    {0,0,0,0,0,0,0,0,0},       /* mutex */
 261    {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
 262    (void*)0,                  /* pHeap */
 263    0,                         /* nHeap */
 264    0, 0,                      /* mnHeap, mxHeap */
 265    SQLITE_DEFAULT_MMAP_SIZE,  /* szMmap */
 266    SQLITE_MAX_MMAP_SIZE,      /* mxMmap */
 267    (void*)0,                  /* pPage */
 268    0,                         /* szPage */
 269    SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */
 270    0,                         /* mxParserStack */
 271    0,                         /* sharedCacheEnabled */
 272    SQLITE_SORTER_PMASZ,       /* szPma */
 273    /* All the rest should always be initialized to zero */
 274    0,                         /* isInit */
 275    0,                         /* inProgress */
 276    0,                         /* isMutexInit */
 277    0,                         /* isMallocInit */
 278    0,                         /* isPCacheInit */
 279    0,                         /* nRefInitMutex */
 280    0,                         /* pInitMutex */
 281    0,                         /* xLog */
 282    0,                         /* pLogArg */
 283 #ifdef SQLITE_ENABLE_SQLLOG
 284    0,                         /* xSqllog */
 285    0,                         /* pSqllogArg */
 286 #endif
 287 #ifdef SQLITE_VDBE_COVERAGE
 288    0,                         /* xVdbeBranch */
 289    0,                         /* pVbeBranchArg */
 290 #endif
 291 #ifndef SQLITE_OMIT_DESERIALIZE
 292    SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */
 293 #endif
 294 #ifndef SQLITE_UNTESTABLE
 295    0,                         /* xTestCallback */
 296 #endif
 297    0,                         /* bLocaltimeFault */
 298    0,                         /* xAltLocaltime */
 299    0x7ffffffe,                /* iOnceResetThreshold */
 300    SQLITE_DEFAULT_SORTERREF_SIZE,   /* szSorterRef */
 301    0,                         /* iPrngSeed */
 302 #ifdef SQLITE_DEBUG
 303    {0,0,0,0,0,0}              /* aTune */
 304 #endif
 305 };
 306
 307 /*
 308 ** Hash table for global functions - functions common to all
 309 ** database connections.  After initialization, this table is
 310 ** read-only.
 311 */
 312 FuncDefHash sqlite3BuiltinFunctions;
 313
 314 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
 315 /*
 316 ** Counter used for coverage testing.  Does not come into play for
 317 ** release builds.
 318 **
 319 ** Access to this global variable is not mutex protected.  This might
 320 ** result in TSAN warnings.  But as the variable does not exist in
 321 ** release builds, that should not be a concern.
 322 */
 323 unsigned int sqlite3CoverageCounter;
 324 #endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */
 325
 326 #ifdef VDBE_PROFILE
 327 /*
 328 ** The following performance counter can be used in place of
 329 ** sqlite3Hwtime() for profiling.  This is a no-op on standard builds.
 330 */
 331 sqlite3_uint64 sqlite3NProfileCnt = 0;
 332 #endif
 333
 334 /*
 335 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
 336 ** 1-gibabyte boundary) in a compatible database.  SQLite never uses
 337 ** the database page that contains the pending byte.  It never attempts
 338 ** to read or write that page.  The pending byte page is set aside
 339 ** for use by the VFS layers as space for managing file locks.
 340 **
 341 ** During testing, it is often desirable to move the pending byte to
 342 ** a different position in the file.  This allows code that has to
 343 ** deal with the pending byte to run on files that are much smaller
 344 ** than 1 GiB.  The sqlite3_test_control() interface can be used to
 345 ** move the pending byte.
 346 **
 347 ** IMPORTANT:  Changing the pending byte to any value other than
 348 ** 0x40000000 results in an incompatible database file format!
 349 ** Changing the pending byte during operation will result in undefined
 350 ** and incorrect behavior.
 351 */
 352 #ifndef SQLITE_OMIT_WSD
 353 int sqlite3PendingByte = 0x40000000;
 354 #endif
 355
 356 /*
 357 ** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
 358 */
 359 u32 sqlite3TreeTrace = 0;
 360 u32 sqlite3WhereTrace = 0;
 361
 362 #include "opcodes.h"
 363 /*
 364 ** Properties of opcodes.  The OPFLG_INITIALIZER macro is
 365 ** created by mkopcodeh.awk during compilation.  Data is obtained
 366 ** from the comments following the "case OP_xxxx:" statements in
 367 ** the vdbe.c file.
 368 */
 369 const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
 370
 371 /*
 372 ** Name of the default collating sequence
 373 */
 374 const char sqlite3StrBINARY[] = "BINARY";
 375
 376 /*
 377 ** Standard typenames.  These names must match the COLTYPE_* definitions.
 378 ** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
 379 **
 380 **    sqlite3StdType[]            The actual names of the datatypes.
 381 **
 382 **    sqlite3StdTypeLen[]         The length (in bytes) of each entry
 383 **                                in sqlite3StdType[].
 384 **
 385 **    sqlite3StdTypeAffinity[]    The affinity associated with each entry
 386 **                                in sqlite3StdType[].
 387 **
 388 **    sqlite3StdTypeMap[]         The type value (as returned from
 389 **                                sqlite3_column_type() or sqlite3_value_type())
 390 **                                for each entry in sqlite3StdType[].
 391 */
 392 const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 };
 393 const char sqlite3StdTypeAffinity[] = {
 394   SQLITE_AFF_NUMERIC,
 395   SQLITE_AFF_BLOB,
 396   SQLITE_AFF_INTEGER,
 397   SQLITE_AFF_INTEGER,
 398   SQLITE_AFF_REAL,
 399   SQLITE_AFF_TEXT
 400 };
 401 const char sqlite3StdTypeMap[] = {
 402   0,
 403   SQLITE_BLOB,
 404   SQLITE_INTEGER,
 405   SQLITE_INTEGER,
 406   SQLITE_FLOAT,
 407   SQLITE_TEXT
 408 };
 409 const char *sqlite3StdType[] = {
 410   "ANY",
 411   "BLOB",
 412   "INT",
 413   "INTEGER",
 414   "REAL",
 415   "TEXT"
 416 };