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 };
  61
  62 /*
  63 ** The following 256 byte lookup table is used to support SQLites built-in
  64 ** equivalents to the following standard library functions:
  65 **
  66 **   isspace()                        0x01
  67 **   isalpha()                        0x02
  68 **   isdigit()                        0x04
  69 **   isalnum()                        0x06
  70 **   isxdigit()                       0x08
  71 **   toupper()                        0x20
  72 **   SQLite identifier character      0x40
  73 **   Quote character                  0x80
  74 **
  75 ** Bit 0x20 is set if the mapped character requires translation to upper
  76 ** case. i.e. if the character is a lower-case ASCII character.
  77 ** If x is a lower-case ASCII character, then its upper-case equivalent
  78 ** is (x - 0x20). Therefore toupper() can be implemented as:
  79 **
  80 **   (x & ~(map[x]&0x20))
  81 **
  82 ** The equivalent of tolower() is implemented using the sqlite3UpperToLower[]
  83 ** array. tolower() is used more often than toupper() by SQLite.
  84 **
  85 ** Bit 0x40 is set if the character is non-alphanumeric and can be used in an
  86 ** SQLite identifier.  Identifiers are alphanumerics, "_", "$", and any
  87 ** non-ASCII UTF character. Hence the test for whether or not a character is
  88 ** part of an identifier is 0x46.
  89 */
  90 const unsigned char sqlite3CtypeMap[256] = {
  91   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 00..07    ........ */
  92   0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,  /* 08..0f    ........ */
  93   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 10..17    ........ */
  94   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 18..1f    ........ */
  95   0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80,  /* 20..27     !"#$%&' */
  96   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 28..2f    ()*+,-./ */
  97   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,  /* 30..37    01234567 */
  98   0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 38..3f    89:;<=>? */
  99
 100   0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02,  /* 40..47    @ABCDEFG */
 101   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 48..4f    HIJKLMNO */
 102   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 50..57    PQRSTUVW */
 103   0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40,  /* 58..5f    XYZ[\]^_ */
 104   0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22,  /* 60..67    `abcdefg */
 105   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 68..6f    hijklmno */
 106   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 70..77    pqrstuvw */
 107   0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 78..7f    xyz{|}~. */
 108
 109   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 80..87    ........ */
 110   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 88..8f    ........ */
 111   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 90..97    ........ */
 112   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 98..9f    ........ */
 113   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a0..a7    ........ */
 114   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a8..af    ........ */
 115   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b0..b7    ........ */
 116   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b8..bf    ........ */
 117
 118   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c0..c7    ........ */
 119   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c8..cf    ........ */
 120   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d0..d7    ........ */
 121   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d8..df    ........ */
 122   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e0..e7    ........ */
 123   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e8..ef    ........ */
 124   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* f0..f7    ........ */
 125   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40   /* f8..ff    ........ */
 126 };
 127
 128 /* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards
 129 ** compatibility for legacy applications, the URI filename capability is
 130 ** disabled by default.
 131 **
 132 ** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled
 133 ** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
 134 **
 135 ** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally
 136 ** disabled. The default value may be changed by compiling with the
 137 ** SQLITE_USE_URI symbol defined.
 138 **
 139 ** URI filenames are enabled by default if SQLITE_HAS_CODEC is
 140 ** enabled.
 141 */
 142 #ifndef SQLITE_USE_URI
 143 /* BEGIN SQLCIPHER */
 144 # ifdef SQLITE_HAS_CODEC
 145 #  define SQLITE_USE_URI 1
 146 # else
 147 #  define SQLITE_USE_URI 0
 148 # endif
 149 /* END SQLCIPHER */
 150 #endif
 151
 152 /* EVIDENCE-OF: R-38720-18127 The default setting is determined by the
 153 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
 154 ** that compile-time option is omitted.
 155 */
 156 #if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN)
 157 # define SQLITE_ALLOW_COVERING_INDEX_SCAN 1
 158 #else
 159 # if !SQLITE_ALLOW_COVERING_INDEX_SCAN
 160 #   error "Compile-time disabling of covering index scan using the\
 161  -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\
 162  Contact SQLite developers if this is a problem for you, and\
 163  delete this #error macro to continue with your build."
 164 # endif
 165 #endif
 166
 167 /* The minimum PMA size is set to this value multiplied by the database
 168 ** page size in bytes.
 169 */
 170 #ifndef SQLITE_SORTER_PMASZ
 171 # define SQLITE_SORTER_PMASZ 250
 172 #endif
 173
 174 /* Statement journals spill to disk when their size exceeds the following
 175 ** threshold (in bytes). 0 means that statement journals are created and
 176 ** written to disk immediately (the default behavior for SQLite versions
 177 ** before 3.12.0).  -1 means always keep the entire statement journal in
 178 ** memory.  (The statement journal is also always held entirely in memory
 179 ** if journal_mode=MEMORY or if temp_store=MEMORY, regardless of this
 180 ** setting.)
 181 */
 182 #ifndef SQLITE_STMTJRNL_SPILL
 183 # define SQLITE_STMTJRNL_SPILL (64*1024)
 184 #endif
 185
 186 /*
 187 ** The default lookaside-configuration, the format "SZ,N".  SZ is the
 188 ** number of bytes in each lookaside slot (should be a multiple of 8)
 189 ** and N is the number of slots.  The lookaside-configuration can be
 190 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
 191 ** or at run-time for an individual database connection using
 192 ** sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE);
 193 **
 194 ** With the two-size-lookaside enhancement, less lookaside is required.
 195 ** The default configuration of 1200,40 actually provides 30 1200-byte slots
 196 ** and 93 128-byte slots, which is more lookaside than is available
 197 ** using the older 1200,100 configuration without two-size-lookaside.
 198 */
 199 #ifndef SQLITE_DEFAULT_LOOKASIDE
 200 # ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE
 201 #   define SQLITE_DEFAULT_LOOKASIDE 1200,100  /* 120KB of memory */
 202 # else
 203 #   define SQLITE_DEFAULT_LOOKASIDE 1200,40   /* 48KB of memory */
 204 # endif
 205 #endif
 206
 207
 208 /* The default maximum size of an in-memory database created using
 209 ** sqlite3_deserialize()
 210 */
 211 #ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE
 212 # define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824
 213 #endif
 214
 215 /*
 216 ** The following singleton contains the global configuration for
 217 ** the SQLite library.
 218 */
 219 SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 220    SQLITE_DEFAULT_MEMSTATUS,  /* bMemstat */
 221    1,                         /* bCoreMutex */
 222    SQLITE_THREADSAFE==1,      /* bFullMutex */
 223    SQLITE_USE_URI,            /* bOpenUri */
 224    SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */
 225    0,                         /* bSmallMalloc */
 226    1,                         /* bExtraSchemaChecks */
 227    0x7ffffffe,                /* mxStrlen */
 228    0,                         /* neverCorrupt */
 229    SQLITE_DEFAULT_LOOKASIDE,  /* szLookaside, nLookaside */
 230    SQLITE_STMTJRNL_SPILL,     /* nStmtSpill */
 231    {0,0,0,0,0,0,0,0},         /* m */
 232    {0,0,0,0,0,0,0,0,0},       /* mutex */
 233    {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
 234    (void*)0,                  /* pHeap */
 235    0,                         /* nHeap */
 236    0, 0,                      /* mnHeap, mxHeap */
 237    SQLITE_DEFAULT_MMAP_SIZE,  /* szMmap */
 238    SQLITE_MAX_MMAP_SIZE,      /* mxMmap */
 239    (void*)0,                  /* pPage */
 240    0,                         /* szPage */
 241    SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */
 242    0,                         /* mxParserStack */
 243    0,                         /* sharedCacheEnabled */
 244    SQLITE_SORTER_PMASZ,       /* szPma */
 245    /* All the rest should always be initialized to zero */
 246    0,                         /* isInit */
 247    0,                         /* inProgress */
 248    0,                         /* isMutexInit */
 249    0,                         /* isMallocInit */
 250    0,                         /* isPCacheInit */
 251    0,                         /* nRefInitMutex */
 252    0,                         /* pInitMutex */
 253    0,                         /* xLog */
 254    0,                         /* pLogArg */
 255 #ifdef SQLITE_ENABLE_SQLLOG
 256    0,                         /* xSqllog */
 257    0,                         /* pSqllogArg */
 258 #endif
 259 #ifdef SQLITE_VDBE_COVERAGE
 260    0,                         /* xVdbeBranch */
 261    0,                         /* pVbeBranchArg */
 262 #endif
 263 #ifdef SQLITE_ENABLE_DESERIALIZE
 264    SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */
 265 #endif
 266 #ifndef SQLITE_UNTESTABLE
 267    0,                         /* xTestCallback */
 268 #endif
 269    0,                         /* bLocaltimeFault */
 270    0x7ffffffe,                /* iOnceResetThreshold */
 271    SQLITE_DEFAULT_SORTERREF_SIZE,   /* szSorterRef */
 272    0,                         /* iPrngSeed */
 273 };
 274
 275 /*
 276 ** Hash table for global functions - functions common to all
 277 ** database connections.  After initialization, this table is
 278 ** read-only.
 279 */
 280 FuncDefHash sqlite3BuiltinFunctions;
 281
 282 #ifdef VDBE_PROFILE
 283 /*
 284 ** The following performance counter can be used in place of
 285 ** sqlite3Hwtime() for profiling.  This is a no-op on standard builds.
 286 */
 287 sqlite3_uint64 sqlite3NProfileCnt = 0;
 288 #endif
 289
 290 /*
 291 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
 292 ** 1-gibabyte boundary) in a compatible database.  SQLite never uses
 293 ** the database page that contains the pending byte.  It never attempts
 294 ** to read or write that page.  The pending byte page is set aside
 295 ** for use by the VFS layers as space for managing file locks.
 296 **
 297 ** During testing, it is often desirable to move the pending byte to
 298 ** a different position in the file.  This allows code that has to
 299 ** deal with the pending byte to run on files that are much smaller
 300 ** than 1 GiB.  The sqlite3_test_control() interface can be used to
 301 ** move the pending byte.
 302 **
 303 ** IMPORTANT:  Changing the pending byte to any value other than
 304 ** 0x40000000 results in an incompatible database file format!
 305 ** Changing the pending byte during operation will result in undefined
 306 ** and incorrect behavior.
 307 */
 308 #ifndef SQLITE_OMIT_WSD
 309 int sqlite3PendingByte = 0x40000000;
 310 #endif
 311
 312 /*
 313 ** Flags for select tracing and the ".selecttrace" macro of the CLI
 314 */
 315 u32 sqlite3_unsupported_selecttrace = 0;
 316
 317 #include "opcodes.h"
 318 /*
 319 ** Properties of opcodes.  The OPFLG_INITIALIZER macro is
 320 ** created by mkopcodeh.awk during compilation.  Data is obtained
 321 ** from the comments following the "case OP_xxxx:" statements in
 322 ** the vdbe.c file.
 323 */
 324 const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
 325
 326 /*
 327 ** Name of the default collating sequence
 328 */
 329 const char sqlite3StrBINARY[] = "BINARY";